2.95.2) CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
2.95.*) CXXFLAGS="$lyx_opt -fno-exceptions";;
2.96*) CXXFLAGS="$lyx_opt -fno-exceptions";;
- 3.0*) CXXFLAGS="$lyx_opt";;
+ 3.0*) CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
*2.91.*) CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
*) CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
esac
xforms)
# for now don't set it for xforms as this is always entered
FRONTEND=""
- FRONTEND_GUILIB="xforms/libxforms.la";;
+ FRONTEND_GUILIB="xforms/libxforms.o";;
gnome)
AM_PATH_GTKMM(1.2.1,,
AC_MSG_ERROR(Cannot find GTK--: Please install Version 1.2.1+))
src/CutAndPaste.C
src/debug.C
src/exporter.C
+src/ext_l10n.h
src/figure_form.C
src/figureForm.C
src/FontLoader.C
Makefile: $(BUILT_SOURCES)
%.h: $(M4_DIR)/%.h.m4 $(M4_DIR)/template.macros.m4
- $(M4) $(M4_INCLUDES) $(DEFINES) $< > $(top_srcdir)/$@
+ $(M4) $(M4_INCLUDES) $(DEFINES) $< > $(top_builddir)/$@
all-local: $(noinst_LTLIBRARIES)
// Iterate until we find a paragraph that won't be immediately deleted.
// In reality this should mean we only execute the body of the while
// loop once at most. However for safety we iterate rather than just
- // make this an if() conditional.
+ // make this an if () conditional.
while ((cur_par_prev || cur_par_next)
&& text->setCursor(this,
cur_par_prev ? cur_par_prev : cur_par_next,
}
-bool BufferView::ChangeCitationsIfUnique(string const & from, string const & to)
+bool BufferView::ChangeCitationsIfUnique(string const & from,
+ string const & to)
{
-
- vector<pair<string,string> > keys = buffer()->getBibkeyList();
+ typedef pair<string, string> StringPair;
+
+ vector<StringPair> keys = buffer()->getBibkeyList();
if (count_if(keys.begin(), keys.end(),
- lyx::equal_1st_in_pair<string,string>(from))
+ lyx::equal_1st_in_pair<StringPair>(from))
> 1)
return false;
{
static Cursor cursor;
static bool cursor_undefined = true;
- if (cursor_undefined){
+ if (cursor_undefined) {
cursor = XCreateFontCursor(fl_get_display(), XC_xterm);
XFlush(fl_get_display());
cursor_undefined = false;
text->cursor.y()
- text->cursor.row()->baseline()
+ text->cursor.row()->height()
- - workarea_.height() + 1 );
+ - workarea_.height() + 1);
updateScrollbar();
}
Buffer * b = bufferlist.exists(fname) ?
bufferlist.getBuffer(fname) :
bufferlist.loadLyXFile(fname); // don't ask, just load it
- if (b != 0 ) buffer(b);
+ if (b != 0) buffer(b);
}
Paragraph * par = buffer_->getParFromID(saved_positions[i].par_id);
case LFUN_CITATION_INSERT:
{
InsetCommandParams p;
- p.setFromString( argument );
+ p.setFromString(argument);
- InsetCitation * inset = new InsetCitation( p );
+ InsetCitation * inset = new InsetCitation(p);
if (!insertInset(inset))
delete inset;
else
- updateInset( inset, true );
+ updateInset(inset, true);
}
break;
string const db = token(argument, ' ', 0);
string const bibstyle = token(argument, ' ', 1);
- InsetCommandParams p( "BibTeX", db, bibstyle );
+ InsetCommandParams p("BibTeX", db, bibstyle);
InsetBibtex * inset = new InsetBibtex(p);
if (insertInset(inset)) {
case LFUN_PARENTINSERT:
{
lyxerr << "arg " << argument << endl;
- InsetCommandParams p( "lyxparent", argument );
+ InsetCommandParams p("lyxparent", argument);
Inset * inset = new InsetParent(p, *buffer_);
if (!insertInset(inset, "Standard"))
delete inset;
} else if (bv_->theLockingInset()->updateInsetInInset(bv_, inset)) {
if (bv_->text->updateInset(bv_, bv_->theLockingInset())) {
update();
- if (mark_dirty){
+ if (mark_dirty) {
buffer_->markDirty();
}
updateScrollbar();
/** The four LaTeX itemize environment default bullets
*/
extern
-Bullet const ITEMIZE_DEFAULTS[4] = { Bullet( 0, 8 ),//"\\(\\bullet\\)"
- Bullet( 0, 0 ),//"\\normalfont\\bfseries{--}"
- Bullet( 0, 6 ),//"\\(\\ast\\)"
- Bullet( 0, 10 ) };//"\\(\\cdot\\)"
+Bullet const ITEMIZE_DEFAULTS[4] = { Bullet(0, 8),//"\\(\\bullet\\)"
+ Bullet(0, 0),//"\\normalfont\\bfseries{--}"
+ Bullet(0, 6),//"\\(\\ast\\)"
+ Bullet(0, 10) };//"\\(\\cdot\\)"
// will need these later if still using full text as below
// \usepackage{latexsym,pifont,amssymb}
+2002-02-16 Lars Gullik Bjønnes <larsbj@lyx.org>
+
+ * a lot of small ws changes
+ * add a lot of using std::XXX
+ * use std construcs some places where approp.
+ * use some exisint stuff from lyxfunctional where approp.
+ * Make file changes to use partial linking (lets test this now...)
+
2002-02-16 Angus Leeming <a.leeming@ic.ac.uk>
* Chktex.C:
}
-bool DepTable::ext_exist(const string& ext ) const
+bool DepTable::ext_exist(const string& ext) const
{
DepList::const_iterator cit = deplist.begin();
DepList::const_iterator end = deplist.end();
- for (; cit != end; ++cit ) {
+ for (; cit != end; ++cit) {
if (suffixIs(cit->first, ext)) {
return true;
}
}
getFontinfo(family, series, shape);
- int fsize = int( (lyxrc.font_sizes[size] * lyxrc.dpi *
- (lyxrc.zoom/100.0) ) / 72.27 + 0.5 );
+ int fsize = int((lyxrc.font_sizes[size] * lyxrc.dpi *
+ (lyxrc.zoom/100.0)) / 72.27 + 0.5);
string font = fontinfo[family][series][shape]->getFontname(fsize);
using std::endl;
using std::set;
+using std::vector;
+using std::find;
+using std::ostream;
+
LaTeXFeatures::LaTeXFeatures(BufferParams const & p, layout_type n)
: layout(n, false), params(p)
}
-void LaTeXFeatures::useLayout(std::vector<bool>::size_type const & idx)
+void LaTeXFeatures::useLayout(vector<bool>::size_type const & idx)
{
layout[idx] = true;
}
bool LaTeXFeatures::isRequired(string const & name) const
{
- FeaturesList::const_iterator i = std::find(features.begin(),
- features.end(),
- name);
+ FeaturesList::const_iterator i = find(features.begin(),
+ features.end(),
+ name);
return i != features.end();
}
for (FileMap::const_iterator fi = IncludedFiles.begin();
fi != end; ++fi)
sgmlpreamble << "\n<!ENTITY " << fi->first
- << (IsSGMLFilename(fi->second) ? " SYSTEM \"" : " \"" )
+ << (IsSGMLFilename(fi->second) ? " SYSTEM \"" : " \"")
<< MakeRelPath(fi->second, basename) << "\">";
return sgmlpreamble.str().c_str();
return params;
}
-void LaTeXFeatures::getFloatDefinitions(std::ostream & os) const
+void LaTeXFeatures::getFloatDefinitions(ostream & os) const
{
// Here we will output the code to create the needed float styles.
// We will try to do this as minimal as possible.
command += " &"; // execute in background
// push directorypath, if necessary
string path = buffer->filePath();
- if (lyxrc.use_tempdir || !IsDirWriteable(path)){
+ if (lyxrc.use_tempdir || !IsDirWriteable(path)) {
path = buffer->tmppath;
}
Path p(path);
if (view()->available()) {
string const cur_title = buffer()->fileName();
- if (!cur_title.empty()){
+ if (!cur_title.empty()) {
title += ": " + MakeDisplayPath(cur_title, 30);
if (!buffer()->isLyxClean())
title += _(" (Changed)");
MAINTAINERCLEANFILES = $(srcdir)/Makefile.in $(srcdir)/config.h.in
bin_PROGRAMS = lyx
-lyx_DEPENDENCIES = mathed/libmathed.la insets/libinsets.la \
- graphics/libgraphics.la \
- frontends/libfrontends.la \
- support/libsupport.la \
+lyx_DEPENDENCIES = mathed/libmathed.o insets/libinsets.o \
+ graphics/libgraphics.o \
+ frontends/libfrontends.o \
+ support/libsupport.o \
@INCLUDED_SIGC@
lyx_LDADD = $(lyx_DEPENDENCIES) @INTLLIBS@ $(SIGC_LIBS) \
- $(PSPELL_LIBS) @AIKSAURUS_LIBS@
+ $(PSPELL_LIBS) @AIKSAURUS_LIBS@ @LYX_LIBS@
#lyx_LDFLAGS=-Wl,-O1
EXTRA_DIST = config.h.in stamp-h.in cheaders ext_l10n.h version.C.in \
#include "Thesaurus.h"
+#ifdef HAVE_LIBAIKSAURUS
+
#include <algorithm>
-Thesaurus thesaurus;
+using std::sort;
-#ifdef HAVE_LIBAIKSAURUS
-
Thesaurus::Thesaurus()
{
aik_ = new Aiksaurus;
for (Meanings::iterator it = meanings.begin();
it != meanings.end(); ++it) {
- std::sort(it->second.begin(), it->second.end());
+ sort(it->second.begin(), it->second.end());
}
return meanings;
}
#endif // HAVE_LIBAIKSAURUS
+
+// Global instance
+Thesaurus thesaurus;
using std::endl;
using std::abs;
+using std::hex;
FL_OBJECT * figinset_canvas;
if (!area) return 1;
- switch (event){
+ switch (event) {
case FL_DRAW:
if (!area->work_area ||
!area->work_area->form->visible)
if (fl_check_forms() == FL_EVENT) {
fl_XNextEvent(&ev);
lyxerr << "Received unhandled X11 event" << endl;
- lyxerr << "Type: 0x" << std::hex << ev.xany.type <<
- "Target: 0x" << std::hex << ev.xany.window << endl;
+ lyxerr << "Type: 0x" << hex << ev.xany.type <<
+ "Target: 0x" << hex << ev.xany.window << endl;
}
}
return clipboard_selection;
static Cursor cursor;
static bool cursor_undefined = true;
- if (cursor_undefined){
+ if (cursor_undefined) {
cursor = XCreateFontCursor(fl_get_display(), XC_watch);
XFlush(fl_get_display());
cursor_undefined = false;
} else if (tmptok == "Note") {
inset = new InsetNote;
} else if (tmptok == "Include") {
- InsetCommandParams p( "Include" );
+ InsetCommandParams p("Include");
inset = new InsetInclude(p, *this);
} else if (tmptok == "ERT") {
inset = new InsetERT;
// original_path is set. This is done for usual tex-file, but not
// for nice-latex-file. (Matthias 250696)
if (!only_body) {
- if (!nice){
+ if (!nice) {
// code for usual, NOT nice-latex-file
ofs << "\\batchmode\n"; // changed
// from \nonstopmode
}
string strOptions(options.str().c_str());
- if (!strOptions.empty()){
+ if (!strOptions.empty()) {
strOptions = strip(strOptions, ',');
ofs << '[' << strOptions << ']';
}
if (par->isInset(0)) {
Inset * inset = par->getInset(0);
Inset::Code lyx_code = inset->lyxCode();
- if (lyx_code == Inset::TOC_CODE){
+ if (lyx_code == Inset::TOC_CODE) {
string const temp = "toc";
sgmlOpenTag(ofs, depth, temp);
_("Error : Wrong depth for"
" LatexType Command.\n"));
- if (!environment_stack[depth].empty()){
+ if (!environment_stack[depth].empty()) {
sgmlCloseTag(ofs, depth,
environment_stack[depth]);
ofs << "</p>";
inline
void reset(PAR_TAG & p1, PAR_TAG const & p2)
{
- p1 = static_cast<PAR_TAG>( p1 & ~p2);
+ p1 = static_cast<PAR_TAG>(p1 & ~p2);
}
} // namespace anon
}
list < PAR_TAG > temp;
- while (!tag_state.empty() && tag_close ) {
+ while (!tag_state.empty() && tag_close) {
PAR_TAG k = tag_state.top();
tag_state.pop();
os << "</" << tag_name(k) << ">";
if (par->isInset(0)) {
Inset * inset = par->getInset(0);
Inset::Code lyx_code = inset->lyxCode();
- if (lyx_code == Inset::LABEL_CODE){
+ if (lyx_code == Inset::LABEL_CODE) {
command_name += " id=\"";
command_name += (static_cast<InsetCommand *>(inset))->getContents();
command_name += "\"";
}
if (environment_stack[depth] != style.latexname()) {
- if(environment_stack.size() == depth + 1) {
+ if (environment_stack.size() == depth + 1) {
environment_stack.push_back("!-- --");
environment_inner.push_back("!-- --");
}
if (style.latextype == LATEX_ENVIRONMENT) {
if (!style.latexparam().empty()) {
- if(style.latexparam() == "CDATA")
+ if (style.latexparam() == "CDATA")
ofs << "<![CDATA[";
else
sgmlOpenTag(ofs, depth + command_depth,
break;
case LATEX_ENVIRONMENT:
if (!style.latexparam().empty()) {
- if(style.latexparam() == "CDATA")
+ if (style.latexparam() == "CDATA")
ofs << "]]>";
else
sgmlCloseTag(ofs, depth + command_depth,
if (font.emph() == LyXFont::ON) {
os << "<emphasis>";
emph_flag = true;
- }else if(i) {
+ } else if (i) {
os << "</emphasis>";
emph_flag = false;
}
}
- if ( par->isInset(i) ) {
+ if (par->isInset(i)) {
Inset * inset = par->getInset(i);
// don't print the inset in position 0 if desc_on == 3 (label)
- if ( i || desc_on != 3)
+ if (i || desc_on != 3)
inset->docbook(this, os);
} else {
char c = par->getChar(i);
if (style.pass_thru) {
os << c;
- } else if(style.free_spacing || par->isFreeSpacing() || c != ' ') {
+ } else if (style.free_spacing || par->isFreeSpacing() || c != ' ') {
os << sgml_string;
} else if (desc_on ==1) {
++char_line_count;
// <term> not closed...
os << "</term>";
}
- if(style.free_spacing) os << '\n';
+ if (style.free_spacing) os << '\n';
}
// if we removed error insets before we ran chktex or if we inserted
// error insets after we ran chktex, this must be run:
- if (removedErrorInsets || res){
+ if (removedErrorInsets || res) {
users->redraw();
users->fitCursor();
}
while (reask) {
switch (Alert::askConfirmation(_("Changes in document:"),
fname,
- _("Save document?"))){
+ _("Save document?"))) {
case 1: // Yes
if (buf->isUnnamed())
reask = !WriteAs(current_view, buf);
text->computeBidiTables(bv->buffer(), cursor.row());
if (cursor.boundary() !=
text->isBoundary(bv->buffer(), cursor.par(), cursor.pos(),
- text->real_current_font) )
+ text->real_current_font))
text->setCursor(bv, cursor.par(), cursor.pos(),
false, !cursor.boundary());
}
*/
#include <config.h>
-
-#include <cerrno>
-
+
+#include "Alert.h"
+
#include "debug.h"
#include "lyxrc.h"
#include "Alert_pimpl.h"
+#include <cerrno>
+
using std::endl;
+using std::pair;
+using std::make_pair;
-namespace Alert {
-
- void alert(string const & s1, string const & s2, string const & s3) {
- if (!lyxrc.use_gui) {
- lyxerr << "----------------------------------------" << endl
- << s1 << endl << s2 << endl << s3 << endl
- << "----------------------------------------" << endl;
- } else {
- alert_pimpl(s1, s2, s3);
- }
- }
- void err_alert(string const & s1, string const & s2) {
- alert(s1, s2, strerror(errno));
+void Alert::alert(string const & s1, string const & s2, string const & s3)
+{
+ if (!lyxrc.use_gui) {
+ lyxerr << "------------------------------" << endl
+ << s1 << endl << s2 << endl << s3 << endl
+ << "------------------------------" << endl;
+ } else {
+ alert_pimpl(s1, s2, s3);
}
+}
- bool askQuestion(string const & s1, string const & s2, string const & s3, bool default_value) {
- if (!lyxrc.use_gui) {
- lyxerr << "----------------------------------------" << endl
- << s1 << endl;
- if (!s2.empty())
- lyxerr << s2 << endl;
- if (!s3.empty())
- lyxerr << s3 << endl;
- lyxerr << "Assuming answer is "
- << (default_value ? "yes" : "no")
- << endl
- << "----------------------------------------" << endl;
- return default_value;
- } else {
- return askQuestion_pimpl(s1, s2, s3);
- }
+
+void Alert::err_alert(string const & s1, string const & s2)
+{
+ alert(s1, s2, strerror(errno));
+}
+
+
+bool Alert::askQuestion(string const & s1, string const & s2,
+ string const & s3, bool default_value)
+{
+ if (!lyxrc.use_gui) {
+ lyxerr << "----------------------------------------" << endl
+ << s1 << endl;
+ if (!s2.empty())
+ lyxerr << s2 << endl;
+ if (!s3.empty())
+ lyxerr << s3 << endl;
+ lyxerr << "Assuming answer is "
+ << (default_value ? "yes" : "no")
+ << endl
+ << "----------------------------------------" << endl;
+ return default_value;
+ } else {
+ return askQuestion_pimpl(s1, s2, s3);
}
+}
- int askConfirmation(string const & s1, string const & s2, string const & s3, int default_value) {
- if (!lyxrc.use_gui) {
- lyxerr << "----------------------------------------" << endl
- << s1 << endl;
- if (!s2.empty())
- lyxerr << s2 << endl;
- if (!s3.empty())
- lyxerr << s3 << endl;
- lyxerr << "Assuming answer is ";
- if (default_value == 1)
- lyxerr << "yes";
- else if (default_value == 2)
- lyxerr << "no";
- else
- lyxerr << "cancel";
- lyxerr << endl
- << "----------------------------------------" << endl;
- return default_value;
- } else {
- return askConfirmation_pimpl(s1, s2, s3);
- }
+
+int Alert::askConfirmation(string const & s1, string const & s2,
+ string const & s3, int default_value)
+{
+ if (!lyxrc.use_gui) {
+ lyxerr << "----------------------------------------" << endl
+ << s1 << endl;
+ if (!s2.empty())
+ lyxerr << s2 << endl;
+ if (!s3.empty())
+ lyxerr << s3 << endl;
+ lyxerr << "Assuming answer is ";
+ if (default_value == 1)
+ lyxerr << "yes";
+ else if (default_value == 2)
+ lyxerr << "no";
+ else
+ lyxerr << "cancel";
+ lyxerr << endl
+ << "----------------------------------------" << endl;
+ return default_value;
+ } else {
+ return askConfirmation_pimpl(s1, s2, s3);
}
-
- std::pair<bool, string> const askForText(string const & msg, string const & dflt) {
- if (!lyxrc.use_gui) {
- lyxerr << "----------------------------------------" << endl
- << msg << endl
- << "Assuming answer is " << dflt
- << "----------------------------------------" << endl;
- return std::make_pair<bool, string>(true, dflt);
- } else {
- return askForText_pimpl(msg, dflt);
- }
+}
+
+
+pair<bool, string> const Alert::askForText(string const & msg,
+ string const & dflt)
+{
+ if (!lyxrc.use_gui) {
+ lyxerr << "----------------------------------------" << endl
+ << msg << endl
+ << "Assuming answer is " << dflt
+ << "----------------------------------------" << endl;
+ return make_pair<bool, string>(true, dflt);
+ } else {
+ return askForText_pimpl(msg, dflt);
}
}
+// -*- C++ -*-
/**
* \file Alert.h
* Copyright 2001 the LyX Team
* \author John Levon <moz@compsoc.man.ac.uk>
*/
+#ifndef LYX_ALERT_H
+#define LYX_ALERT_H
+
#include "support/lstrings.h"
+
#include <algorithm>
-
+
namespace Alert {
- /// show an alert message
- void alert(string const & s1, string const & s2 = string(),
- string const & s3 = string());
- /// show an alert message and strerror(errno)
- void err_alert(string const & s1, string const & s2 = string());
+/// show an alert message
+void alert(string const & s1, string const & s2 = string(),
+ string const & s3 = string());
+
+/// show an alert message and strerror(errno)
+void err_alert(string const & s1, string const & s2 = string());
- /// ask a question
- bool askQuestion(string const & s1, string const & s2 = string(),
+/// ask a question
+bool askQuestion(string const & s1, string const & s2 = string(),
string const & s3 = string(), bool default_value = true);
- /// Returns 1 for yes, 2 for no, 3 for cancel.
- int askConfirmation(string const & s1, string const & s2 = string(),
- string const & s3 = string(), int default_value = 1);
-
- /// Asks for a text
- std::pair<bool, string> const askForText(string const & msg,
- string const & dflt = string());
+/// Returns 1 for yes, 2 for no, 3 for cancel.
+int askConfirmation(string const & s1, string const & s2 = string(),
+ string const & s3 = string(), int default_value = 1);
+
+/// Asks for a text
+std::pair<bool, string> const
+askForText(string const & msg,
+ string const & dflt = string());
+
}
+
+#endif
BOOST_INCLUDES = -I$(top_srcdir)/boost
INCLUDES = ${FRONTEND_INCLUDES} -I${srcdir}/.. -I${srcdir}/xforms ${SIGC_CFLAGS} $(BOOST_INCLUDES)
LIBS =
-noinst_LTLIBRARIES = libfrontends.la
+noinst_LTLIBRARIES = libfrontends.o
-libfrontends_la_LIBADD= @FRONTEND_GUILIB@ \
- support/libfrontendsupport.la \
- controllers/libcontrollers.la
+libfrontends_o_LIBADD= `cat libxforms.objects` \
+ `cat libcontrollers.objects` \
+ support/libfrontendsupport.o
-libfrontends_la_DEPENDENCIES = @FRONTEND_GUILIB@ \
- support/libfrontendsupport.la \
- controllers/libcontrollers.la
+libfrontends_o_DEPENDENCIES = \
+ support/libfrontendsupport.o
-libfrontends_la_SOURCES=\
+libfrontends_o_SOURCES=\
Alert.C \
Alert.h \
Alert_pimpl.h \
if (val == _("No change"))
font_->setLanguage(ignore_language);
- else if ( val == _("Reset"))
+ else if (val == _("Reset"))
font_->setLanguage(lv_.buffer()->params.language);
else
AUTOMAKE_OPTIONS = foreign 1.4
DISTCLEANFILES= *.orig *.rej *~ *.bak core
MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
-noinst_LTLIBRARIES = libcontrollers.la
+noinst_LTLIBRARIES = libcontrollers.o
BOOST_INCLUDES = -I$(top_srcdir)/boost
INCLUDES = -I${top_srcdir}/src/ \
-I${top_srcdir}/src/frontends/ \
EXTRA_DIST = ButtonController.tmpl ControlDialog.tmpl ControlInset.tmpl
-libcontrollers_la_SOURCES=\
+libcontrollers_o_SOURCES=\
biblio.C \
biblio.h \
character.C \
ViewBase.h \
helper_funcs.C \
helper_funcs.h
+
+libcontrollers.o: $(libcontrollers_o_OBJECTS) $(libcontrollers_o_DEPENDENCIES)
+ rm -f ../libcontrollers.objects
+ for fil in $(libcontrollers_o_OBJECTS) ; do \
+ echo controllers/$$fil >> ../libcontrollers.objects ; \
+ done
bool caseSensitive)
{
// Preliminary checks
- if(start < keys.begin() || start >= keys.end())
+ if (start < keys.begin() || start >= keys.end())
return keys.end();
string search_expr = frontStrip(strip(expr));
string const outname = browseFile(lv, fname, title, pattern,
dir1, dir2);
string const reloutname = MakeRelPath(outname, refpath);
- if(prefixIs(reloutname, "../"))
+ if (prefixIs(reloutname, "../"))
return outname;
else
return reloutname;
AUTOMAKE_OPTIONS = foreign 1.4
DISTCLEANFILES= *.orig *.rej *~ *.bak core
MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
-noinst_LTLIBRARIES = libfrontendsupport.la
+noinst_LTLIBRARIES = libfrontendsupport.o
LIBS =
ETAGS_ARGS = --lang=c++
INCLUDES = -I${srcdir}/../../ $(SIGC_CFLAGS)
-libfrontendsupport_la_SOURCES = \
+libfrontendsupport_o_SOURCES = \
LyXImage.h \
LyXImage.C
h /= 60.0;
int const j = max(0, static_cast<int>(::floor(h)));
- //if( j < 0 ) j = 0;
+ //if (j < 0) j = 0;
double const f = h - j;
double const p = v * (1.0 - s);
}
}
- r = static_cast<int>( ::floor((rd * 255.0) + 0.5) );
- g = static_cast<int>( ::floor((gd * 255.0) + 0.5) );
- b = static_cast<int>( ::floor((bd * 255.0) + 0.5) );
+ r = static_cast<int>(::floor((rd * 255.0) + 0.5));
+ g = static_cast<int>(::floor((gd * 255.0) + 0.5));
+ b = static_cast<int>(::floor((bd * 255.0) + 0.5));
}
double const g = rgb.g / 255.0;
double const b = rgb.b / 255.0;
- double const maxval = max( max( r, g ), b );
- double const minval = min( min( r, g ), b );
+ double const maxval = max( max( r, g), b);
+ double const minval = min( min( r, g), b);
v = maxval;
struct NamedColor : public RGBColor {
string name;
NamedColor() : RGBColor() {}
- NamedColor(string const & n, RGBColor const & c )
+ NamedColor(string const & n, RGBColor const & c)
: RGBColor(c), name(n) {}
RGBColor const & color() const { return *this; }
string const & getname() const { return name; }
#include <iostream>
#include <cctype>
-
+
+
+using std::vector;
+
+
namespace {
extern "C" void C_CompletedCB(FL_OBJECT * ob, long)
}
-void DropDown::select(std::vector<string> const & choices, int x, int y, int w)
+void DropDown::select(vector<string> const & choices, int x, int y, int w)
{
if (choices.empty())
return;
fl_set_form_geometry(form_, x, y-100, w, 100);
fl_clear_browser(browser_);
- for (std::vector<string>::const_iterator cit = choices.begin();
- cit != choices.end(); ++cit) {
+
+ vector<string>::const_iterator cit = choices.begin();
+ vector<string>::const_iterator end = choices.end();
+ for (; cit != end; ++cit) {
fl_add_browser_line(browser_, cit->c_str());
}
fl_select_browser_line(browser_, 1);
fl_clear_choice(ob);
fl_addto_choice(ob, _(" None | Normal | Verbose "));
- switch(tooltip_level_){
+ switch (tooltip_level_) {
case NO_TOOLTIP:
fl_set_choice(ob, 1);
break;
lyx::Assert(ob && ob->objclass == FL_CHOICE &&
fl_get_choice_maxitems(ob) == 3);
- switch(fl_get_choice(ob)){
+ switch (fl_get_choice(ob)) {
case 1:
tooltip_level_ = NO_TOOLTIP;
break;
// using the middle mouse button.
pre->InputCB(ob, 0);
- } else if (event == FL_ENTER || event == FL_LEAVE){
+ } else if (event == FL_ENTER || event == FL_LEAVE) {
// Post feedback as the mouse enters the object,
// remove it as the mouse leaves.
pre->FeedbackCB(ob, event);
#include "support/filetools.h"
+using std::vector;
+using std::sort;
+
+
typedef FormCB<ControlBibtex, FormDB<FD_form_bibtex> > base_class;
FormBibtex::FormBibtex(ControlBibtex & c)
// Remove all duplicate entries in c.
// Taken stright out of Stroustrup
-template<class C> void eliminate_duplicates(C & c)
+template<class C>
+void eliminate_duplicates(C & c)
{
- std::sort(c.begin(), c.end()); // sort
- typename C::iterator p = std::unique(c.begin(), c.end()); // compact
- c.erase(p, c.end()); // shrink
+ sort(c.begin(), c.end());
+ typename C::iterator p = std::unique(c.begin(), c.end());
+ c.erase(p, c.end());
}
+
string const unique_and_no_extensions(string const & str_in)
{
- std::vector<string> dbase = getVectorFromString(str_in);
- for (std::vector<string>::iterator it = dbase.begin();
+ vector<string> dbase = getVectorFromString(str_in);
+ for (vector<string>::iterator it = dbase.begin();
it != dbase.end(); ++it) {
*it = ChangeExtension(*it, "");
}
// bibtotoc and no style
controller().params().setOptions("bibtotoc");
- } else if (!bibstyle.empty()){
+ } else if (!bibstyle.empty()) {
// only style
controller().params().setOptions(bibstyle);
}
#include "helper_funcs.h"
using std::vector;
+using std::find;
+
using namespace character;
typedef FormCB<ControlCharacter, FormDB<FD_form_character> > base_class;
template<class A>
typename vector<A>::size_type findPos(vector<A> const & vec, A const & val)
{
- vector<A>::const_iterator it =
- std::find(vec.begin(), vec.end(), val);
+ vector<A>::const_iterator it = find(vec.begin(), vec.end(), val);
if (it == vec.end())
return 0;
return it - vec.begin();
string const tmp = formatted(biblio::getInfo(theMap,
bibkeys[sel-1]),
- dialog_->browser_info->w-10 );
+ dialog_->browser_info->w-10);
fl_add_browser_line(dialog_->browser_info, tmp.c_str());
// Highlight the selected browser_bib key in browser_cite if
void FormDocument::redraw()
{
- if( form() && form()->visible )
- fl_redraw_form( form() );
+ if (form() && form()->visible)
+ fl_redraw_form(form());
else
return;
FL_FORM * outer_form = fl_get_active_folder(dialog_->tabbed_folder);
if (outer_form && outer_form->visible)
- fl_redraw_form( outer_form );
+ fl_redraw_form(outer_form);
}
} //namespace
-bool FormDocument::input( FL_OBJECT * ob, long data )
+bool FormDocument::input(FL_OBJECT * ob, long data)
{
- State cb = static_cast<State>( data );
+ State cb = static_cast<State>(data);
switch (cb) {
case CHECKCHOICECLASS:
}
-void FormDocument::ChoiceBulletSize(FL_OBJECT * ob, long /*data*/ )
+void FormDocument::ChoiceBulletSize(FL_OBJECT * ob, long /*data*/)
{
BufferParams & param = lv_->buffer()->params;
BufferParams & param = lv_->buffer()->params;
int data = 0;
- if (cb == BULLETDEPTH1 )
+ if (cb == BULLETDEPTH1)
data = 0;
- else if (cb == BULLETDEPTH2 )
+ else if (cb == BULLETDEPTH2)
data = 1;
- else if (cb == BULLETDEPTH3 )
+ else if (cb == BULLETDEPTH3)
data = 2;
- else if (cb == BULLETDEPTH4 )
+ else if (cb == BULLETDEPTH4)
data = 3;
switch (fl_get_button_numb(ob)) {
/* by the user. (eg. standard.xpm, psnfss1.xpm etc...) */
int data = 0;
- if (cb == BULLETPANEL1 )
+ if (cb == BULLETPANEL1)
data = 0;
- else if (cb == BULLETPANEL2 )
+ else if (cb == BULLETPANEL2)
data = 1;
- else if (cb == BULLETPANEL3 )
+ else if (cb == BULLETPANEL3)
data = 2;
- else if (cb == BULLETPANEL4 )
+ else if (cb == BULLETPANEL4)
data = 3;
- else if (cb == BULLETPANEL5 )
+ else if (cb == BULLETPANEL5)
data = 4;
- else if (cb == BULLETPANEL6 )
+ else if (cb == BULLETPANEL6)
data = 5;
if (data != current_bullet_panel) {
}
-void FormDocument::BulletBMTable(FL_OBJECT * ob, long /*data*/ )
+void FormDocument::BulletBMTable(FL_OBJECT * ob, long /*data*/)
{
/* handle the user input by setting the current bullet depth's pixmap */
/* to that extracted from the current chosen position of the BMTable */
/// Build the dialog
virtual void build();
/// Filter the inputs
- virtual bool input( FL_OBJECT *, long );
+ virtual bool input( FL_OBJECT *, long);
/// Update the dialog.
virtual void update();
/// Apply from dialog
void FormGraphics::redraw()
{
- if(form() && form()->visible)
+ if (form() && form()->visible)
fl_redraw_form(form());
else
return;
}
params.setFromString(arg);
- if ( !arg.empty() )
+ if ( !arg.empty())
bc().valid(); // so that the user can press Ok
show();
}
class FormMathsSpace : public FormMathsSub {
public:
///
- FormMathsSpace(LyXView *, Dialogs * , FormMathsPanel const & );
+ FormMathsSpace(LyXView *, Dialogs * , FormMathsPanel const &);
private:
/// Build the dialog
#include "support/lstrings.h"
+#include <functional>
+
using Liason::setMinibuffer;
using SigC::slot;
+using std::vector;
+using std::bind2nd;
FormParagraph::FormParagraph(LyXView * lv, Dialogs * d)
void FormParagraph::redraw()
{
- if( form() && form()->visible )
- fl_redraw_form( form() );
+ if (form() && form()->visible)
+ fl_redraw_form(form());
}
// Create the contents of the unit choices
// Don't include the "%" terms...
- std::vector<string> units_vec = getLatexUnits();
- for (std::vector<string>::iterator it = units_vec.begin();
+#warning A bit dangerous... (Lgb)
+ vector<string> units_vec = getLatexUnits();
+#if 0
+ for (vector<string>::iterator it = units_vec.begin();
it != units_vec.end(); ++it) {
if (contains(*it, "%"))
it = units_vec.erase(it, it+1) - 1;
}
+#else
+ // Something similar to this is a better way to erase
+ vector<string>::iterator del =
+ remove_if(units_vec.begin(), units_vec.end(),
+ bind2nd(contains_functor(), "%"));
+ units_vec.erase(del, units_vec.end());
+#endif
+
string units = getStringFromVector(units_vec, "|");
fl_addto_choice(dialog_->choice_value_space_above, units.c_str());
#include "lyxrc.h"
#include "combox.h"
#include "debug.h"
-#include "support/filetools.h"
-#include "support/LAssert.h"
#include "lyxlex.h"
#include "input_validators.h"
#include "xforms_helpers.h"
#include "helper_funcs.h"
#include "converter.h"
+
#include "support/lyxfunctional.h"
#include "support/lyxmanip.h"
+#include "support/filetools.h"
+#include "support/LAssert.h"
using std::endl;
using std::pair;
using std::max;
using std::min;
using std::vector;
+using std::setw;
+using std::setfill;
+
using SigC::slot;
extern string system_lyxdir;
HSVColor hsv(rgb);
hsv.v += addVal;
- hsv.v = min( 1.0, max(0.0, hsv.v) );
+ hsv.v = min(1.0, max(0.0, hsv.v));
rgb = RGBColor(hsv);
fl_mapcolor(colAdjust, rgb.r, rgb.g, rgb.b);
// Is the choice an Xforms color...
RGBColor col;
- if( selLyX-1 < xformsColorDB.size() ) {
+ if (selLyX - 1 < xformsColorDB.size()) {
vector<XformsColor>::size_type const i = selLyX - 1;
col = xformsColorDB[i].color();
}
bool modify = false;
// Is the choice an Xforms color...
- if( selLyX-1 < xformsColorDB.size() ) {
+ if (selLyX - 1 < xformsColorDB.size()) {
vector<XformsColor>::size_type const i = selLyX - 1;
modify = (xformsColorDB[i].color() != col);
}
bool modify = false;
// Is the choice an Xforms color...
- if( selLyX-1 < xformsColorDB.size() ) {
+ if (selLyX - 1 < xformsColorDB.size()) {
vector<XformsColor>::size_type const i = selLyX - 1;
modify = (xformsColorDB[i].color() != col);
}
fl_getmcolor(GUI_COLOR_CHOICE, &col.r, &col.g, &col.b);
// Is the choice an Xforms color...
- if( selLyX-1 < xformsColorDB.size() ) {
+ if (selLyX - 1 < xformsColorDB.size()) {
vector<XformsColor>::size_type const i = selLyX - 1;
xformsColorDB[i].r = col.r;
xformsColorDB[i].g = col.g;
{
ostringstream ostr;
- ostr << "#" << std::setbase(16) << std::setfill('0')
- << std::setw(2) << col.r
- << std::setw(2) << col.g
- << std::setw(2) << col.b;
+ ostr << "#" << std::setbase(16) << setfill('0')
+ << setw(2) << col.r
+ << setw(2) << col.g
+ << setw(2) << col.b;
return ostr.str().c_str();
}
}
-FormPreferences::Formats::Formats( FormPreferences & p )
+FormPreferences::Formats::Formats(FormPreferences & p)
: parent_(p)
{}
}
-FormPreferences::InputsMisc::InputsMisc( FormPreferences & p )
+FormPreferences::InputsMisc::InputsMisc(FormPreferences & p)
: parent_(p)
{}
}
-FormPreferences::Interface::Interface( FormPreferences & p )
+FormPreferences::Interface::Interface(FormPreferences & p)
: parent_(p)
{}
}
-FormPreferences::Language::Language( FormPreferences & p )
+FormPreferences::Language::Language(FormPreferences & p)
: parent_(p)
{}
}
-FormPreferences::LnFmisc::LnFmisc( FormPreferences & p )
+FormPreferences::LnFmisc::LnFmisc(FormPreferences & p)
: parent_(p)
{}
}
-FormPreferences::OutputsMisc::OutputsMisc( FormPreferences & p )
+FormPreferences::OutputsMisc::OutputsMisc(FormPreferences & p)
: parent_(p)
{}
}
-FormPreferences::Paths::Paths( FormPreferences & p )
+FormPreferences::Paths::Paths(FormPreferences & p)
: parent_(p)
{}
}
-FormPreferences::ScreenFonts::ScreenFonts( FormPreferences & p )
+FormPreferences::ScreenFonts::ScreenFonts(FormPreferences & p)
: parent_(p)
{}
-FormPreferences::SpellOptions::SpellOptions( FormPreferences & p )
+FormPreferences::SpellOptions::SpellOptions(FormPreferences & p)
: parent_(p)
{}
/// The preemptive handler for feedback messages.
void Feedback(FL_OBJECT *, int);
/// Print a warning message and set warning flag.
- void printWarning( string const & );
+ void printWarning(string const &);
/** Launch a file dialog and modify input if it returns a new file.
For an explanation of the various parameters, see xforms_helpers.h.
*/
- void browse( FL_OBJECT * input,
+ void browse(FL_OBJECT * input,
string const & title, string const & pattern,
std::pair<string,string> const & dir1= std::make_pair(string(),string()),
std::pair<string,string> const & dir2 = std::make_pair(string(),string()));
GUI_COLOR_CURSOR = FL_FREE_COL3
};
///
- Colors( FormPreferences & p );
+ Colors(FormPreferences & p);
///
FD_form_colors const * dialog();
///
private:
///
- void AdjustVal( int, int, double ) const;
+ void AdjustVal(int, int, double) const;
///
void InputBrowserLyX() const;
///
class Converters {
public:
///
- Converters( FormPreferences & p );
+ Converters(FormPreferences & p);
///
FD_form_converters const * dialog();
///
///
string const feedback(FL_OBJECT const * const) const;
///
- bool input( FL_OBJECT const * const );
+ bool input(FL_OBJECT const * const);
///
void update();
///
class Formats {
public:
///
- Formats( FormPreferences & p );
+ Formats(FormPreferences & p);
///
FD_form_formats const * dialog();
///
///
string const feedback(FL_OBJECT const * const) const;
///
- bool input( FL_OBJECT const * const );
+ bool input(FL_OBJECT const * const);
///
void update();
class InputsMisc {
public:
///
- InputsMisc( FormPreferences & p );
+ InputsMisc(FormPreferences & p);
///
FD_form_inputs_misc const * dialog();
///
class Interface {
public:
///
- Interface( FormPreferences & p );
+ Interface(FormPreferences & p);
///
FD_form_interface const * dialog();
///
///
string const feedback(FL_OBJECT const * const) const;
///
- bool input( FL_OBJECT const * const );
+ bool input(FL_OBJECT const * const);
///
void update();
class Language {
public:
///
- Language( FormPreferences & p );
+ Language(FormPreferences & p);
///
FD_form_language const * dialog();
///
///
string const feedback(FL_OBJECT const * const) const;
///
- bool input( FL_OBJECT const * const );
+ bool input(FL_OBJECT const * const);
///
void update();
///
class LnFmisc {
public:
///
- LnFmisc( FormPreferences & p );
+ LnFmisc(FormPreferences & p);
///
FD_form_lnf_misc const * dialog();
///
class OutputsMisc {
public:
///
- OutputsMisc( FormPreferences & p );
+ OutputsMisc(FormPreferences & p);
///
FD_form_outputs_misc const * dialog();
///
class Paths {
public:
///
- Paths( FormPreferences & p );
+ Paths(FormPreferences & p);
///
FD_form_paths const * dialog();
///
class Printer {
public:
///
- Printer( FormPreferences & p );
+ Printer(FormPreferences & p);
///
FD_form_printer const * dialog();
///
class ScreenFonts {
public:
///
- ScreenFonts( FormPreferences & p );
+ ScreenFonts(FormPreferences & p);
///
FD_form_screen_fonts const * dialog();
///
class SpellOptions {
public:
///
- SpellOptions( FormPreferences & p );
+ SpellOptions(FormPreferences & p);
///
FD_form_spelloptions const * dialog();
///
fl_set_input(dialog_->input, w.c_str());
fl_set_object_label(dialog_->text, w.c_str());
fl_clear_browser(dialog_->browser);
- while ( !(w = controller().getSuggestion()).empty() ) {
+ while (!(w = controller().getSuggestion()).empty()) {
fl_add_browser_line(dialog_->browser, w.c_str());
}
}
#include "form_tabular.h"
#include "LyXView.h"
#include "Dialogs.h"
-#include "insets/insettabular.h"
#include "buffer.h"
#include "xforms_helpers.h"
#include "lyxrc.h" // to set the default length values
#include "helper_funcs.h"
#include "input_validators.h"
+
+#include "insets/insettabular.h"
+
#include "support/lstrings.h"
+#include <functional>
+
+
using SigC::slot;
+using std::vector;
+using std::bind2nd;
+
FormTabular::FormTabular(LyXView * lv, Dialogs * d)
: FormInset(lv, d, _("Tabular Layout")),
void FormTabular::redraw()
{
- if(form() && form()->visible)
+ if (form() && form()->visible)
fl_redraw_form(form());
else
return;
// Create the contents of the unit choices
// Don't include the "%" terms...
- std::vector<string> units_vec = getLatexUnits();
- for (std::vector<string>::iterator it = units_vec.begin();
+ vector<string> units_vec = getLatexUnits();
+#if 0
+ for (vector<string>::iterator it = units_vec.begin();
it != units_vec.end(); ++it) {
if (contains(*it, "%"))
it = units_vec.erase(it, it + 1) - 1;
}
+#else
+ vector<string>::iterator ret =
+ remove_if(units_vec.begin(),
+ units_vec.end(),
+ bind2nd(contains_functor(), "%"));
+ units_vec.erase(ret, units_vec.end());
+#endif
+
string units = getStringFromVector(units_vec, "|");
fl_addto_choice(column_options_->choice_value_column_width,
#include "form_tabular_create.h"
#include "support/lstrings.h"
+
+using std::make_pair;
+
+
typedef FormCB<ControlTabularCreate, FormDB<FD_form_tabular_create> > base_class;
FormTabularCreate::FormTabularCreate(ControlTabularCreate & c)
unsigned int ysize = (unsigned int)(fl_get_slider_value(dialog_->slider_columns) + 0.5);
unsigned int xsize = (unsigned int)(fl_get_slider_value(dialog_->slider_rows) + 0.5);
- controller().params() = std::make_pair(xsize, ysize);
+ controller().params() = make_pair(xsize, ysize);
}
unsigned int selection = fl_get_browser(dialog_->browser);
// a valid entry?
if (selection > 0) {
- controller().viewFile(
+ controller().viewFile(
fl_get_browser_line(dialog_->browser,
selection));
}
#include "form_thesaurus.h"
#include "debug.h"
+
+using std::vector;
+
+
typedef FormCB<ControlThesaurus, FormDB<FD_form_thesaurus> > base_class;
FormThesaurus::FormThesaurus(ControlThesaurus & c)
fl_freeze_form(form());
Thesaurus::Meanings meanings = controller().getMeanings(str);
-
- for (Thesaurus::Meanings::const_iterator cit = meanings.begin();
- cit != meanings.end(); ++cit) {
- fl_add_browser_line(dialog_->browser_meanings, cit->first.c_str());
- for (std::vector<string>::const_iterator cit2 = cit->second.begin();
- cit2 != cit->second.end(); ++cit2) {
- string ent = " ";
- ent += *cit2;
- fl_add_browser_line(dialog_->browser_meanings, ent.c_str());
- }
+
+ Thesaurus::Meanings::const_iterator cit = meanings.begin();
+ Thesaurus::Meanings::const_iterator end = meanings.end();
+ for (; cit != end; ++cit) {
+ fl_add_browser_line(dialog_->browser_meanings,
+ cit->first.c_str());
+
+ vector<string> const & tmpvec = cit->second;
+ vector<string>::const_iterator cit2 = tmpvec.begin();
+ vector<string>::const_iterator end2 = tmpvec.end();
+ for (; cit2 != end2; ++cit2) {
+ string ent = " ";
+ ent += *cit2;
+ fl_add_browser_line(dialog_->browser_meanings,
+ ent.c_str());
}
+ }
fl_unfreeze_form(form());
fl_redraw_form(form());
bool all_lower = true;
bool all_upper = true;
- for (string::const_iterator it = templ.begin(); it != templ.end(); ++it) {
- if (isupper(*it))
+ string::const_iterator beg = templ.begin();
+ string::const_iterator end = templ.end();
+ string::const_iterator cit = beg;
+ for (; cit != end; ++cit) {
+ if (isupper(*cit))
all_lower = false;
- if (islower(*it))
+ if (islower(*cit))
all_upper = false;
}
str = uppercase(nstr);
} else if (templ.size() > 0 && isupper(templ[0])) {
bool rest_lower = true;
- for (string::const_iterator it = templ.begin() + 1;
- it != templ.end(); ++it) {
- if (isupper(*it))
+ string::const_iterator cit2 = beg + 1;
+
+ for (; cit2 != end; ++cit2) {
+ if (isupper(*cit2))
rest_lower = false;
}
updateContents();
- unsigned int const choice = fl_get_browser( dialog_->browser_toc );
+ unsigned int const choice = fl_get_browser(dialog_->browser_toc);
if (choice - 1 < toclist_.size() && choice >= 1) {
controller().Goto(toclist_[choice - 1].par->id());
fl_get_browser_topline(dialog_->browser_toc);
unsigned int const line = fl_get_browser(dialog_->browser_toc);
- fl_clear_browser( dialog_->browser_toc );
+ fl_clear_browser(dialog_->browser_toc);
Buffer::SingleList::const_iterator cit = toclist_.begin();
Buffer::SingleList::const_iterator end = toclist_.end();
If you want to try to compile anyway, delete this test in src/frontends/xforms/GUIRunTime.C.
#endif
+
using std::endl;
+using std::hex;
+
extern bool finished;
XEvent ev;
fl_XNextEvent(&ev);
lyxerr << "Received unhandled X11 event" << endl;
- lyxerr << "Type: 0x" << std::hex << ev.xany.type <<
- "Target: 0x" << std::hex << ev.xany.window << endl;
+ lyxerr << "Type: 0x" << hex << ev.xany.type <<
+ "Target: 0x" << hex << ev.xany.window << endl;
}
}
XEvent ev;
fl_XNextEvent(&ev);
lyxerr << "Received unhandled X11 event" << endl;
- lyxerr << "Type: 0x" << std::hex << ev.xany.type <<
- "Target: 0x" << std::hex << ev.xany.window << endl;
+ lyxerr << "Type: 0x" << hex << ev.xany.type <<
+ "Target: 0x" << hex << ev.xany.window << endl;
}
}
}
AUTOMAKE_OPTIONS = foreign 1.4
DISTCLEANFILES= *.orig *.rej *~ *.bak core
MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
-noinst_LTLIBRARIES = libxforms.la
+noinst_LTLIBRARIES = libxforms.o
BOOST_INCLUDES = -I$(top_srcdir)/boost
INCLUDES = -I${top_srcdir}/images -I${top_srcdir}/src/ \
-I${top_srcdir}/src/frontends/ \
LYXDATADIRS = forms
ETAGS_ARGS = --lang=c++
# Alphabetical order please. It makes it easier to figure out what's missing.
-libxforms_la_SOURCES = \
+libxforms_o_SOURCES = \
Alert_pimpl.C \
bmtable.c \
bmtable.h \
# GUI_runtime.C \
# GUI_applymenu.C
-libxforms_la_LIBADD = @LYX_LIBS@ @FRONTEND_LDFLAGS@ @FRONTEND_LIBS@
+libxforms_o_LIBADD = @LYX_LIBS@ @FRONTEND_LDFLAGS@ @FRONTEND_LIBS@
+
+libxforms.o: $(libxforms_o_OBJECTS) $(libxforms_o_DEPENDENCIES)
+ rm -f ../libxforms.objects
+ for fil in $(libxforms_o_OBJECTS) ; do \
+ echo xforms/$$fil >> ../libxforms.objects ; \
+ done
# for convenience only
updatesrc:
using std::vector;
using std::max;
using std::min;
+using std::for_each;
typedef vector<int>::size_type size_type;
string const & menu_name,
vector<int> & smn)
{
- if (!menubackend_->hasMenu(menu_name)){
+ if (!menubackend_->hasMenu(menu_name)) {
lyxerr << "ERROR:create_submenu: Unknown menu `"
<< menu_name << "'" << endl;
return -1;
lyxerr << "Error in MenuCallback" << endl;
}
- std::for_each(submenus.begin(), submenus.end(), fl_freepup);
+ for_each(submenus.begin(), submenus.end(), fl_freepup);
// restore tabstop length
fl_set_tabstop(default_tabstop);
#include <config.h>
-#include <functional>
-#include <algorithm>
-#include <iterator>
-
#ifdef __GNUG__
#pragma implementation
#endif
#include "RadioButtonGroup.h"
#include "debug.h" // for lyxerr
+#include "support/lyxfunctional.h"
+
+//#include <functional>
+#include <algorithm>
+#include <iterator>
using std::find_if;
-using std::bind2nd;
+//using std::bind2nd;
using std::endl;
+
void RadioButtonGroup::registerRadioButton(FL_OBJECT *button, int value)
{
- map.push_back( ButtonValuePair(button, value) );
+ map.push_back(ButtonValuePair(button, value));
}
map.clear();
}
+
+#if 0
// Functor to help us in our work, we should try to find how to achieve
// this with only STL predicates, but its easier to write this than to
// dig. If you can find the equivalent STL predicate combination, let me
return left.second == right;
}
};
+#endif
+
void RadioButtonGroup::setButton(int value)
{
+#if 0
ButtonValueMap::const_iterator it =
find_if(map.begin(), map.end(),
- bind2nd(equal_to_second_in_pair < ButtonValuePair > (),
+ bind2nd(equal_to_second_in_pair<ButtonValuePair>(),
value));
-
+#else
+ ButtonValueMap::const_iterator it =
+ find_if(map.begin(), map.end(),
+ lyx::equal_2nd_in_pair<ButtonValuePair>(value));
+#endif
+
// If we found nothing, report it and return
if (it == map.end()) {
lyxerr << "BUG: Requested value in RadioButtonGroup doesn't exists"
}
+
template < typename T >
struct is_set_button {
bool operator() (T const & item) const
{
- return fl_get_button( (item).first );
+ return fl_get_button((item).first);
}
};
+
int RadioButtonGroup::getButton()
{
// Find the first button that is active
ButtonValueMap::iterator it =
find_if(map.begin(), map.end(),
- is_set_button < ButtonValuePair > () );
+ is_set_button<ButtonValuePair> ());
// If such a button was found, return its value.
if (it != map.end()) {
#pragma interface
#endif
-using std::vector;
-using std::pair;
-
/** This class simplifies the work with a group of radio buttons,
* the idea is that you register a bunch of radio buttons with the accompanying
RadioButtonGroup(unsigned n = 5) : map(n) {};
/// Register a radio button with it's corresponding value.
- void registerRadioButton(FL_OBJECT *button, int value);
+ void registerRadioButton(FL_OBJECT * button, int value);
/// Reset registrations.
void reset();
private:
///
- typedef pair<FL_OBJECT *, int> ButtonValuePair;
+ typedef std::pair<FL_OBJECT *, int> ButtonValuePair;
///
- typedef vector<ButtonValuePair> ButtonValueMap;
+ typedef std::vector<ButtonValuePair> ButtonValueMap;
///
ButtonValueMap map;
};
FL_OBJECT * bubble_timer = reinterpret_cast<FL_OBJECT *>(ob->u_cdata);
// We do not test for empty help here, since this can never happen
- if (event == FL_ENTER){
+ if (event == FL_ENTER) {
fl_set_object_callback(bubble_timer,
C_Toolbar_BubbleTimerCB,
reinterpret_cast<long>(ob));
fl_set_timer(bubble_timer, 1);
}
- else if (event != FL_MOTION){
+ else if (event != FL_MOTION) {
fl_set_timer(bubble_timer, 0);
fl_hide_oneliner();
}
ToolbarList::iterator item = toollist.begin();
ToolbarList::iterator end = toollist.end();
for (; item != end; ++item) {
- switch (item->action){
+ switch (item->action) {
case ToolbarDefaults::SEPARATOR:
xpos += sepspace;
break;
lyx::Assert(timer);
// We do not test for empty help here, since this can never happen
- if (event == FL_ENTER){
+ if (event == FL_ENTER) {
fl_set_object_callback(timer,
C_TooltipTimerCB,
reinterpret_cast<long>(ob));
fl_set_timer(timer, 1);
}
- else if (event != FL_MOTION){
+ else if (event != FL_MOTION) {
fl_set_timer(timer, 0);
fl_hide_oneliner();
}
FL_FORM * current_form = fl_current_form;
fl_end_form();
- bw = w + 20; bh = hmax - hmin - 12;
+ bw = w + 20;
+ bh = hmax - hmin - 12;
form = fl_bgn_form(FL_NO_BOX, bw, bh);
browser = obj = fl_add_browser(FL_HOLD_BROWSER, 0, 0, bw, bh, "");
int folder_x, folder_y, folder_w, folder_h;
fl_get_folder_area( tabfolder1,
&folder_x, &folder_y,
- &folder_w, &folder_h );
+ &folder_w, &folder_h);
x += folder_x;
y += folder_y;
if (tabfolder2) {
fl_get_folder_area( tabfolder2,
&folder_x, &folder_y,
- &folder_w, &folder_h );
+ &folder_w, &folder_h);
x += tabfolder2->form->x + folder_x;
y += tabfolder2->form->y + folder_y;
} else {
fl_set_form_position(form, x, y);
fl_show_form(form, FL_PLACE_POSITION, FL_NOBORDER, "");
- if (sel>0) {
+ if (sel > 0) {
fl_set_browser_topline(browser, sel);
fl_select_browser_line(browser, sel);
}
XFlush(fl_get_display());
}
if (button) {
- if (type != FL_COMBOX_NORMAL){
+ if (type != FL_COMBOX_NORMAL) {
fl_set_object_label(button, "@2->");
fl_redraw_object(button);
}
}
// Flush remaining contents of word
- if (!word.empty() ) sentence.push_back(word);
+ if (!word.empty()) sentence.push_back(word);
string line;
string line_plus_word;
line.erase();
}
- if (!line_plus_word.empty() ) line_plus_word += ' ';
+ if (!line_plus_word.empty()) line_plus_word += ' ';
line_plus_word += word;
int const length = fl_get_string_width(style, size,
#pragma implementation
#endif
-#include "graphics/GraphicsCache.h"
#include "graphics/GraphicsCacheItem.h"
-#include "frontends/support/LyXImage.h"
+#include "graphics/GraphicsCache.h"
#include "graphics/ImageLoaderXPM.h"
#include "converter.h"
-#include "support/filetools.h"
-#include "support/lyxlib.h"
#include "lyx_gui_misc.h"
#include "debug.h"
#include "support/LAssert.h"
#include "gettext.h"
#include "lyxfunc.h"
+#include "frontends/support/LyXImage.h"
+
+#include "support/filetools.h"
+#include "support/lyxlib.h"
+
using std::endl;
+
/*
* The order of conversion:
*
*/
GraphicsCacheItem::GraphicsCacheItem(string const & filename)
- : imageStatus_(GraphicsCacheItem::Loading)
+ : filename_(filename), imageStatus_(GraphicsCacheItem::Loading)
{
- filename_ = filename;
-
bool success = convertImage(filename);
- if (! success) // Conversion failed miserably (couldn't even start).
+ if (!success) // Conversion failed miserably (couldn't even start).
setStatus(ErrorConverting);
}
GraphicsCacheItem::ImageStatus
-GraphicsCacheItem::getImageStatus() const { return imageStatus_; }
+GraphicsCacheItem::getImageStatus() const
+{
+ return imageStatus_;
+}
void GraphicsCacheItem::setStatus(ImageStatus new_status)
LyXImage *
-GraphicsCacheItem::getImage() const { return image_.get(); }
+GraphicsCacheItem::getImage() const
+{
+ return image_.get();
+}
void GraphicsCacheItem::imageConverted(bool success)
}
if (iter == end) {
// We do not know how to convert the image to something loadable.
- lyxerr << "ERROR: Do not know how to convert image." << std::endl;
+ lyxerr << "ERROR: Do not know how to convert image." << endl;
return string();
}
return (*iter);
bool GraphicsCacheItem::convertImage(string const & filename)
{
setStatus(GraphicsCacheItem::Converting);
+#warning shadowing class variable (Lgb)
+ // Is this needed at all?
string filename_ = string(filename);
lyxerr << "try to convert image file: " << filename_ << endl;
// maybe that other zip extensions also be useful, especially the
lyx::unlink(tempfile);
if (zipped)
lyx::unlink(filename_);
- tempfile = string();
+ tempfile.erase();
return true;
}
*
* ================================================= */
+#include <config.h>
+
#ifdef __GNUG__
#pragma implementation
#endif
-#include <config.h>
#include "ImageLoaderXPM.h"
#include "ColorHandler.h"
#include "lyxrc.h"
+#include "debug.h"
+
#include "frontends/support/LyXImage.h"
#include "frontends/GUIRunTime.h"
+
#include "support/filetools.h"
+#include "support/LAssert.h"
#include XPM_H_LOCATION
#include <iostream>
#include <fstream>
-#include "support/LAssert.h"
-#include "debug.h"
+using std::ifstream;
using std::endl;
using std::ios;
+
bool ImageLoaderXPM::isImageFormatOK(string const & filename) const
{
- std::ifstream is(filename.c_str(), ios::in);
+ ifstream is(filename.c_str(), ios::in);
// The signature of the file without the spaces.
static char const str[] = "/*XPM*/";
return true;
}
+
ImageLoaderXPM::FormatList const
ImageLoaderXPM::loadableFormats() const
{
return formats;
}
-
+
+
ImageLoader::Result
ImageLoaderXPM::runImageLoader(string const & filename)
{
AUTOMAKE_OPTIONS = foreign
DISTCLEANFILES= *.orig *.rej *~ *.bak core
MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
-noinst_LTLIBRARIES = libgraphics.la
+noinst_LTLIBRARIES = libgraphics.o
LIBS =
ETAGS_ARGS = --lang=c++
BOOST_INCLUDES = -I$(top_srcdir)/boost
INCLUDES = -I${srcdir}/../ $(SIGC_CFLAGS) $(BOOST_INCLUDES)
-libgraphics_la_SOURCES = \
+libgraphics_o_SOURCES = \
GraphicsCache.h \
GraphicsCache.C \
GraphicsCacheItem.h \
class dumpTemplate {
public:
- dumpTemplate(std::ostream & o)
+ dumpTemplate(ostream & o)
: ost(o) {}
void operator()(ExternalTemplateManager::Templates::value_type const & vt) {
ExternalTemplate const & et = vt.second;
AUTOMAKE_OPTIONS = foreign
DISTCLEANFILES= *.orig *.rej *~ *.bak core
MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
-noinst_LTLIBRARIES = libinsets.la
+noinst_LTLIBRARIES = libinsets.o
LIBS =
ETAGS_ARGS = --lang=c++
BOOST_INCLUDES = -I$(top_srcdir)/boost
insettheorem.C \
insettheorem.h
-libinsets_la_SOURCES = \
+libinsets_o_SOURCES = \
ExternalTemplate.C \
ExternalTemplate.h \
figinset.C \
#include <config.h>
-#include <fstream>
-#include <queue>
-#include <list>
-#include <algorithm>
-#include <vector>
-#include <utility>
-
-#include <unistd.h>
-#include <csignal>
-#include <sys/wait.h>
-
-#include FORMS_H_LOCATION
-#include <cstdlib>
-#include <cctype>
-#include <cmath>
-#include <cerrno>
-
#include "figinset.h"
+
#include "lyx_main.h"
#include "buffer.h"
-#include "frontends/FileDialog.h"
-#include "support/filetools.h"
#include "LyXView.h" // just because of form_main
#include "debug.h"
#include "LaTeXFeatures.h"
#include "lyxrc.h"
#include "gettext.h"
#include "lyx_gui_misc.h" // CancelCloseBoxCB
-#include "frontends/Alert.h"
-#include "support/FileInfo.h"
-#include "support/lyxlib.h"
-#include "support/os.h"
#include "Painter.h"
#include "font.h"
#include "bufferview_funcs.h"
#include "ColorHandler.h"
#include "converter.h"
-#include "frontends/Dialogs.h" // redrawGUI
#include "BufferView.h"
+#include "frontends/FileDialog.h"
+#include "frontends/Alert.h"
+#include "frontends/Dialogs.h" // redrawGUI
+
+#include "support/FileInfo.h"
+#include "support/lyxlib.h"
+#include "support/os.h"
+#include "support/filetools.h"
+
+#include <fstream>
+#include <queue>
+#include <list>
+#include <algorithm>
+#include <vector>
+#include <utility>
+
+#include <unistd.h>
+#include <csignal>
+#include <sys/wait.h>
+#include <cstdlib>
+#include <cctype>
+#include <cmath>
+#include <cerrno>
+
using std::ostream;
using std::istream;
using std::ofstream;
using std::pair;
using std::make_pair;
using std::ios;
+using std::ostream_iterator;
#ifndef CXX_GLOBAL_CSTD
using std::memcpy;
if (lyxerr.debugging()) {
lyxerr << "Pids to wait for: \n";
copy(pidwaitlist.begin(), pidwaitlist.end(),
- std::ostream_iterator<int>(lyxerr, "\n"));
+ ostream_iterator<int>(lyxerr, "\n"));
lyxerr << flush;
}
}
vi->visualid, vi->c_class,
vi->bits_per_rgb, vi->map_entries);
}
- color_visual = ( (vi->c_class == StaticColor) ||
+ color_visual = ((vi->c_class == StaticColor) ||
(vi->c_class == PseudoColor) ||
(vi->c_class == TrueColor) ||
- (vi->c_class == DirectColor) );
+ (vi->c_class == DirectColor));
if ((vi->c_class & 1) == 0) return;
// now allocate colors
if (vi->c_class == GrayScale) {
env = new char_p[ne + 2];
string tmp = t2.str().c_str();
env[0] = new char[tmp.size() + 1];
- std::copy(tmp.begin(), tmp.end(), env[0]);
+ copy(tmp.begin(), tmp.end(), env[0]);
env[0][tmp.size()] = '\0';
memcpy(&env[1], environ,
sizeof(char*) * (ne + 1));
fl_set_input(form->Width, tostr(xwid).c_str());
fl_set_input(form->Height, tostr(xhgh).c_str());
fl_set_input(form->Angle, tostr(angle).c_str());
- if (!fname.empty()){
+ if (!fname.empty()) {
string buf1 = OnlyPath(owner->fileName());
string fname2 = MakeRelPath(fname, buf1);
fl_set_input(form->EpsFile, fname2.c_str());
#ifndef FIGINSET_H
#define FIGINSET_H
+#include FORMS_H_LOCATION
#include "figure_form.h"
#include "LString.h"
#include "buffer.h"
id_ = id_arg;
}
-void Inset::setFont(BufferView *, LyXFont const &, bool, bool )
+void Inset::setFont(BufferView *, LyXFont const &, bool, bool)
{}
int UpdatableInset::getMaxWidth(BufferView * bv, UpdatableInset const *) const
{
int w;
- if (owner()){
+ if (owner()) {
w = static_cast<UpdatableInset*>
(owner())->getMaxWidth(bv, this);
} else {
string linebuf0;
while (getline(ifs, linebuf0)) {
string linebuf = frontStrip(strip(linebuf0));
- if (linebuf.empty() ) continue;
+ if (linebuf.empty()) continue;
if (prefixIs(linebuf, "@")) {
linebuf = subst(linebuf, '{', '(');
string tmp;
#include "BufferView.h"
#include "LaTeXFeatures.h"
#include "LyXView.h"
+
#include "frontends/Dialogs.h"
+
#include "support/lstrings.h"
+
+using std::ostream;
+
+
InsetCitation::InsetCitation(InsetCommandParams const & p, bool)
: InsetCommand(p)
{}
keys = frontStrip(split(keys, label, ',')) + ",";
string::size_type const maxSize = 40;
- while (contains( keys, "," )) {
+ while (contains(keys, ",")) {
string key;
keys = frontStrip(split(keys, key, ','));
edit(bv, 0, 0, 0);
}
-int InsetCitation::ascii(Buffer const *, std::ostream & os, int) const
+int InsetCitation::ascii(Buffer const *, ostream & os, int) const
{
os << "[" << getContents() << "]";
return 0;
// the \cite command is valid. Eg, the user has natbib enabled, inputs some
// citations and then changes his mind, turning natbib support off. The output
// should revert to \cite[]{}
-int InsetCitation::latex(Buffer const * buffer, std::ostream & os,
+int InsetCitation::latex(Buffer const * buffer, ostream & os,
bool /*fragile*/, bool/*fs*/) const
{
os << "\\";
#include "lyxfont.h"
#include "BufferView.h"
#include "Painter.h"
-#include "insets/insettext.h"
-#include "support/LOstream.h"
-#include "support/lstrings.h"
#include "debug.h"
#include "lyxtext.h"
#include "font.h"
#include "lyxlex.h"
-class LyXText;
+#include "insets/insettext.h"
+#include "support/LOstream.h"
+#include "support/lstrings.h"
+
+using std::vector;
using std::ostream;
using std::endl;
using std::max;
+class LyXText;
+
+
InsetCollapsable::InsetCollapsable(bool collapsed)
: UpdatableInset(), collapsed_(collapsed),
button_length(0), button_top_y(0), button_bottom_y(0),
}
-int InsetCollapsable::ascii(Buffer const *buf, std::ostream & os, int ll) const
+int InsetCollapsable::ascii(Buffer const * buf, ostream & os, int ll) const
{
return inset.ascii(buf, os, ll);
}
-int InsetCollapsable::linuxdoc(Buffer const *buf, std::ostream & os) const
+int InsetCollapsable::linuxdoc(Buffer const * buf, ostream & os) const
{
return inset.linuxdoc(buf, os);
}
-int InsetCollapsable::docbook(Buffer const *buf, std::ostream & os) const
+int InsetCollapsable::docbook(Buffer const * buf, ostream & os) const
{
return inset.docbook(buf, os);
}
}
-std::vector<string> const InsetCollapsable::getLabelList() const
+vector<string> const InsetCollapsable::getLabelList() const
{
return inset.getLabelList();
}
{}
-InsetCommandParams::InsetCommandParams( string const & n,
+InsetCommandParams::InsetCommandParams(string const & n,
string const & c,
- string const & o )
+ string const & o)
: cmdname(n), contents(c), options(o)
{}
}
-void InsetCommandParams::setFromString( string const & b )
+void InsetCommandParams::setFromString(string const & b)
{
string::size_type idx = b.find("|++|");
if (idx == string::npos) {
}
// Don't mess with this.
- if (!tcmdname.empty()) setCmdName( tcmdname );
- if (!toptions.empty()) setOptions( toptions );
- if (!tcontents.empty()) setContents( tcontents );
+ if (!tcmdname.empty()) setCmdName(tcmdname);
+ if (!toptions.empty()) setOptions(toptions);
+ if (!tcontents.empty()) setContents(tcontents);
if (lyxerr.debugging(Debug::PARSER))
lyxerr << "Command <" << cmd
InsetCommand::InsetCommand(InsetCommandParams const & p, bool)
- : p_( p.getCmdName(), p.getContents(), p.getOptions() )
+ : p_(p.getCmdName(), p.getContents(), p.getOptions())
{}
-void InsetCommand::setParams(InsetCommandParams const & p )
+void InsetCommand::setParams(InsetCommandParams const & p)
{
- p_.setCmdName( p.getCmdName() );
- p_.setContents( p.getContents() );
- p_.setOptions( p.getOptions() );
+ p_.setCmdName(p.getCmdName());
+ p_.setContents(p.getContents());
+ p_.setOptions(p.getOptions());
}
InsetCommandParams();
///
explicit
- InsetCommandParams( string const & n,
+ InsetCommandParams(string const & n,
string const & c = string(),
string const & o = string());
///
///
string const & getContents() const { return contents; }
///
- void setCmdName( string const & n) { cmdname = n; }
+ void setCmdName(string const & n) { cmdname = n; }
///
void setOptions(string const & o) { options = o; }
///
///
string const getAsString() const;
///
- void setFromString( string const & );
+ void setFromString(string const &);
private:
///
string cmdname;
virtual ~InsetCommand() { hideDialog(); }
///
void write(Buffer const *, std::ostream & os) const
- { p_.write( os ); }
+ { p_.write(os); }
///
virtual void read(Buffer const *, LyXLex & lex)
- { p_.read( lex ); }
+ { p_.read(lex); }
/// Can remove one InsetBibKey is modified
- void scanCommand(string const & c) { p_.scanCommand( c ); };
+ void scanCommand(string const & c) { p_.scanCommand(c); };
///
virtual int latex(Buffer const *, std::ostream &,
bool fragile, bool free_spc) const;
void InsetError::edit(BufferView * bv, int, int, unsigned int)
{
- bv->owner()->getDialogs()->showError( this );
+ bv->owner()->getDialogs()->showError(this);
}
#include "support/LOstream.h"
+
using std::ostream;
+using std::min;
+using std::endl;
+
using lyx::pos_type;
token_found = true;
} else {
lyxerr << "InsetERT::Read: Missing 'status'-tag!"
- << std::endl;
+ << endl;
// take countermeasures
lex.pushToken(token);
}
{
string st;
- switch(status_) {
+ switch (status_) {
case Open:
st = "Open";
break;
case Paragraph::META_INSET:
case Paragraph::META_HFILL:
lyxerr << "Element is not allowed in insertERT"
- << std::endl;
+ << endl;
case Paragraph::META_NEWLINE:
os << "\n\\newline \n";
break;
}
-int InsetERT::latex(Buffer const *, std::ostream & os, bool /*fragile*/,
+int InsetERT::latex(Buffer const *, ostream & os, bool /*fragile*/,
bool /*free_spc*/) const
{
Paragraph * par = inset.paragraph();
int InsetERT::ascii(Buffer const *,
- std::ostream &, int /*linelen*/) const
+ ostream &, int /*linelen*/) const
{
return 0;
}
-int InsetERT::linuxdoc(Buffer const *, std::ostream & os) const
+int InsetERT::linuxdoc(Buffer const *, ostream & os) const
{
Paragraph * par = inset.paragraph();
int lines = 0;
}
-int InsetERT::docbook(Buffer const *, std::ostream & os) const
+int InsetERT::docbook(Buffer const *, ostream & os) const
{
Paragraph * par = inset.paragraph();
int lines = 0;
set_latex_font(bv);
}
- switch(action) {
+ switch (action) {
case LFUN_LAYOUT:
bv->owner()->setLayout(inset.paragraph()->getLayout());
break;
default:
result = InsetCollapsable::localDispatch(bv, action, arg);
}
- switch(action) {
+ switch (action) {
case LFUN_BREAKPARAGRAPH:
case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
case LFUN_BACKSPACE:
string la;
pos_type const max_length = 15;
pos_type const p_siz = inset.paragraph()->size();
- pos_type const n = std::min(max_length, p_siz);
+ pos_type const n = min(max_length, p_siz);
int i = 0;
int j = 0;
for(; i < n && j < p_siz; ++j) {
{
if (st != status_) {
status_ = st;
- switch(st) {
+ switch (st) {
case Inlined:
inset.setAutoBreakRows(false);
break;
#pragma implementation
#endif
-#include <cstdio>
-#include <utility>
-
#include "insetexternal.h"
#include "ExternalTemplate.h"
#include "BufferView.h"
#include "buffer.h"
#include "LyXView.h"
-#include "frontends/Dialogs.h"
#include "lyx_main.h"
#include "LaTeXFeatures.h"
+#include "gettext.h"
+#include "debug.h"
+
+#include "frontends/Dialogs.h"
+
#include "support/filetools.h"
#include "support/lstrings.h"
#include "support/path.h"
#include "support/syscall.h"
-#include "gettext.h"
-#include "debug.h"
#include "support/FileInfo.h"
+#include <cstdio>
+#include <utility>
+
+
+using std::ostream;
using std::endl;
+
InsetExternal::InsetExternal()
: view_(0)
{
}
-void InsetExternal::write(Buffer const *, std::ostream & os) const
+void InsetExternal::write(Buffer const *, ostream & os) const
{
- os << "External " << params_.templ.lyxName << ",\"" << params_.filename
- << "\",\"" << params_.parameters << "\"\n";
+ os << "External " << params_.templ.lyxName << ",\""
+ << params_.filename << "\",\"" << params_.parameters << "\"\n";
}
int InsetExternal::write(string const & format,
- Buffer const * buf, std::ostream & os) const
+ Buffer const * buf, ostream & os) const
{
ExternalTemplate const & et = params_.templ;
ExternalTemplate::Formats::const_iterator cit =
et.formats.find(format);
if (cit == et.formats.end()) {
lyxerr << "External template format '" << format
- << "' not specified in template " << params_.templ.lyxName
- << endl;
+ << "' not specified in template "
+ << params_.templ.lyxName << endl;
return 0;
}
int InsetExternal::latex(Buffer const * buf,
- std::ostream & os, bool, bool) const
+ ostream & os, bool, bool) const
{
return write("LaTeX", buf, os);
}
-int InsetExternal::ascii(Buffer const * buf, std::ostream & os, int) const
+int InsetExternal::ascii(Buffer const * buf, ostream & os, int) const
{
return write("Ascii", buf, os);
}
-int InsetExternal::linuxdoc(Buffer const * buf, std::ostream & os) const
+int InsetExternal::linuxdoc(Buffer const * buf, ostream & os) const
{
return write("LinuxDoc", buf, os);
}
-int InsetExternal::docbook(Buffer const * buf, std::ostream & os) const
+int InsetExternal::docbook(Buffer const * buf, ostream & os) const
{
return write("DocBook", buf, os);
}
string const InsetExternal::doSubstitution(Buffer const * buffer,
- string const & s) const
+ string const & s) const
{
string result;
string const basename = ChangeExtension(params_.filename, string());
#include "gettext.h"
#include "debug.h"
+
+using std::ostream;
using std::endl;
+
InsetFloatList::InsetFloatList()
: InsetCommand(InsetCommandParams())
{
}
-void InsetFloatList::write(Buffer const *, std::ostream & os) const
+void InsetFloatList::write(Buffer const *, ostream & os) const
{
os << "FloatList " << getCmdName() << "\n";
}
}
-int InsetFloatList::latex(Buffer const *, std::ostream & os, bool, bool) const
+int InsetFloatList::latex(Buffer const *, ostream & os, bool, bool) const
{
FloatList::const_iterator cit = floatList[getCmdName()];
}
-int InsetFloatList::ascii(Buffer const * buffer, std::ostream & os, int) const
+int InsetFloatList::ascii(Buffer const * buffer, ostream & os, int) const
{
os << getScreenLabel(buffer) << "\n\n";
#include "debug.h"
+using std::ostream;
+
+
InsetFoot::InsetFoot()
: InsetFootlike()
{
int InsetFoot::latex(Buffer const * buf,
- std::ostream & os, bool fragile, bool fp) const
+ ostream & os, bool fragile, bool fp) const
{
os << "%\n\\footnote{";
#include "support/LOstream.h"
+using std::ostream;
+
+
InsetFootlike::InsetFootlike()
: InsetCollapsable()
{
}
-void InsetFootlike::write(Buffer const * buf, std::ostream & os) const
+void InsetFootlike::write(Buffer const * buf, ostream & os) const
{
os << getInsetName() << "\n";
InsetCollapsable::write(buf, os);
#include "insets/insetgraphics.h"
#include "insets/insetgraphicsParams.h"
+
#include "graphics/GraphicsCache.h"
#include "graphics/GraphicsCacheItem.h"
-#include "frontends/Dialogs.h"
-#include "frontends/Alert.h"
#include "LyXView.h"
#include "buffer.h"
#include "BufferView.h"
#include "converter.h"
-#include "frontends/support/LyXImage.h"
#include "Painter.h"
#include "lyx_gui_misc.h"
-#include "support/FileInfo.h"
-#include "support/filetools.h"
-#include "support/lyxalgo.h" // lyx::count
-#include "support/lyxlib.h"
-#include "frontends/controllers/helper_funcs.h"
#include "lyxtext.h"
#include "lyxrc.h"
-#include "font.h" // For the lyxfont class.
-#include "fstream" // for ifstream in isEPS
-#include <algorithm> // For the std::max
-#include "support/lyxmanip.h"
+#include "font.h"
#include "debug.h"
#include "gettext.h"
-//#include "LOStream.h"
+
+#include "frontends/Dialogs.h"
+#include "frontends/Alert.h"
+#include "frontends/controllers/helper_funcs.h"
+#include "frontends/support/LyXImage.h"
+
+#include "support/FileInfo.h"
+#include "support/filetools.h"
+#include "support/lyxlib.h"
+#include "support/lyxmanip.h"
#include "support/lyxalgo.h"
+#include <fstream>
+#include <algorithm>
+
extern string system_tempdir;
using std::ifstream;
using std::ostream;
using std::endl;
+using std::max;
+using std::vector;
+
///////////////////////////////////////////////////////////////////////////
int const VersionNumber = 1;
if (!msg.empty()) {
msgFont.setSize(LyXFont::SIZE_TINY);
int const msg_width = lyxfont::width(msg, msgFont);
- font_width = std::max(font_width, msg_width);
+ font_width = max(font_width, msg_width);
}
- return std::max(50, font_width + 15);
+ return max(50, font_width + 15);
}
}
string const token = lex.getString();
lyxerr[Debug::INFO] << "Token: '" << token << '\''
- << std::endl;
+ << endl;
if (token.empty()) {
continue;
<< "This document was created with a newer Graphics widget"
", You should use a newer version of LyX to read this"
" file."
- << std::endl;
+ << endl;
// TODO: Possibly open up a dialog?
}
else {
if (! params.Read(buf, lex, token))
lyxerr << "Unknown token, " << token << ", skipping."
- << std::endl;
+ << endl;
}
}
}
// FormatVersion < 1.0 (LyX < 1.2)
void InsetGraphics::readFigInset(Buffer const * buf, LyXLex & lex)
{
- std::vector<string> const oldUnits =
+ vector<string> const oldUnits =
getVectorFromString("pt,cm,in,p%,c%");
bool finished = false;
// set the display default
#endif
#include "insetgraphicsParams.h"
+
#include "support/translator.h"
#include "support/filetools.h"
#include "support/lyxlib.h"
#include "support/LOstream.h"
#include "support/LAssert.h"
+
+using std::ostream;
+
+
namespace {
/// This variable keeps a tab on whether the translator was set with the
left.rotateOrigin == right.rotateOrigin &&
lyx::float_equal(left.rotateAngle, right.rotateAngle, 0.001 &&
left.special == right.special)
- )
+ )
return true;
return false;
#include "buffer.h"
#include "lyxlex.h"
-using std::ostream;
-
/// This struct holds all the parameters needed by insetGraphics.
struct InsetGraphicsParams
{
///
InsetGraphicsParams & operator=(InsetGraphicsParams const &);
/// Save the parameters in the LyX format stream.
- void Write(Buffer const * buf, ostream & os) const;
+ void Write(Buffer const * buf, std::ostream & os) const;
/// If the token belongs to our parameters, read it.
bool Read(Buffer const * buf, LyXLex & lex, string const & token);
}
-int InsetInclude::ascii(Buffer const *, std::ostream & os, int) const
+int InsetInclude::ascii(Buffer const *, ostream & os, int) const
{
if (isVerbatim())
os << GetFileContents(getFileName());
void InsetIndex::edit(BufferView * bv, int, int, unsigned int)
{
- bv->owner()->getDialogs()->showIndex( this );
+ bv->owner()->getDialogs()->showIndex(this);
}
case UMLAUT: // umlaut
{
pain.text(int(x2 - (lyxfont::rbearing('¨', font) - lyxfont::lbearing('¨', font)) / 2),
- baseline - lyxfont::ascent(ic, font) - lyxfont::descent('¨', font) - ( lyxfont::ascent('¨', font) + lyxfont::descent('¨', font)) / 2,
+ baseline - lyxfont::ascent(ic, font) - lyxfont::descent('¨', font) - (lyxfont::ascent('¨', font) + lyxfont::descent('¨', font)) / 2,
'¨', font);
break;
}
#include "debug.h"
+using std::ostream;
+
+
InsetMarginal::InsetMarginal()
: InsetFootlike()
{
int InsetMarginal::latex(Buffer const * buf,
- std::ostream & os, bool fragile, bool fp) const
+ ostream & os, bool fragile, bool fp) const
{
os << "%\n\\marginpar{";
void InsetRef::edit(BufferView * bv, int, int, unsigned int button)
{
// Eventually trigger dialog with button 3 not 1
- if (button == 3 )
+ if (button == 3)
bv->owner()->getLyXFunc()->
dispatch(LFUN_REF_GOTO, getContents());
- else if (button == 1 )
- bv->owner()->getDialogs()->showRef( this );
+ else if (button == 1)
+ bv->owner()->getDialogs()->showRef(this);
}
if (getOptions().empty())
os << escape(getCommand());
else {
- InsetCommandParams p( getCmdName(), getContents(), "" );
+ InsetCommandParams p(getCmdName(), getContents(), "");
os << escape(p.getCommand());
}
return 0;
#include <map>
//#include <signal.h>
+
+using std::vector;
using std::ostream;
using std::ifstream;
using std::max;
while (p < len &&
((p = clip.find_first_of("\t\n", p)) != string::npos)) {
- switch(clip[p]) {
+ switch (clip[p]) {
case '\t':
++cols;
break;
(p = clip.find_first_of("\t\n", p)) != string::npos) {
if (p >= len)
break;
- switch(clip[p]) {
+ switch (clip[p]) {
case '\t':
paste_tabular->GetCellInset(cell)->setText(clip.substr(op, p-op));
++cols;
}
-std::vector<string> const InsetTabular::getLabelList() const
+vector<string> const InsetTabular::getLabelList() const
{
return tabular->getLabelList();
}
}
-bool InsetTabular::isRightToLeft(BufferView *bv )
+bool InsetTabular::isRightToLeft(BufferView * bv)
{
return bv->getParentLanguage(this)->RightToLeft();
}
using std::max;
using std::make_pair;
using std::vector;
+using std::pair;
using lyx::pos_type;
using lyx::layout_type;
updateLocal(bv, CURSOR_PAR, false);
return result;
} else if (result >= FINISHED) {
- switch(result) {
+ switch (result) {
case FINISHED_RIGHT:
moveRightIntern(bv, false, false);
result = DISPATCHED;
// Derive layout number from given argument (string)
// and current buffer's textclass (number). */
textclass_type tclass = bv->buffer()->params.textclass;
- std::pair <bool, layout_type> layout =
+ pair<bool, layout_type> layout =
textclasslist.NumberOfLayout(tclass, arg);
// If the entry is obsolete, use the new one instead.
}
if (environment_stack[depth] != style.latexname()) {
- if(environment_stack.size() == depth + 1) {
+ if (environment_stack.size() == depth + 1) {
environment_stack.push_back("!-- --");
environment_inner.push_back("!-- --");
}
if (style.latextype == LATEX_ENVIRONMENT) {
if (!style.latexparam().empty()) {
- if(style.latexparam() == "CDATA")
+ if (style.latexparam() == "CDATA")
os << "<![CDATA[";
else
buf->sgmlOpenTag(os, depth + command_depth,
switch (style.latextype) {
case LATEX_ENVIRONMENT:
if (!style.latexparam().empty()) {
- if(style.latexparam() == "CDATA")
+ if (style.latexparam() == "CDATA")
os << "]]>";
else
buf->sgmlCloseTag(os, depth + command_depth,
}
-std::vector<string> const InsetText::getLabelList() const
+vector<string> const InsetText::getLabelList() const
{
- std::vector<string> label_list;
+ vector<string> label_list;
Paragraph * tpar = par;
while (tpar) {
Paragraph::inset_iterator beg = tpar->inset_iterator_begin();
Paragraph::inset_iterator end = tpar->inset_iterator_end();
for (; beg != end; ++beg) {
- std::vector<string> const l = (*beg)->getLabelList();
+ vector<string> const l = (*beg)->getLabelList();
label_list.insert(label_list.end(), l.begin(), l.end());
}
tpar = tpar->next();
#include "debug.h"
#include "buffer.h"
+
using std::vector;
+using std::ostream;
+
string const InsetTOC::getScreenLabel(Buffer const *) const
{
}
-int InsetTOC::ascii(Buffer const * buffer, std::ostream & os, int) const
+int InsetTOC::ascii(Buffer const * buffer, ostream & os, int) const
{
os << getScreenLabel(buffer) << "\n\n";
}
-int InsetTOC::linuxdoc(Buffer const *, std::ostream & os) const
+int InsetTOC::linuxdoc(Buffer const *, ostream & os) const
{
if (getCmdName() == "tableofcontents")
os << "<toc>";
}
-int InsetTOC::docbook(Buffer const *, std::ostream & os) const
+int InsetTOC::docbook(Buffer const *, ostream & os) const
{
if (getCmdName() == "tableofcontents")
os << "<toc></toc>";
void InsetUrl::edit(BufferView * bv, int, int, unsigned int)
{
- bv->owner()->getDialogs()->showUrl( this );
+ bv->owner()->getDialogs()->showUrl(this);
}
string const InsetUrl::getScreenLabel(Buffer const *) const
{
string temp;
- if (getCmdName() == "url" )
+ if (getCmdName() == "url")
temp = _("Url: ");
else
temp = _("HtmlUrl: ");
ParIterator & ParIterator::operator++()
{
while (!positions.empty()) {
- ParPosition & p = positions.back();
+ ParPosition & p = positions.top();
// Does the current inset contain more "cells" ?
if (p.index >= 0) {
++p.index;
Paragraph * par = (*p.it)->getFirstParagraph(p.index);
if (par) {
- positions.push_back(ParPosition(par));
+ positions.push(ParPosition(par));
return *this;
}
++p.it;
p.it = p.par->inset_iterator_begin();
// Try to find the next inset that contains paragraphs
- for ( ; p.it != p.par->inset_iterator_end(); ++p.it) {
+ Paragraph::inset_iterator end = p.par->inset_iterator_end();
+ for (; p.it != end; ++p.it) {
Paragraph * par = (*p.it)->getFirstParagraph(0);
if (par) {
p.index = 0;
- positions.push_back(ParPosition(par));
+ positions.push(ParPosition(par));
return *this;
}
}
return *this;
}
- positions.pop_back();
+ positions.pop();
}
return *this;
}
#ifndef ITERATORS_H
#define ITERATORS_H
-#include <vector>
+#include <stack>
#include "paragraph.h"
class ParIterator {
public:
+ ///
+ typedef std::stack<ParPosition> PosHolder;
///
ParIterator() {}
- //
- ParIterator(Paragraph * par)
- : positions(1, ParPosition(par)) {}
+ ///
+ ParIterator(Paragraph * par) {
+ positions.push(ParPosition(par));
+ }
///
ParIterator & operator++();
///
- Paragraph * operator*() { return positions.back().par; }
+ Paragraph * operator*() {
+ return positions.top().par;
+ }
///
- std::vector<ParPosition>::size_type size() const
+ PosHolder::size_type size() const
{ return positions.size(); }
///
friend
bool operator==(ParIterator const & iter1, ParIterator const & iter2);
private:
///
- std::vector<ParPosition> positions;
+ PosHolder positions;
};
#include "commandtags.h"
#include "debug.h"
+
+using std::vector;
using std::endl;
+using std::hex;
+using std::dec;
+
// The only modifiers that we handle. We want to throw away things
// like NumLock.
if (deleted_)
return buf;
- for (std::vector<unsigned int>::size_type i = 0; i < length_; ++i) {
+ for (vector<unsigned int>::size_type i = 0; i < length_; ++i) {
buf += kb_keymap::printKeysym(sequence[i], modifiers[i] & 0xffff);
// append a blank
unsigned int const c = getsym();
lyxerr[Debug::KBMAP] << "Raw keysym: "
- << std::hex << c << std::dec << endl;
+ << hex << c << dec << endl;
lyxerr[Debug::KBMAP] << "byte 3: "
- << std::hex << (c & 0xff00) << std::dec
+ << hex << (c & 0xff00) << dec
<< endl;
return kb_keymap::getiso(c);
}
#include <algorithm>
#include <iterator>
+
+using std::ifstream;
+using std::ofstream;
using std::getline;
using std::endl;
+using std::find;
+using std::copy;
+using std::ostream_iterator;
LastFiles::LastFiles(string const & filename, bool st, unsigned int num)
{
// we will not complain if we can't find filename nor will
// we issue a warning. (Lgb)
- std::ifstream ifs(filename.c_str());
+ ifstream ifs(filename.c_str());
string tmp;
FileInfo fileInfo;
void LastFiles::writeFile(string const & filename) const
{
- std::ofstream ofs(filename.c_str());
+ ofstream ofs(filename.c_str());
if (ofs) {
- std::copy(files.begin(), files.end(),
- std::ostream_iterator<string>(ofs, "\n"));
+ copy(files.begin(), files.end(),
+ ostream_iterator<string>(ofs, "\n"));
} else
lyxerr << "LyX: Warning: unable to save LastFiles: "
<< filename << endl;
void LastFiles::newFile(string const & file)
{
// If file already exist, delete it and reinsert at front.
- Files::iterator it = std::find(files.begin(), files.end(), file);
+ Files::iterator it = find(files.begin(), files.end(), file);
if (it != files.end())
files.erase(it);
files.push_front(file);
}
}
if (!label.empty()) {
- InsetCommandParams p( "label", label );
- InsetLabel * inset = new InsetLabel( p );
- bv->insertInset( inset );
+ InsetCommandParams p("label", label);
+ InsetLabel * inset = new InsetLabel(p);
+ bv->insertInset(inset);
}
bv->owner()->allowInput();
}
fl_get_app_resources(res, num_res);
static const int geometryBitmask =
- XParseGeometry( geometry,
+ XParseGeometry(geometry,
&xpos,
&ypos,
reinterpret_cast<unsigned int *>(&width),
// This is probably as good a time as any to map the xform colours,
// should a mapping exist.
string const filename = AddName(user_lyxdir, "preferences.xform");
- XformsColor::read( filename );
+ XformsColor::read(filename);
// Show the main & title form
int main_placement = FL_PLACE_CENTER | FL_FREE_SIZE;
lyxerr[Debug::INIT] << "About to read " << name << "..." << endl;
string const lyxrc_path = LibFileSearch(string(), name);
- if (!lyxrc_path.empty()){
+ if (!lyxrc_path.empty()) {
lyxerr[Debug::INIT] << "Found " << name
<< " in " << lyxrc_path << endl;
if (lyxrc.read(lyxrc_path) < 0) {
break;
default:
- if(!strip(lex.getString()).empty())
+ if (!strip(lex.getString()).empty())
lex.printError("LyX::ReadUIFile: "
"Unknown menu tag: `$$Token'");
break;
inline
bool LyXFont::isSymbolFont() const
{
- switch(family()) {
+ switch (family()) {
case LyXFont::SYMBOL_FAMILY:
case LyXFont::CMSY_FAMILY:
case LyXFont::CMM_FAMILY:
using std::make_pair;
using std::endl;
using std::find_if;
+using std::vector;
+using std::transform;
+using std::back_inserter;
extern BufferList bufferlist;
extern LyXServer * lyxserver;
(!keyseq.deleted())))
{
if ((action == LFUN_UNKNOWN_ACTION)
- && argument.empty()){
+ && argument.empty()) {
argument = keyseq.getiso();
}
// Undo/Redo is a bit tricky for insets.
// --- Misc -------------------------------------------
case LFUN_EXEC_COMMAND:
{
- std::vector<string> allCmds;
- std::transform(lyxaction.func_begin(), lyxaction.func_end(),
- std::back_inserter(allCmds), lyx::firster());
- static std::vector<string> hist;
+ vector<string> allCmds;
+ transform(lyxaction.func_begin(), lyxaction.func_end(),
+ back_inserter(allCmds), lyx::firster());
+ static vector<string> hist;
owner->getMiniBuffer()->getString(MiniBuffer::spaces,
allCmds, hist);
}
#endif
p.setCmdName("tableofcontents");
#if 0
- else if (action == LFUN_LOAVIEW )
+ else if (action == LFUN_LOAVIEW)
p.setCmdName("listof{algorithm}{List of Algorithms}");
else if (action == LFUN_LOFVIEW)
p.setCmdName("listoffigures");
Paragraph * par = owner->buffer()->getParFromID(id);
if (par == 0) {
lyxerr[Debug::INFO] << "No matching paragraph found! ["
- << id << "]" << std::endl;
+ << id << "]" << endl;
break;
} else {
lyxerr << "Paragraph " << par->id()
case LFUN_CITATION_CREATE:
{
- InsetCommandParams p( "cite" );
+ InsetCommandParams p("cite");
if (!argument.empty()) {
// This should be set at source, ie when typing
// Question: would pybibliographer also need to be
// changed. Suspect so. Leave as-is therefore.
if (contains(argument, "|")) {
- p.setContents( token(argument, '|', 0) );
- p.setOptions( token(argument, '|', 1) );
+ p.setContents(token(argument, '|', 0));
+ p.setOptions( token(argument, '|', 1));
} else {
- p.setContents( argument );
+ p.setContents(argument);
}
dispatch(LFUN_CITATION_INSERT, p.getAsString());
} else
- owner->getDialogs()->createCitation( p.getAsString() );
+ owner->getDialogs()->createCitation(p.getAsString());
}
break;
string const LyXLength::asLatexString() const
{
ostringstream buffer;
- switch(unit_) {
+ switch (unit_) {
case PW:
buffer << abs(static_cast<int>(val_/100)) << "."
<< abs(static_cast<int>(val_)%100) << "\\textwidth";
}
-std::istream & LyXLex::getStream()
+istream & LyXLex::getStream()
{
return pimpl_->is;
}
is.get(cc);
c = cc;
} while (c > ' ' && c != ',' && is
- && (i != LEX_MAX_BUFF - 1) );
+ && (i != LEX_MAX_BUFF - 1));
if (i == LEX_MAX_BUFF - 1) {
printError("Line too long");
}
is.get(cc);
c = cc;
} while (c > ' ' && c != ',' && is
- && (i != LEX_MAX_BUFF - 1) );
+ && (i != LEX_MAX_BUFF - 1));
if (i == LEX_MAX_BUFF - 1) {
printError("Line too long");
}
is.get(cc);
c = cc;
} while (c > ' ' && c != ',' && is
- && (i != LEX_MAX_BUFF-1) );
+ && (i != LEX_MAX_BUFF-1));
if (i == LEX_MAX_BUFF-1) {
printError("Line too long");
}
XComposeStatus compose_status= {0, 0};
// This is called after the main LyX window has been created
-void InitLyXLookup(Display *, Window )
+void InitLyXLookup(Display *, Window)
{
//Nothing to do.
}
<< "#\n\n";
case RC_SET_COLOR:
- for (int i = 0; i < LColor::ignore; ++i ) {
+ for (int i = 0; i < LColor::ignore; ++i) {
LColor::color lc = static_cast<LColor::color>(i);
string const col(lcolor.getX11Name(lc));
// OS/2 pipes are deleted automatically
#ifndef __EMX__
- if (lyx::unlink(filename) < 0){
+ if (lyx::unlink(filename) < 0) {
lyxerr << "LyXComm: Could not remove pipe " << filename
<< '\n' << strerror(errno) << endl;
};
errno = 0;
return; // up to libforms select-loop (*crunch*)
}
- if (errno != 0 )
+ if (errno != 0)
{
lyxerr << "LyXComm: " << strerror(errno) << endl;
if (!lsbuf.empty())
// we are listening.
if (cmd == "hello") {
// One more client
- if (serv->numclients == MAX_CLIENTS){ //paranoid check
+ if (serv->numclients == MAX_CLIENTS) { //paranoid check
lyxerr[Debug::LYXSERVER]
<< "LyXServer: too many clients..."
<< endl;
using std::endl;
using std::find_if;
using std::remove_if;
+using std::ostream;
/* ******************************************************************* */
}
-std::ostream & operator<<(std::ostream & os, LyXTextClass::PageSides p)
+ostream & operator<<(ostream & os, LyXTextClass::PageSides p)
{
switch (p) {
case LyXTextClass::OneSide:
AUTOMAKE_OPTIONS = foreign 1.4
DISTCLEANFILES= *.orig *.rej *~ *.bak core
MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
-noinst_LTLIBRARIES = libmathed.la
+noinst_LTLIBRARIES = libmathed.o
LIBS=
ETAGS_ARGS = --lang=c++
BOOST_INCLUDES = -I$(top_srcdir)/boost
INCLUDES = -I${srcdir}/../ $(SIGC_CFLAGS) $(BOOST_INCLUDES)
-libmathed_la_SOURCES = \
+libmathed_o_SOURCES = \
formulabase.C \
formulabase.h \
formula.C \
}
-//std::ostream & operator<<(std::ostream & os, LyXCursor const & c)
+//ostream & operator<<(ostream & os, LyXCursor const & c)
//{
// os << '[' << c.x() << ' ' << c.y() << ' ' << c.pos() << ']';
// return os;
vector<string> const InsetFormulaBase::getLabelList() const
{
- return std::vector<string>();
+ return vector<string>();
}
}
-void InsetFormulaBase::revealCodes(BufferView * bv) const
+void InsetFormulaBase::revealCodes(BufferView * /*bv*/) const
{
if (!mathcursor)
return;
using std::vector;
using std::istringstream;
using std::getline;
+using std::istream_iterator;
MathArrayInset::MathArrayInset(string const & name, int m, int n)
string line;
getline(is, line);
istringstream ls(line.c_str());
- typedef std::istream_iterator<string> iter;
+ typedef istream_iterator<string> iter;
vector<string> v = vector<string>(iter(ls), iter());
if (v.size())
dat.push_back(v);
#include <utility>
+
+using std::swap;
+
+
MathAtom::MathAtom()
: nucleus_(0)
{}
if (&p == this)
return;
MathAtom tmp(p);
- std::swap(tmp.nucleus_, nucleus_);
+ swap(tmp.nucleus_, nucleus_);
}
#include "math_mathmlstream.h"
+using std::max;
+
+
MathBinaryOpInset::MathBinaryOpInset(char op)
: MathNestInset(2), op_(op)
{}
xcell(0).metrics(mi);
xcell(1).metrics(mi);
width_ = xcell(0).width() + xcell(1).width() + opwidth();
- ascent_ = std::max(xcell(0).ascent(), xcell(1).ascent());
- descent_ = std::max(xcell(0).descent(), xcell(1).descent());
+ ascent_ = max(xcell(0).ascent(), xcell(1).ascent());
+ descent_ = max(xcell(0).descent(), xcell(1).descent());
}
#include "math_mathmlstream.h"
+using std::max;
+
+
MathBinomInset::MathBinomInset()
{}
xcell(1).metrics(mi);
ascent_ = xcell(0).height() + 4 + 5;
descent_ = xcell(1).height() + 4 - 5;
- width_ = std::max(xcell(0).width(), xcell(1).width()) + 2 * dw() + 4;
+ width_ = max(xcell(0).width(), xcell(1).width()) + 2 * dw() + 4;
}
#include "math_mathmlstream.h"
+using std::max;
+
+
MathBraceInset::MathBraceInset()
: MathNestInset(1)
{}
xcell(0).metrics(mi);
int a, d;
mathed_char_dim(LM_TC_TEX, mi, '{', a, d, wid_);
- ascent_ = std::max(xcell(0).ascent(), a);
- descent_ = std::max(xcell(0).descent(), a);
+ ascent_ = max(xcell(0).ascent(), a);
+ descent_ = max(xcell(0).descent(), a);
width_ = xcell(0).width() + 2 * wid_;
}
#include "LaTeXFeatures.h"
+using std::ostream;
+
+
MathCharInset::MathCharInset(char c)
: char_(c), code_(nativeCode(c))
{
}
-void MathCharInset::writeHeader(std::ostream & os) const
+void MathCharInset::writeHeader(ostream & os) const
{
if (math_font_name(code_))
os << '\\' << math_font_name(code_) << '{';
}
-void MathCharInset::writeTrailer(std::ostream & os) const
+void MathCharInset::writeTrailer(ostream & os) const
{
if (math_font_name(code_))
os << '}';
}
-void MathCharInset::writeRaw(std::ostream & os) const
+void MathCharInset::writeRaw(ostream & os) const
{
os << char_;
}
{
// Make sure amssymb is put in preamble if Blackboard Bold or
// Fraktur used:
- if ( (code_ == LM_TC_BB) || (code_ == LM_TC_EUFRAK) )
+ if ((code_ == LM_TC_BB) || (code_ == LM_TC_EUFRAK))
features.require("amssymb");
}
using std::max;
using std::swap;
using std::isalnum;
+using std::vector;
+using std::ostringstream;
namespace {
c1 = p->col(i1.idx_);
c2 = p->col(i2.idx_);
if (c1 > c2)
- std::swap(c1, c2);
+ swap(c1, c2);
r1 = p->row(i1.idx_);
r2 = p->row(i2.idx_);
if (r1 > r2)
- std::swap(r1, r2);
+ swap(r1, r2);
}
void grab(MathCursor const & cursor)
{
string s;
MathInset::difference_type i = macroNamePos();
- for ( ; i >= 0 && i < int(pos()); ++i)
+ for (; i >= 0 && i < int(pos()); ++i)
s += array().at(i)->getChar();
return s;
}
int y2 = c.yo() + c.descent();
pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, LColor::selection);
} else {
- std::vector<MathInset::idx_type> indices
+ vector<MathInset::idx_type> indices
= i1.par_->idxBetween(i1.idx_, i2.idx_);
for (unsigned i = 0; i < indices.size(); ++i) {
MathXArray & c = i1.xcell(indices[i]);
{
MathIterator it = ibegin(formula()->par().nucleus());
MathIterator et = iend(formula()->par().nucleus());
- for ( ; it != et; ++it)
+ for (; it != et; ++it)
if (it.par()->asBoxInset())
it.par()->asBoxInset()->rebreak();
}
unsigned int n = 1;
istringstream is(s.substr(5).c_str());
is >> n;
- n = std::max(1u, n);
+ n = max(1u, n);
niceInsert(MathAtom(new MathCasesInset(n)));
return true;
}
string h_align;
istringstream is(s.substr(6).c_str());
is >> m >> n >> v_align >> h_align;
- m = std::max(1u, m);
- n = std::max(1u, n);
+ m = max(1u, m);
+ n = max(1u, n);
v_align += 'c';
niceInsert(MathAtom(new MathArrayInset("array", m, n, v_align[0], h_align)));
return true;
string MathCursor::info() const
{
- std::ostringstream os;
+ ostringstream os;
if (pos() > 0)
prevAtom()->infoize(os);
return os.str();
#include "math_extern.h"
+using std::max;
+
+
MathDelimInset::MathDelimInset(string const & l, string const & r)
: MathNestInset(1), left_(l), right_(r)
{}
int a, d, w;
mathed_char_dim(LM_TC_VAR, mi, 'I', a, d, w);
int h0 = (a + d) / 2;
- int a0 = std::max(xcell(0).ascent(), a) - h0;
- int d0 = std::max(xcell(0).descent(), d) + h0;
- ascent_ = std::max(a0, d0) + h0;
- descent_ = std::max(a0, d0) - h0;
+ int a0 = max(xcell(0).ascent(), a) - h0;
+ int d0 = max(xcell(0).descent(), d) + h0;
+ ascent_ = max(a0, d0) + h0;
+ descent_ = max(a0, d0) - h0;
width_ = xcell(0).width() + 2 * dw() + 8;
}
#include "debug.h"
-std::ostream & operator<<(std::ostream & os, MathArray const & ar)
+using std::ostream;
+using std::istringstream;
+using std::find_if;
+
+
+ostream & operator<<(ostream & os, MathArray const & ar)
{
NormalStream ns(os);
ns << ar;
string s;
MathTextCodes c;
charSequence(ar.begin(), ar.end(), s, c);
- std::istringstream is(s.c_str());
+ istringstream is(s.c_str());
is >> i;
return is;
}
// try to figure out the summation index from the subscript
MathArray & ar = sub->down().data_;
MathArray::iterator it =
- std::find_if(ar.begin(), ar.end(), &testEqualSign);
+ find_if(ar.begin(), ar.end(), &testEqualSign);
if (it != ar.end()) {
// we found a '=', use everything in front of that as index,
// and everything behind as lower index
string s;
if (!extractString((*it).nucleus(), s))
return false;
- std::istringstream is(s.c_str());
+ istringstream is(s.c_str());
is >> i;
return is;
}
// collect denominator parts
MathArray & denom = f->cell(1);
- for (MathArray::iterator dt = denom.begin(); dt != denom.end(); ) {
+ for (MathArray::iterator dt = denom.begin(); dt != denom.end();) {
// find the next 'd'
- MathArray::iterator et = std::find_if(dt + 1, denom.end(), &testDiffItem);
+ MathArray::iterator et = find_if(dt + 1, denom.end(), &testDiffItem);
// point before this
MathArray::iterator st = et - 1;
// things like d.../dx^n
int mult = 1;
if (extractNumber(script->up().data_, mult)) {
- //lyxerr << "mult: " << mult << std::endl;
+ //lyxerr << "mult: " << mult << endl;
for (int i = 0; i < mult; ++i)
diff->addDer(MathArray(dt + 1, st));
}
#include "math_mathmlstream.h"
+using std::max;
+
+
MathFracInset::MathFracInset(bool atop)
: atop_(atop)
{}
smallerStyleFrac(m);
xcell(0).metrics(m);
xcell(1).metrics(m);
- width_ = std::max(xcell(0).width(), xcell(1).width()) + 4;
+ width_ = max(xcell(0).width(), xcell(1).width()) + 4;
ascent_ = xcell(0).height() + 2 + 5;
descent_ = xcell(1).height() + 2 - 5;
}
#include "debug.h"
+using std::swap;
+using std::max;
+using std::min;
+using std::vector;
+
+
namespace {
string verboseHLine(int n)
int desc = 0;
for (col_type col = 0; col < ncols(); ++col) {
MathXArray const & c = xcell(index(row, col));
- asc = std::max(asc, c.ascent());
- desc = std::max(desc, c.descent());
+ asc = max(asc, c.ascent());
+ desc = max(desc, c.descent());
}
rowinfo_[row].ascent_ = asc;
rowinfo_[row].descent_ = desc;
for (col_type col = 0; col < ncols(); ++col) {
int wid = 0;
for (row_type row = 0; row < nrows(); ++row)
- wid = std::max(wid, xcell(index(row, col)).width());
+ wid = max(wid, xcell(index(row, col)).width());
colinfo_[col].width_ = wid;
}
colinfo_[ncols()].width_ = 0;
for (col_type col = 0; col < nc; ++col)
new_cells[row * (nc + 1) + col + (col > newcol)]
= cells_[row * nc + col];
- std::swap(cells_, new_cells);
+ swap(cells_, new_cells);
ColInfo inf;
inf.skip_ = defaultColSpace(newcol);
for (col_type i = 0; i < nargs(); ++i)
if (i % ncols() != col)
tmpcells.push_back(cells_[i]);
- std::swap(cells_, tmpcells);
+ swap(cells_, tmpcells);
colinfo_.erase(colinfo_.begin() + col);
}
}
-std::vector<MathInset::idx_type>
+vector<MathInset::idx_type>
MathGridInset::idxBetween(idx_type from, idx_type to) const
{
- row_type r1 = std::min(row(from), row(to));
- row_type r2 = std::max(row(from), row(to));
- col_type c1 = std::min(col(from), col(to));
- col_type c2 = std::max(col(from), col(to));
- std::vector<idx_type> res;
+ row_type r1 = min(row(from), row(to));
+ row_type r2 = max(row(from), row(to));
+ col_type c1 = min(col(from), col(to));
+ col_type c2 = max(col(from), col(to));
+ vector<idx_type> res;
for (row_type i = r1; i <= r2; ++i)
for (col_type j = c1; j <= c2; ++j)
res.push_back(index(i, j));
#include <map>
+using std::map;
namespace {
-// global
-std::map<string, latexkeys> theWordList;
+// file scope
+typedef map<string, latexkeys> WordList;
+WordList theWordList;
struct key_type {
}
}
+
void initSymbols()
{
unsigned const n = sizeof(wordlist_array) / sizeof(wordlist_array[0]);
initialized = true;
}
- std::map<string, latexkeys>::iterator it = theWordList.find(str);
+ WordList::iterator it = theWordList.find(str);
return (it != theWordList.end()) ? &(it->second) : 0;
}
#include <vector>
+using std::vector;
+using std::max;
using std::endl;
namespace {
if (numberedType()) {
int l = 0;
for (row_type row = 0; row < nrows(); ++row)
- l = std::max(l, mathed_string_width(LM_TC_BF, mi_, nicelabel(row)));
+ l = max(l, mathed_string_width(LM_TC_BF, mi_, nicelabel(row)));
if (l)
width_ += 30 + l;
int asc = 0;
int des = 0;
math_font_max_dim(LM_TC_TEXTRM, mi_, asc, des);
- ascent_ = std::max(ascent_, asc);
- descent_ = std::max(descent_, des);
+ ascent_ = max(ascent_, asc);
+ descent_ = max(descent_, des);
}
}
-std::vector<string> const MathHullInset::getLabelList() const
+vector<string> const MathHullInset::getLabelList() const
{
- std::vector<string> res;
+ vector<string> res;
for (row_type row = 0; row < nrows(); ++row)
if (!label_[row].empty() && nonum_[row] != 1)
res.push_back(label_[row]);
#include "debug.h"
+using std::ostream;
+using std::vector;
+
+
int MathInset::height() const
{
return ascent() + descent();
}
-std::ostream & operator<<(std::ostream & os, MathInset const & inset)
+ostream & operator<<(ostream & os, MathInset const & inset)
{
WriteStream wi(os, false);
inset.write(wi);
{}
-std::vector<MathInset::idx_type>
+vector<MathInset::idx_type>
MathInset::idxBetween(idx_type from, idx_type to) const
{
- std::vector<idx_type> res;
+ vector<idx_type> res;
for (idx_type i = from; i <= to; ++i)
res.push_back(i);
return res;
#include "LaTeXFeatures.h"
+using std::max;
+
+
MathMacro::MathMacro(string const & name)
: MathNestInset(MathMacroTable::provide(name)->asMacroTemplate()->numargs()),
tmplate_(MathMacroTable::provide(name))
for (idx_type i = 0; i < nargs(); ++i) {
MathXArray const & c = xcell(i);
c.metrics(mi_);
- width_ = std::max(width_, c.width() + lwid);
- descent_ += std::max(c.ascent(), lasc) + 5;
- descent_ += std::max(c.descent(), ldes) + 5;
+ width_ = max(width_, c.width() + lwid);
+ descent_ += max(c.ascent(), lasc) + 5;
+ descent_ += max(c.descent(), ldes) + 5;
}
return;
}
for (idx_type i = 0; i < nargs(); ++i) {
MathXArray const & c = xcell(i);
- h += std::max(c.ascent(), lasc) + 5;
+ h += max(c.ascent(), lasc) + 5;
c.draw(pain, x + lwid, h);
char str[] = "#1:";
str[1] += static_cast<char>(i);
drawStr(pain, LM_TC_TEX, mi_, x + 3, h, str);
- h += std::max(c.descent(), ldes) + 5;
+ h += max(c.descent(), ldes) + 5;
}
return;
}
#include "debug.h"
+using std::endl;
+
MathMacroArgument::MathMacroArgument(int n, MathTextCodes code)
: MathNestInset(1), number_(n), expanded_(false), code_(code)
{
if (n < 1 || n > 9) {
lyxerr << "MathMacroArgument::MathMacroArgument: wrong Argument id: "
- << n << std::endl;
+ << n << endl;
}
str_[0] = '#';
str_[1] = static_cast<unsigned char>('0' + n);
#include "debug.h"
+using std::endl;
+
+
MathMacroTemplate::MathMacroTemplate()
: MathNestInset(1), numargs_(0), name_()
{}
{
if (numargs_ > 9)
lyxerr << "MathMacroTemplate::MathMacroTemplate: wrong # of arguments: "
- << numargs_ << std::endl;
+ << numargs_ << endl;
}
#include "support/lyxalgo.h"
-MathMLStream::MathMLStream(std::ostream & os)
+using std::ostream;
+
+
+MathMLStream::MathMLStream(ostream & os)
: os_(os), tab_(0), line_(0), lastchar_(0)
{}
//////////////////////////////////////////////////////////////////////
-WriteStream::WriteStream(std::ostream & os, bool fragile)
+WriteStream::WriteStream(ostream & os, bool fragile)
: os_(os), fragile_(fragile), firstitem_(false), line_(0)
{}
-WriteStream::WriteStream(std::ostream & os)
+WriteStream::WriteStream(ostream & os)
: os_(os), fragile_(false), firstitem_(false), line_(0)
{}
using std::endl;
using std::stack;
using std::fill;
+using std::vector;
//#define FILEDEBUG
///
int lineno_;
///
- std::vector<Token> tokens_;
+ vector<Token> tokens_;
///
unsigned pos_;
///
#include "support/LAssert.h"
+using std::ostream;
+
MathCursorPos::MathCursorPos()
: par_(0), idx_(0), pos_(0)
{}
}
-std::ostream & operator<<(std::ostream & os, MathCursorPos const & p)
+ostream & operator<<(ostream & os, MathCursorPos const & p)
{
os << "(par: " << p.par_ << " idx: " << p.idx_ << " pos: " << p.pos_ << ")";
return os;
#include "Painter.h"
+using std::max;
+
+
MathRootInset::MathRootInset()
: MathNestInset(2)
{}
void MathRootInset::metrics(MathMetricsInfo const & mi) const
{
MathNestInset::metrics(mi);
- ascent_ = std::max(xcell(0).ascent() + 5, xcell(1).ascent()) + 2;
- descent_ = std::max(xcell(1).descent() + 5, xcell(0).descent()) + 2;
+ ascent_ = max(xcell(0).ascent() + 5, xcell(1).ascent()) + 2;
+ descent_ = max(xcell(1).descent() + 5, xcell(0).descent()) + 2;
width_ = xcell(0).width() + xcell(1).width() + 10;
}
void MathRootInset::draw(Painter & pain, int x, int y) const
{
int const w = xcell(0).width();
- xcell(0).draw(pain, x, y - 5 - xcell(0).descent()); // the "exponent"
- xcell(1).draw(pain, x + w + 8, y); // the "base"
+ // the "exponent"
+ xcell(0).draw(pain, x, y - 5 - xcell(0).descent());
+ // the "base"
+ xcell(1).draw(pain, x + w + 8, y);
int const a = ascent();
int const d = descent();
int xp[5];
#include "debug.h"
+using std::max;
+
+
MathScriptInset::MathScriptInset()
: MathNestInset(2), limits_(0)
{
if (hasLimits(nuc))
des += nd + 2;
else
- des = std::max(des, nd);
+ des = max(des, nd);
return des;
}
if (hasLimits(nuc))
asc += na + 2;
else
- asc = std::max(asc, na);
- asc = std::max(asc, mathed_char_ascent(LM_TC_VAR, mi_, 'I'));
+ asc = max(asc, na);
+ asc = max(asc, mathed_char_ascent(LM_TC_VAR, mi_, 'I'));
return asc;
}
if (hasLimits(nuc)) {
wid = nwid(nuc);
if (hasUp())
- wid = std::max(wid, up().width());
+ wid = max(wid, up().width());
if (hasDown())
- wid = std::max(wid, down().width());
+ wid = max(wid, down().width());
} else {
if (hasUp())
- wid = std::max(wid, up().width());
+ wid = max(wid, up().width());
if (hasDown())
- wid = std::max(wid, down().width());
+ wid = max(wid, down().width());
wid += nwid(nuc);
}
return wid;
#include "math_support.h"
+using std::max;
+
+
MathStackrelInset::MathStackrelInset()
{}
smallerStyleFrac(m);
xcell(0).metrics(m);
xcell(1).metrics(mi);
- width_ = std::max(xcell(0).width(), xcell(1).width()) + 4;
+ width_ = max(xcell(0).width(), xcell(1).width()) + 4;
ascent_ = xcell(1).ascent() + xcell(0).height() + 4;
descent_ = xcell(1).descent();
}
if (r >= 2)
x += w;
- for (int i = 0; d[i]; ) {
+ for (int i = 0; d[i];) {
int code = int(d[i++]);
if (code & 1) { // code == 1 || code == 3
double xx = d[i++];
#include "debug.h"
+using std::ostream;
+
+
MathSymbolInset::MathSymbolInset(const latexkeys * l)
: sym_(l), h_(0)
{}
MathTextCodes MathSymbolInset::code() const
{
- switch(sym_->token) {
+ switch (sym_->token) {
case LM_TK_CMR:
return LM_TC_CMR;
case LM_TK_CMSY:
}
-void MathSymbolInset::infoize(std::ostream & os) const
+void MathSymbolInset::infoize(ostream & os) const
{
os << '\\' << name();
}
#include "math_support.h"
+using std::max;
+
+
MathUndersetInset::MathUndersetInset()
{}
smallerStyleFrac(m);
xcell(0).metrics(m);
xcell(1).metrics(mi);
- width_ = std::max(xcell(0).width(), xcell(1).width()) + 4;
+ width_ = max(xcell(0).width(), xcell(1).width()) + 4;
ascent_ = xcell(1).ascent();
descent_ = xcell(1).descent() + xcell(0).height() + 4;
}
#include "debug.h"
+using std::max;
+using std::min;
+
+
extern MathScriptInset const * asScript(MathArray::const_iterator it);
MathScriptInset const * q = (it + 1 == end()) ? 0 : asScript(it);
if (q) {
q->metrics(p, mi);
- ascent_ = std::max(ascent_, q->ascent2(p));
- descent_ = std::max(descent_, q->descent2(p));
+ ascent_ = max(ascent_, q->ascent2(p));
+ descent_ = max(descent_, q->descent2(p));
width_ += q->width2(p);
++it;
} else {
p->metrics(mi);
- ascent_ = std::max(ascent_, p->ascent());
- descent_ = std::max(descent_, p->descent());
+ ascent_ = max(ascent_, p->ascent());
+ descent_ = max(descent_, p->descent());
width_ += p->width();
}
}
int MathXArray::pos2x(size_type targetpos) const
{
int x = 0;
- const_iterator target = std::min(begin() + targetpos, end());
+ const_iterator target = min(begin() + targetpos, end());
for (const_iterator it = begin(); it < target; ++it) {
MathInset const * p = it->nucleus();
MathScriptInset const * q = (it + 1 == end()) ? 0 : asScript(it);
const_iterator it = begin();
int lastx = 0;
int currx = 0;
- for ( ; currx < targetx && it < end(); ++it) {
+ for (; currx < targetx && it < end(); ++it) {
lastx = currx;
int wid = 0;
center(cx, cy);
double r = 1.0;
- int dist = (x - cx) * (x - cx) + (y - cy) * (y - cy);
+ //int dist = (x - cx) * (x - cx) + (y - cy) * (y - cy);
x = cx + int(r * (x - cx));
y = cy + int(r * (y - cy));
#include "debug.h"
+using std::max;
+
+
MathXYArrowInset::MathXYArrowInset()
: MathNestInset(2)
{}
if (editing()) {
int w = mathed_string_width(LM_TC_TEXTRM, mi_, "target: ");
- width_ = w + std::max(xcell(0).width(), xcell(1).width());
+ width_ = w + max(xcell(0).width(), xcell(1).width());
ascent_ = xcell(0).ascent();
descent_ = xcell(0).descent() + xcell(1).height() + 10;
} else {
xcell(0).draw(pain, x + lwid, y);
drawStr(pain, LM_TC_TEXTRM, mi_, x + 3, y, "target");
- y += std::max(xcell(0).descent(), ldes) + 5;
+ y += max(xcell(0).descent(), ldes) + 5;
- y += std::max(xcell(1).ascent(), lasc) + 5;
+ y += max(xcell(1).ascent(), lasc) + 5;
xcell(1).draw(pain, x + lwid, y);
drawStr(pain, LM_TC_TEXTRM, mi_, x + 3, y, "label");
using SigC::slot;
using std::vector;
+using std::back_inserter;
+using std::find;
extern LyXAction lyxaction;
vector<string> comp;
lyx::copy_if(completion_.begin(),
completion_.end(),
- std::back_inserter(comp), prefix(input));
+ back_inserter(comp), prefix(input));
if (comp.empty()) {
// No matches
vector<string> vtmp;
lyx::copy_if(comp.begin(),
comp.end(),
- std::back_inserter(vtmp),
+ back_inserter(vtmp),
prefix(test));
if (vtmp.size() != comp.size()) {
test.erase(test.length() - 1);
// of argumetns LFUN's should have first. (Lgb)
// First check for match
vector<string>::const_iterator cit =
- std::find(completion_.begin(),
+ find(completion_.begin(),
completion_.end(),
input);
if (cit == completion_.end()) {
Paragraph * Paragraph::outerHook()
{
- if(!getDepth())
+ if (!getDepth())
return 0;
return depthHook(depth_type(getDepth() - 1));
}
Paragraph const * Paragraph::outerHook() const
{
- if(!getDepth())
+ if (!getDepth())
return 0;
return depthHook(depth_type(getDepth() - 1));
}
texrow.newline();
}
- if (tex_code_break_column && style.isCommand()){
+ if (tex_code_break_column && style.isCommand()) {
os << '\n';
texrow.newline();
}
further_blank_line = true;
}
- if (further_blank_line){
+ if (further_blank_line) {
os << '\n';
texrow.newline();
}
further_blank_line = true;
}
- if (further_blank_line){
+ if (further_blank_line) {
os << '\n';
texrow.newline();
}
}
-bool Paragraph::isWord(pos_type pos ) const
+bool Paragraph::isWord(pos_type pos) const
{
return IsWordChar(getChar(pos)) ;
}
#include "support/LAssert.h"
using lyx::pos_type;
+using std::endl;
+using std::ostream;
+using std::upper_bound;
+using std::lower_bound;
extern int tex_code_break_column;
// Update the font table.
FontTable search_font(pos, LyXFont());
- for (FontList::iterator it = std::lower_bound(fontlist.begin(),
+ for (FontList::iterator it = lower_bound(fontlist.begin(),
fontlist.end(),
search_font, matchFT());
it != fontlist.end(); ++it)
// Update the inset table.
InsetTable search_inset(pos, 0);
- for (InsetList::iterator it = std::lower_bound(owner_->insetlist.begin(),
+ for (InsetList::iterator it = lower_bound(owner_->insetlist.begin(),
owner_->insetlist.end(),
search_inset, matchIT());
it != owner_->insetlist.end(); ++it)
// Add a new entry in the inset table.
InsetTable search_inset(pos, 0);
- InsetList::iterator it = std::lower_bound(owner_->insetlist.begin(),
+ InsetList::iterator it = lower_bound(owner_->insetlist.begin(),
owner_->insetlist.end(),
search_inset, matchIT());
if (it != owner_->insetlist.end() && it->pos == pos) {
lyxerr << "ERROR (Paragraph::InsertInset): "
- "there is an inset in position: " << pos << std::endl;
+ "there is an inset in position: " << pos << endl;
} else {
owner_->insetlist.insert(it, InsetTable(pos, inset));
inset->parOwner(owner_);
// find the entry
InsetTable search_inset(pos, 0);
InsetList::iterator it =
- std::lower_bound(owner_->insetlist.begin(),
+ lower_bound(owner_->insetlist.begin(),
owner_->insetlist.end(),
search_inset, matchIT());
if (it != owner_->insetlist.end() && it->pos == pos) {
FontTable search_font(pos, LyXFont());
FontList::iterator it =
- std::lower_bound(fontlist.begin(),
+ lower_bound(fontlist.begin(),
fontlist.end(),
search_font, matchFT());
if (it != fontlist.end() && it->pos() == pos &&
InsetTable search_inset(pos, 0);
InsetList::iterator lend = owner_->insetlist.end();
for (InsetList::iterator it =
- std::upper_bound(owner_->insetlist.begin(),
+ upper_bound(owner_->insetlist.begin(),
lend,
search_inset, matchIT());
it != lend; ++it)
}
-void Paragraph::Pimpl::simpleTeXBlanks(std::ostream & os, TexRow & texrow,
+void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow,
pos_type const i,
int & column, LyXFont const & font,
LyXLayout const & style)
void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf,
BufferParams const & bparams,
- std::ostream & os,
+ ostream & os,
TexRow & texrow,
bool moving_arg,
LyXFont & font,
Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf,
BufferParams const & bparams,
- std::ostream & os, TexRow & texrow)
+ ostream & os, TexRow & texrow)
{
- lyxerr[Debug::LATEX] << "TeXDeeper... " << this << std::endl;
+ lyxerr[Debug::LATEX] << "TeXDeeper... " << this << endl;
Paragraph * par = owner_;
while (par && par->params().depth() == owner_->params().depth()) {
os, texrow, false);
}
}
- lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << std::endl;
+ lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl;
return par;
}
// Secure against very strange situations
int const y2 = max(y_tmp, y1);
- if (cursor_pixmap){
+ if (cursor_pixmap) {
XFreePixmap(fl_get_display(), cursor_pixmap);
cursor_pixmap = 0;
}
{
if (!cursor_visible) return;
- if (cursor_pixmap){
+ if (cursor_pixmap) {
XCopyArea (fl_get_display(),
cursor_pixmap,
owner.getWin(),
+// -*- C++ -*-
#ifndef SP_BASE_H
#define SP_BASE_H
virtual ~SpellBase() {}
- virtual void initialize(BufferParams const & , string const & ) = 0;
+ virtual void initialize(BufferParams const & , string const &) = 0;
virtual bool alive() = 0;
virtual void close() = 0;
- virtual void insert(string const & ) = 0;
+ virtual void insert(string const &) = 0;
- virtual void accept(string const & ) = 0;
+ virtual void accept(string const &) = 0;
- virtual void store(string const & , string const & ) = 0;
+ virtual void store(string const & , string const &) = 0;
virtual char const * error() = 0;
AUTOMAKE_OPTIONS = foreign
DISTCLEANFILES= *.orig *.rej *~ *.bak core
MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
-noinst_LTLIBRARIES = libsupport.la
+noinst_LTLIBRARIES = libsupport.o
LIBS =
ETAGS_ARGS = --lang=c++
BOOST_INCLUDES = -I$(top_srcdir)/boost
REGEX = regex.c lyxregex.h
endif
-libsupport_la_SOURCES = \
+libsupport_o_SOURCES = \
DebugStream.C \
DebugStream.h \
FileInfo.C \
#include "support/lyxlib.h"
#include "LString.h"
+using std::ifstream;
+using std::ofstream;
+using std::ios;
+
bool lyx::copy(string const & from, string const & to)
{
- std::ifstream ifs(from.c_str());
- if (!ifs) return false;
- std::ofstream ofs(to.c_str(),
- std::ios::binary | std::ios::out | std::ios::trunc);
- if (!ofs) return false;
+ ifstream ifs(from.c_str());
+ if (!ifs)
+ return false;
+ ofstream ofs(to.c_str(),
+ ios::binary | ios::out | ios::trunc);
+ if (!ofs)
+ return false;
ofs << ifs.rdbuf();
- if (ofs.good()) return true;
+ if (ofs.good())
+ return true;
return false;
}
char lowercase(char c)
{
- return char( tolower(c) );
+ return char(tolower(c));
}
char uppercase(char c)
{
- return char( toupper(c) );
+ return char(toupper(c));
}
///
bool contains(char const * a, char const * b);
+/// This should probably we rewritten to be more general.
+class contains_functor {
+public:
+ typedef string first_argument_type;
+ typedef string second_argument_type;
+ typedef bool result_type;
+
+ bool operator()(string const & haystack, string const & needle) const {
+ return contains(haystack, needle);
+ }
+};
+
+
///
bool containsOnly(string const &, char const *);
// Functors used in the template.
///
-template<typename T1, typename T2>
+template<typename T>
class equal_1st_in_pair {
public:
///
- equal_1st_in_pair(T1 const & value) : value_(value) {}
+ typedef typename T::first_type first_type;
///
- typedef std::pair<T1, T2> pair_type;
+ typedef T pair_type;
+ ///
+ equal_1st_in_pair(first_type const & value) : value_(value) {}
///
bool operator() (pair_type const & p) const {
return p.first == value_;
}
private:
///
- T1 const & value_;
+ first_type const & value_;
};
///
-template<typename T1, typename T2>
+template<typename T>
class equal_2nd_in_pair {
public:
///
- equal_2nd_in_pair(T2 const & value) : value_(value) {}
+ typedef typename T::second_type second_type;
+ ///
+ typedef T pair_type;
///
- typedef std::pair<T1, T2> pair_type;
+ equal_2nd_in_pair(second_type const & value) : value_(value) {}
///
bool operator() (pair_type const & p) const {
return p.second == value_;
}
private:
///
- T2 const & value_;
+ second_type const & value_;
};
} // end of namespace lyx
#include "support/lyxlib.h"
#include "debug.h"
-using std::endl;
-
// Various implementations of lyx::sum(), depending on what methods
// are available. Order is faster to slowest.
#if defined(HAVE_MMAP) && defined(HAVE_MUNMAP)
#include <unistd.h>
#include <sys/mman.h>
+using std::ifstream;
+using std::endl;
+using std::for_each;
+using std::istreambuf_iterator;
+using std::istream_iterator;
+using std::ios;
+
+
unsigned long lyx::sum(string const & file)
{
lyxerr[Debug::FILES] << "lyx::sum() using mmap (lightning fast)"
<< endl;
int fd = open(file.c_str(), O_RDONLY);
- if(!fd)
+ if (!fd)
return 0;
struct stat info;
unsigned long do_crc(InputIterator first, InputIterator last)
{
boost::crc_32_type crc;
- crc = std::for_each(first, last, crc);
+ crc = for_each(first, last, crc);
return crc.checksum();
}
lyxerr[Debug::FILES] << "lyx::sum() using istreambuf_iterator (fast)"
<< endl;
- std::ifstream ifs(file.c_str());
+ ifstream ifs(file.c_str());
if (!ifs) return 0;
- std::istreambuf_iterator<char> beg(ifs);
- std::istreambuf_iterator<char> end;
+ istreambuf_iterator<char> beg(ifs);
+ istreambuf_iterator<char> end;
return do_crc(beg,end);
}
<< "lyx::sum() using istream_iterator (slow as a snail)"
<< endl;
- std::ifstream ifs(file.c_str());
+ ifstream ifs(file.c_str());
if (!ifs) return 0;
- ifs.unsetf(std::ios::skipws);
- std::istream_iterator<char> beg(ifs);
- std::istream_iterator<char> end;
+ ifs.unsetf(ios::skipws);
+ istream_iterator<char> beg(ifs);
+ istream_iterator<char> end;
return do_crc(beg,end);
}
#ifdef __EMX__
#include "os_os2.C"
-#elif defined(__CYGWIN__) || defined( __CYGWIN32__)
+#elif defined(__CYGWIN__) || defined(__CYGWIN32__)
#include "os_win32.C"
#else
#include "os_unix.C"
return *this;
}
-#if !defined( BOOST_NO_MEMBER_TEMPLATES )
+#if !defined(BOOST_NO_MEMBER_TEMPLATES)
template<typename Y>
shared_c_ptr(const shared_c_ptr<Y>& r) : px(r.px) { // never throws
++*(pn = r.pn);
#endif
void reset(T* p=0) {
- if ( px == p ) return; // fix: self-assignment safe
+ if (px == p) return; // fix: self-assignment safe
if (--*pn == 0) { checked_delete(px); }
else { // allocate new reference counter
#ifndef LYX_NO_EXCEPTIONS
// Tasteless as this may seem, making all members public allows member templates
// to work in the absence of member template friends. (Matthew Langston)
// Don't split this line into two; that causes problems for some GCC 2.95.2 builds
-#if defined(BOOST_NO_MEMBER_TEMPLATES) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS )
+#if defined(BOOST_NO_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
private:
#endif
/// Word is not IsSeparator or IsKomma or IsHfill or IsFloat or IsInset.
inline
bool IsWordChar(unsigned char c) {
- return !( IsSeparatorChar( c )
- || IsKommaChar( c )
- || IsHfillChar( c )
- || IsInsetChar( c ));
+ return !(IsSeparatorChar(c)
+ || IsKommaChar(c)
+ || IsHfillChar(c)
+ || IsInsetChar(c));
}
// For explanation see the next find() function.
Map::const_iterator it =
std::find_if(map.begin(), map.end(),
- lyx::equal_1st_in_pair<T1, T2>(first)
+ lyx::equal_1st_in_pair<MapPair>(first)
);
if (it != map.end()) {
// to take only the second value of the pair to be compared.
//
// We can depict it as follows:
- // equal_to( select2nd(pair) , second)
+ // equal_to(select2nd(pair) , second)
Map::const_iterator it =
std::find_if(map.begin(), map.end(),
- lyx::equal_2nd_in_pair<T1, T2>(second)
+ lyx::equal_2nd_in_pair<MapPair>(second)
);
if (it != map.end())
}
}
for (int column = 0; column < columns_ && top; ++column) {
- switch (cell_info[row][column].multicolumn){
+ switch (cell_info[row][column].multicolumn) {
case LyXTabular::CELL_BEGIN_OF_MULTICOLUMN:
top = cell_info[row][column].top_line;
break;
{
int x = 0;
- switch (GetAlignment(cell)){
+ switch (GetAlignment(cell)) {
case LYX_ALIGN_CENTER:
x += (GetWidthOfColumn(cell) - GetWidthOfCell(cell)) / 2;
break;
if (TopLine(i))
++tmp;
}
- if (tmp == (n - fcell)){
+ if (tmp == (n - fcell)) {
os << "\\hline ";
} else if (tmp) {
for (int i = fcell; i < n; ++i) {
if (BottomLine(i))
++tmp;
}
- if (tmp == (n-fcell)){
+ if (tmp == (n - fcell)) {
os << "\\hline";
} else if (tmp) {
for (int i = fcell; i < n; ++i) {
os << "%\n\\end{minipage}";
ret += 2;
}
- if (IsMultiColumn(cell)){
+ if (IsMultiColumn(cell)) {
os << '}';
}
if (GetRotateCell(cell)) {
#warning Jose please have a look here I changed the longtable header/footer
#warning ---- options so I had to disable the docbook code (Jug 20011219)
#if 0
- if ( IsLongTabular() ) {
+ if (IsLongTabular()) {
// Header
- if(endhead.row || endfirsthead.row ) {
+ if (endhead.row || endfirsthead.row) {
os << "<thead>\n";
- if( endfirsthead.row ) {
- docbookRow( buf, os, endfirsthead.row - 1);
+ if (endfirsthead.row) {
+ docbookRow(buf, os, endfirsthead.row - 1);
}
- if( endhead.row && endhead.row != endfirsthead.row) {
+ if (endhead.row && endhead.row != endfirsthead.row) {
docbookRow(buf, os, endhead.row - 1);
}
os << "</thead>\n";
}
// Footer
- if( endfoot.row || endlastfoot.row ) {
+ if (endfoot.row || endlastfoot.row) {
os << "<tfoot>\n";
- if( endfoot.row ) {
- docbookRow( buf, os, endfoot.row - 1);
+ if (endfoot.row) {
+ docbookRow(buf, os, endfoot.row - 1);
}
- if( endlastfoot.row && endlastfoot.row != endfoot.row) {
- docbookRow( buf, os, endlastfoot.row - 1);
+ if (endlastfoot.row && endlastfoot.row != endfoot.row) {
+ docbookRow(buf, os, endlastfoot.row - 1);
}
os << "</tfoot>\n";
}
os << "<tbody>\n";
for (int i = 0; i < rows_; ++i) {
- if(!IsLongTabular() || (
+ if (!IsLongTabular() || (
!row_info[i].endhead && !row_info[i].endfirsthead &&
!row_info[i].endfoot && !row_info[i].endlastfoot)) {
- docbookRow( buf, os, i);
+ docbookRow(buf, os, i);
}
}
os << "</tbody>\n";
}
-std::vector<string> const LyXTabular::getLabelList() const
+vector<string> const LyXTabular::getLabelList() const
{
- std::vector<string> label_list;
+ vector<string> label_list;
for (int i = 0; i < rows_; ++i)
for (int j = 0; j < columns_; ++j) {
- std::vector<string> const l =
+ vector<string> const l =
GetCellInset(i, j)->getLabelList();
label_list.insert(label_list.end(),
l.begin(), l.end());
string const tostr(LyXAlignment const & num)
{
- switch(num) {
+ switch (num) {
case LYX_ALIGN_NONE:
return "none";
case LYX_ALIGN_BLOCK:
string const tostr(LyXTabular::VAlignment const & num)
{
- switch(num) {
+ switch (num) {
case LyXTabular::LYX_VALIGN_TOP:
return "top";
case LyXTabular::LYX_VALIGN_CENTER:
string const tostr(LyXTabular::BoxType const & num)
{
- switch(num) {
+ switch (num) {
case LyXTabular::BOX_NONE:
return "none";
case LyXTabular::BOX_PARBOX:
tex_accent_struct get_accent(kb_action action)
{
int i = 0;
- while (i <= TEX_MAX_ACCENT){
+ while (i <= TEX_MAX_ACCENT) {
if (lyx_accent_table[i].action == action)
return lyx_accent_table[i];
++i;
class same_rownumber {
public:
- same_rownumber(TexRow::RowList::value_type const & v):vt(v){}
+ same_rownumber(TexRow::RowList::value_type const & v):vt(v) {}
bool operator()(TexRow::RowList::value_type const & vt1) const {
return vt.rownumber() == vt1.rownumber();
}
" fall back to the brute force method" << endl;
Buffer::inset_iterator it = bview->buffer()->inset_iterator_begin();
Buffer::inset_iterator end = bview->buffer()->inset_iterator_end();
- for ( ; it != end; ++it) {
+ for (; it != end; ++it) {
if (*it == inset) {
par = it.getPar();
pos = it.getPos();
getFont(bview->buffer(),
cursor.par(),
cursor.pos() - 1).number() == LyXFont::ON)
- )
+ )
number(bview); // Set current_font.number to OFF
} else if (IsDigit(c) &&
real_current_font.isVisibleRightToLeft()) {
if (contains(number_unary_operators, c) &&
(cursor.pos() == 1 ||
cursor.par()->isSeparator(cursor.pos() - 2) ||
- cursor.par()->isNewline(cursor.pos() - 2) )
- ) {
+ cursor.par()->isNewline(cursor.pos() - 2))
+ ) {
setCharFont(bview->buffer(),
cursor.par(),
cursor.pos() - 1,
}
// Advance through word.
while (tmpcursor.pos() < tmpcursor.par()->size() &&
- tmpcursor.par()->isWord( tmpcursor.pos())) {
+ tmpcursor.par()->isWord(tmpcursor.pos())) {
// printf("Current pos2 %d", tmpcursor.pos()) ;
tmpcursor.pos(tmpcursor.pos() + 1);
++steps;
&& !tmpcursor.par()->isNewline(tmpcursor.pos()))
tmpcursor.pos(tmpcursor.pos() + 1);
- if (tmpcursor.pos() == tmpcursor.par()->size()){
+ if (tmpcursor.pos() == tmpcursor.par()->size()) {
if (tmpcursor.par()->next()) {
tmpcursor.par(tmpcursor.par()->next());
tmpcursor.pos(0);
|| cur.par()->isHfill(cur.pos() - 1))) {
cur.pos(cur.pos() - 1);
} else if (!cur.pos()) {
- if (cur.par()->previous()){
+ if (cur.par()->previous()) {
cur.par(cur.par()->previous());
cur.pos(cur.par()->size());
}
} else { // Here, cur != 0
while (cur.pos() > 0 &&
- cur.par()->isWord(cur.pos()-1) )
+ cur.par()->isWord(cur.pos()-1))
cur.pos(cur.pos() - 1);
}
}
{
// first put the cursor where we wana start to select the word
from = cursor;
- switch(loc) {
+ switch (loc) {
case WHOLE_WORD_STRICT:
if (cursor.pos() == 0 || cursor.pos() == cursor.par()->size()
|| cursor.par()->isSeparator(cursor.pos())
while (to.pos() < to.par()->size()
&& !to.par()->isSeparator(to.pos())
&& !to.par()->isKomma(to.pos())
- && !to.par()->isHfill(to.pos()) )
+ && !to.par()->isHfill(to.pos()))
{
to.pos(to.pos() + 1);
}
if (to == from)
return;
selection.cursor = cursor;
- setCursor(bview, to.par(), to.pos() );
+ setCursor(bview, to.par(), to.pos());
setSelection(bview);
}
}
// Update the value if we changed paragraphs
- if (cursor.par() != tmppar){
+ if (cursor.par() != tmppar) {
setCursor(bview, cursor.par(), cursor.pos());
value = float(cursor.y())/float(height);
}
LyXFont font;
font.decSize();
- int const min_size = std::max(3 * arrow_size,
+ int const min_size = max(3 * arrow_size,
lyxfont::maxAscent(font)
+ lyxfont::maxDescent(font));
if (vsp.length().len().value() < 0.0)
return min_size;
else
- return std::max(min_size, space_size);
+ return max(min_size, space_size);
}
float x = p.x;
if (layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) {
x = ((is_rtl ? leftMargin(p.bv, p.row) : p.x)
- + ww - rightMargin(buffer, p.row) ) / 2;
+ + ww - rightMargin(buffer, p.row)) / 2;
x -= lyxfont::width(str, font) / 2;
} else if (is_rtl) {
x = ww - leftMargin(p.bv, p.row) -
if (row->pos() > last) // Row is empty?
c = row->pos();
else if (lastrow &&
- ( ( rtl && left_side && vc == row->pos() && x < tmpx - 5) ||
- (!rtl && !left_side && vc == last + 1 && x > tmpx + 5) ))
+ ((rtl && left_side && vc == row->pos() && x < tmpx - 5) ||
+ (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
c = last + 1;
else if (vc == row->pos()) {
c = vis2log(vc);
#include "support/textutils.h"
#include "support/lstrings.h"
+using std::vector;
using std::copy;
using std::find;
using std::endl;
layoutfont = layout.font;
// Realize against environment font information
- if (par->getDepth()){
+ if (par->getDepth()) {
Paragraph * tp = par;
while (!layoutfont.resolved() && tp && tp->getDepth()) {
tp = tp->outerHook();
layoutfont = layout.font;
// Realize against environment font information
- if (par->getDepth()){
+ if (par->getDepth()) {
Paragraph * tp = par;
while (!layoutfont.resolved() && tp && tp->getDepth()) {
tp = tp->outerHook();
par->incCounter(i);
int number = par->getCounter(i);
if (!par->bibkey) {
- InsetCommandParams p( "bibitem" );
+ InsetCommandParams p("bibitem" );
par->bibkey = new InsetBibKey(p);
}
par->bibkey->setCounter(number);
bool LyXText::gotoNextInset(BufferView * bview,
- std::vector<Inset::Code> const & codes,
+ vector<Inset::Code> const & codes,
string const & contents) const
{
LyXCursor res = cursor;
#include "debug.h"
#include "trans_mgr.h"
+using std::map;
using std::endl;
tex_accent accent_2= getkeymod(str);
if (accent_2 == TEX_NOACCENT) return -1;
- std::map<int, KmodInfo>::iterator it1 =
+ map<int, KmodInfo>::iterator it1 =
kmod_list_.find(accent_1);
- std::map<int, KmodInfo>::iterator it2 =
+ map<int, KmodInfo>::iterator it2 =
kmod_list_.find(accent_2);
if (it1 == kmod_list_.end()
|| it2 == kmod_list_.end()) {
// Find what key accent_2 is on - should
// check about accent_1 also
- std::map<int, string>::iterator it = keymap_.begin();
- std::map<int, string>::iterator end = keymap_.end();
+ map<int, string>::iterator it = keymap_.begin();
+ map<int, string>::iterator end = keymap_.end();
for (; it != end; ++it) {
if (!it->second.empty()
&& it->second[0] == 0
bool Trans::isAccentDefined(tex_accent accent, KmodInfo & i) const
{
- std::map<int, KmodInfo>::const_iterator cit = kmod_list_.find(accent);
+ map<int, KmodInfo>::const_iterator cit = kmod_list_.find(accent);
if (cit != kmod_list_.end()) {
i = cit->second;
return true;
#include <vector>
#endif
+using std::vector;
+
+
/// the flag used by FinishUndo();
bool undo_finished;
/// a flag
// now remove the old text if there is any
#ifdef DELETE_UNUSED_PARAGRAPHS
-
std::vector<Paragraph *> vvpar;
+ vector<Paragraph *> vvpar;
#endif
if (before != behind || (!behind && !before)) {
if (before)
}
// put the new stuff in the list if there is one
- if (tmppar3){
+ if (tmppar3) {
if (before)
before->next(tmppar3);
else
// which not always is true.
bv->text->redoParagraphs(bv, bv->text->cursor,
bv->text->cursor.par());
- if (tmppar){
+ if (tmppar) {
it = static_cast<UpdatableInset*>(tmppar->inInset());
LyXText * t;
if (it) {
delete undo;
#ifdef DELETE_UNUSED_PARAGRAPHS
// And here it's save enough to delete all removed paragraphs
-
std::vector<Paragraph *>::iterator pit = vvpar.begin();
+ vector<Paragraph *>::iterator pit = vvpar.begin();
if (pit != vvpar.end()) {
lyxerr << "DEL: ";
for(;pit != vvpar.end(); ++pit) {
// appear one by one when undoing.
// EDIT is special since only layout information, not the
// contents of a paragaph are stored.
- if (!undo_finished && (kind != Undo::EDIT) && (kind != Undo::FINISH)){
+ if (!undo_finished && (kind != Undo::EDIT) && (kind != Undo::FINISH)) {
// check wether storing is needed
if (!bv->buffer()->undostack.empty() &&
bv->buffer()->undostack.top()->kind == kind &&
int VSpace::inPixels(BufferView * bv) const
{
// Height of a normal line in pixels (zoom factor considered)
- int default_height = bv->text->defaultHeight(); // [pixels]
- int default_width = bv->workWidth();
+ int const default_height = bv->text->defaultHeight(); // [pixels]
+ int retval = 0;
+
switch (kind_) {
case NONE:
- return 0;
+ // Value for this is already set
+ break;
case DEFSKIP:
- return bv->buffer()->params.getDefSkip().inPixels(bv);
-
+ retval = bv->buffer()->params.getDefSkip().inPixels(bv);
+ break;
+
// This is how the skips are normally defined by
// LateX. But there should be some way to change
// this per document.
case SMALLSKIP:
- return default_height / 4;
+ retval = default_height / 4;
+ break;
+
case MEDSKIP:
- return default_height / 2;
+ retval = default_height / 2;
+ break;
+
case BIGSKIP:
- return default_height;
+ retval = default_height;
+ break;
case VFILL:
// leave space for the vfill symbol
- return 3 * default_height;
+ retval = 3 * default_height;
+ break;
+
case LENGTH:
- return len_.len().inPixels(default_width, default_height);
+ {
+ int const default_width = bv->workWidth();
+ retval = len_.len().inPixels(default_width, default_height);
+ break;
}
- // we cannot go there, but there is a compiler warning...
- return 0;
+
+ }
+
+ return retval;
}
projects / lyx.git / commitdiff