{
oss_.imbue( loc );
state0_.set_by_stream(oss_);
- parse(s);
+ parse(s);
}
#endif //BOOST_NO_STD_LOCALE
items_(), oss_(), exceptions_(io::all_error_bits)
{
state0_.set_by_stream(oss_);
- parse(s);
+ parse(s);
}
template< class Ch, class Tr>
basic_format<Ch, Tr> :: basic_format(const basic_format& x)
- : style_(x.style_), cur_arg_(x.cur_arg_), num_args_(x.num_args_), dumped_(false),
- items_(x.items_), prefix_(x.prefix_), bound_(x.bound_),
+ : style_(x.style_), cur_arg_(x.cur_arg_), num_args_(x.num_args_), dumped_(false),
+ items_(x.items_), prefix_(x.prefix_), bound_(x.bound_),
oss_(), // <- we obviously can't copy x.oss_
state0_(x.state0_), exceptions_(x.exceptions_)
-{
+{
state0_.apply_on(oss_);
-}
+}
template< class Ch, class Tr>
basic_format<Ch, Tr>& basic_format<Ch, Tr> ::operator= (const basic_format& x)
items_ = x.items_;
prefix_ = x.prefix_;
bound_=x.bound_;
- style_=x.style_;
- cur_arg_=x.cur_arg_;
+ style_=x.style_;
+ cur_arg_=x.cur_arg_;
num_args_=x.num_args_;
dumped_=x.dumped_;
return *this;
template< class Ch, class Tr>
-unsigned char basic_format<Ch,Tr> ::exceptions() const
+unsigned char basic_format<Ch,Tr> ::exceptions() const
{
- return exceptions_;
+ return exceptions_;
}
template< class Ch, class Tr>
-unsigned char basic_format<Ch,Tr> ::exceptions(unsigned char newexcept)
-{
- unsigned char swp = exceptions_;
- exceptions_ = newexcept;
- return swp;
+unsigned char basic_format<Ch,Tr> ::exceptions(unsigned char newexcept)
+{
+ unsigned char swp = exceptions_;
+ exceptions_ = newexcept;
+ return swp;
}
}
template< class Ch, class Tr>
-basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_binds()
+basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_binds()
// cancel all bindings, and clear()
{
bound_.resize(0);
}
template< class Ch, class Tr>
-basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_bind(int argN)
+basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_bind(int argN)
// cancel the binding of ONE argument, and clear()
{
- if(argN<1 || argN > num_args_ || bound_.size()==0 || !bound_[argN-1] )
+ if(argN<1 || argN > num_args_ || bound_.size()==0 || !bound_[argN-1] )
{
if( exceptions() & io::out_of_range_bit )
boost::throw_exception(io::out_of_range()); // arg not in range.
unsigned long sz = prefix_.size();
unsigned long i;
- for(i=0; i < items_.size(); ++i)
+ for(i=0; i < items_.size(); ++i)
sz += items_[i].res_.size() + items_[i].appendix_.size();
string_t res;
res.reserve(sz);
res += prefix_;
- for(i=0; i < items_.size(); ++i)
+ for(i=0; i < items_.size(); ++i)
{
const format_item_t& item = items_[i];
res += item.res_;
- if( item.argN_ == format_item_t::argN_tabulation)
- {
+ if( item.argN_ == format_item_t::argN_tabulation)
+ {
BOOST_ASSERT( item.pad_scheme_ & format_item_t::tabulation);
std::streamsize n = item.state_.width_ - res.size();
if( n > 0 )
namespace io {
namespace detail {
-template<class Ch, class Tr, class T>
-basic_format<Ch, Tr>& bind_arg_body( basic_format<Ch, Tr>& self,
- int argN,
+template<class Ch, class Tr, class T>
+basic_format<Ch, Tr>& bind_arg_body( basic_format<Ch, Tr>& self,
+ int argN,
const T& val)
// bind one argument to a fixed value
// this is persistent over clear() calls, thus also over str() and <<
{
if(self.dumped_) self.clear(); // needed, because we will modify cur_arg_..
- if(argN<1 || argN > self.num_args_)
+ if(argN<1 || argN > self.num_args_)
{
if( self.exceptions() & io::out_of_range_bit )
boost::throw_exception(io::out_of_range()); // arg not in range.
else return self;
}
- if(self.bound_.size()==0)
+ if(self.bound_.size()==0)
self.bound_.assign(self.num_args_,false);
- else
+ else
BOOST_ASSERT( self.num_args_ == static_cast<signed int>(self.bound_.size()) );
int o_cur_arg = self.cur_arg_;
self.cur_arg_ = argN-1; // arrays begin at 0
self.bound_[self.cur_arg_]=false; // if already set, we unset and re-sets..
self.operator%(val); // put val at the right place, because cur_arg is set
-
+
// Now re-position cur_arg before leaving :
- self.cur_arg_ = o_cur_arg;
+ self.cur_arg_ = o_cur_arg;
self.bound_[argN-1]=true;
if(self.cur_arg_ == argN-1 )
// hum, now this arg is bound, so move to next free arg
return self;
}
-template<class Ch, class Tr, class T>
+template<class Ch, class Tr, class T>
basic_format<Ch, Tr>& modify_item_body( basic_format<Ch, Tr>& self,
- int itemN,
+ int itemN,
const T& manipulator)
// applies a manipulator to the format_item describing a given directive.
// this is a permanent change, clear or clear_binds won't cancel that.
{
- if(itemN<1 || itemN >= static_cast<signed int>(self.items_.size() ))
+ if(itemN<1 || itemN >= static_cast<signed int>(self.items_.size() ))
{
- if( self.exceptions() & io::out_of_range_bit )
+ if( self.exceptions() & io::out_of_range_bit )
boost::throw_exception(io::out_of_range()); // item not in range.
else return self;
}
namespace detail {
template<class Ch, class Stream> inline
- bool wrap_isdigit(Ch c, Stream &os)
+ bool wrap_isdigit(Ch c, Stream &os)
{
#ifndef BOOST_NO_LOCALE_ISIDIGIT
return std::isdigit(c, os.rdbuf()->getloc() );
# else
using namespace std;
- return isdigit(c);
-#endif
+ return isdigit(c);
+#endif
} //end- wrap_isdigit(..)
template<class Res, class Ch, class Tr> inline
- Res str2int(const std::basic_string<Ch, Tr>& s,
- typename std::basic_string<Ch, Tr>::size_type start,
+ Res str2int(const std::basic_string<Ch, Tr>& s,
+ typename std::basic_string<Ch, Tr>::size_type start,
BOOST_IO_STD basic_ios<Ch,Tr> &os,
- const Res = Res(0) )
+ const Res = Res(0) )
// Input : char string, with starting index
// a basic_ios& merely to call its widen/narrow member function in the desired locale.
// Effects : reads s[start:] and converts digits into an integral n, of type Res
}
template<class Ch, class Tr>
- void skip_asterisk(const std::basic_string<Ch,Tr> & buf,
+ void skip_asterisk(const std::basic_string<Ch,Tr> & buf,
typename std::basic_string<Ch,Tr>::size_type * pos_p,
BOOST_IO_STD basic_ios<Ch, Tr> &os)
// skip printf's "asterisk-fields" directives in the format-string buf
if(exceptions & io::bad_format_string_bit)
boost::throw_exception(io::bad_format_string());
}
-
+
template<class Ch, class Tr>
// Input : a 'printf-directive' in the format-string, starting at buf[ *pos_p ]
// a basic_ios& merely to call its widen/narrow member function in the desired locale.
// a bitset'excpetions' telling whether to throw exceptions on errors.
- // Returns : true if parse somehow succeeded (possibly ignoring errors if exceptions disabled)
+ // Returns : true if parse somehow succeeded (possibly ignoring errors if exceptions disabled)
// false if it failed so bad that the directive should be printed verbatim
// Effects : - *pos_p is incremented so that buf[*pos_p] is the first char after the directive
// - *fpar is set with the parameters read in the directive
{
typedef format_item<Ch, Tr> format_item_t;
BOOST_ASSERT( pos_p != 0);
- typename std::basic_string<Ch, Tr>::size_type &i1 = *pos_p,
- i0;
+ typename std::basic_string<Ch, Tr>::size_type &i1 = *pos_p,
+ i0;
fpar->argN_ = format_item_t::argN_no_posit; // if no positional-directive
bool in_brackets=false;
}
// the flag '0' would be picked as a digit for argument order, but here it's a flag :
- if(buf[i1]==os.widen('0'))
+ if(buf[i1]==os.widen('0'))
goto parse_flags;
// handle argument order (%2$d) or possibly width specification: %2d
i0 = i1; // save position before digits
while (i1 < buf.size() && wrap_isdigit(buf[i1], os))
++i1;
- if (i1!=i0)
+ if (i1!=i0)
{
if( i1 >= buf.size() ) {
maybe_throw_exception(exceptions);
return false;
}
int n=str2int(buf,i0, os, int(0) );
-
+
// %N% case : this is already the end of the directive
- if( buf[i1] == os.widen('%') )
+ if( buf[i1] == os.widen('%') )
{
fpar->argN_ = n-1;
++i1;
- if( in_brackets)
- maybe_throw_exception(exceptions);
+ if( in_brackets)
+ maybe_throw_exception(exceptions);
// but don't return. maybe "%" was used in lieu of '$', so we go on.
else return true;
}
- if ( buf[i1]==os.widen('$') )
+ if ( buf[i1]==os.widen('$') )
{
fpar->argN_ = n-1;
++i1;
- }
- else
+ }
+ else
{
// non-positionnal directive
fpar->ref_state_.width_ = n;
goto parse_precision;
}
}
-
- parse_flags:
+
+ parse_flags:
// handle flags
while ( i1 <buf.size()) // as long as char is one of + - = # 0 l h or ' '
- {
+ {
// misc switches
- switch (os.narrow(buf[i1], 0))
+ switch (os.narrow(buf[i1], 0))
{
case '\'' : break; // no effect yet. (painful to implement)
case 'l':
fpar->ref_state_.flags_ |= std::ios_base::showpos;
break;
case '0':
- fpar->pad_scheme_ |= format_item_t::zeropad;
+ fpar->pad_scheme_ |= format_item_t::zeropad;
// need to know alignment before really setting flags,
// so just add 'zeropad' flag for now, it will be processed later.
break;
} // loop on flag.
if( i1>=buf.size()) {
maybe_throw_exception(exceptions);
- return true;
+ return true;
}
parse_width:
i0 = i1; // save position before digits
while (i1<buf.size() && wrap_isdigit(buf[i1], os))
i1++;
-
- if (i1!=i0)
+
+ if (i1!=i0)
{ fpar->ref_state_.width_ = str2int( buf,i0, os, std::streamsize(0) ); }
parse_precision:
- if( i1>=buf.size()) {
+ if( i1>=buf.size()) {
maybe_throw_exception(exceptions);
return true;
}
// handle precision spec
- if (buf[i1]==os.widen('.'))
+ if (buf[i1]==os.widen('.'))
{
++i1;
skip_asterisk(buf, &i1, os);
if(i1==i0)
fpar->ref_state_.precision_ = 0;
- else
+ else
fpar->ref_state_.precision_ = str2int(buf,i0, os, std::streamsize(0) );
}
-
+
// handle formatting-type flags :
- while( i1<buf.size() &&
+ while( i1<buf.size() &&
( buf[i1]==os.widen('l') || buf[i1]==os.widen('L') || buf[i1]==os.widen('h')) )
++i1;
if( i1>=buf.size()) {
maybe_throw_exception(exceptions);
return true;
}
-
- if( in_brackets && buf[i1]==os.widen('|') )
+
+ if( in_brackets && buf[i1]==os.widen('|') )
{
++i1;
return true;
}
- switch (os.narrow(buf[i1], 0) )
+ switch (os.narrow(buf[i1], 0) )
{
case 'X':
fpar->ref_state_.flags_ |= std::ios_base::uppercase;
fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
fpar->ref_state_.flags_ |= std::ios_base::hex;
break;
-
+
case 'o':
fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
fpar->ref_state_.flags_ |= std::ios_base::oct;
fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
fpar->ref_state_.flags_ |= std::ios_base::dec;
break;
-
+
case 'f':
fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
fpar->ref_state_.flags_ |= std::ios_base::fixed;
else
fpar->ref_state_.fill_ = buf[i1];
fpar->pad_scheme_ |= format_item_t::tabulation;
- fpar->argN_ = format_item_t::argN_tabulation;
+ fpar->argN_ = format_item_t::argN_tabulation;
break;
- case 't':
+ case 't':
fpar->ref_state_.fill_ = os.widen(' ');
fpar->pad_scheme_ |= format_item_t::tabulation;
- fpar->argN_ = format_item_t::argN_tabulation;
+ fpar->argN_ = format_item_t::argN_tabulation;
break;
case 'G':
fpar->ref_state_.flags_ |= std::ios_base::dec;
// CLEAR all floatield flags, so stream will CHOOSE
- fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
+ fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
break;
case 'C':
- case 'c':
+ case 'c':
fpar->truncate_ = 1;
break;
case 'S':
- case 's':
+ case 's':
fpar->truncate_ = fpar->ref_state_.precision_;
fpar->ref_state_.precision_ = -1;
break;
- case 'n' :
+ case 'n' :
fpar->argN_ = format_item_t::argN_ignored;
break;
- default:
+ default:
maybe_throw_exception(exceptions);
}
++i1;
if( in_brackets )
{
- if( i1<buf.size() && buf[i1]==os.widen('|') )
+ if( i1<buf.size() && buf[i1]==os.widen('|') )
{
++i1;
return true;
// format :: parse(..)
template<class Ch, class Traits>
-void basic_format<Ch, Traits> ::parse(const string_t & buf)
+void basic_format<Ch, Traits> ::parse(const string_t & buf)
// parse the format-string
{
using namespace std;
const Ch arg_mark = oss_.widen('%');
- bool ordered_args=true;
+ bool ordered_args=true;
int max_argN=-1;
typename string_t::size_type i1=0;
int num_items=0;
-
+
// A: find upper_bound on num_items and allocates arrays
- i1=0;
- while( (i1=buf.find(arg_mark,i1)) != string::npos )
+ i1=0;
+ while( (i1=buf.find(arg_mark,i1)) != string_t::npos )
{
if( i1+1 >= buf.size() ) {
if(exceptions() & io::bad_format_string_bit)
}
if(buf[i1+1] == buf[i1] ) { i1+=2; continue; } // escaped "%%" / "##"
++i1;
-
+
// in case of %N% directives, dont count it double (wastes allocations..) :
while(i1 < buf.size() && io::detail::wrap_isdigit(buf[i1],oss_)) ++i1;
if( i1 < buf.size() && buf[i1] == arg_mark ) ++ i1;
++num_items;
}
items_.assign( num_items, format_item_t() );
-
+
// B: Now the real parsing of the format string :
num_items=0;
i1 = 0;
typename string_t::size_type i0 = i1;
bool special_things=false;
int cur_it=0;
- while( (i1=buf.find(arg_mark,i1)) != string::npos )
+ while( (i1=buf.find(arg_mark,i1)) != string_t::npos )
{
string_t & piece = (cur_it==0) ? prefix_ : items_[cur_it-1].appendix_;
if( buf[i1+1] == buf[i1] ) // escaped mark, '%%'
{
- piece += buf.substr(i0, i1-i0) + buf[i1];
+ piece += buf.substr(i0, i1-i0) + buf[i1];
i1+=2; i0=i1;
- continue;
+ continue;
}
BOOST_ASSERT( static_cast<unsigned int>(cur_it) < items_.size() || cur_it==0);
if(i1!=i0) piece += buf.substr(i0, i1-i0);
++i1;
-
+
bool parse_ok;
parse_ok = io::detail::parse_printf_directive(buf, &i1, &items_[cur_it], oss_, exceptions());
if( ! parse_ok ) continue; // the directive will be printed verbatim
++cur_it;
} // loop on %'s
BOOST_ASSERT(cur_it == num_items);
-
+
// store the final piece of string
string_t & piece = (cur_it==0) ? prefix_ : items_[cur_it-1].appendix_;
piece += buf.substr(i0);
-
- if( !ordered_args)
+
+ if( !ordered_args)
{
if(max_argN >= 0 ) // dont mix positional with non-positionnal directives
{
// set things like it would have been with positional directives :
int non_ordered_items = 0;
for(int i=0; i< num_items; ++i)
- if(items_[i].argN_ == format_item_t::argN_no_posit)
+ if(items_[i].argN_ == format_item_t::argN_no_posit)
{
items_[i].argN_ = non_ordered_items;
++non_ordered_items;
}
max_argN = non_ordered_items-1;
}
-
+
// C: set some member data :
items_.resize(num_items);
* Copyright 1995-2002 the LyX Team
* Read the file COPYING
*
- * \author unknown
+ * \author Lars Gullik Bjønnes
* \author John Levon <moz@compsoc.man.ac.uk>
*/
extern BufferList bufferlist;
using lyx::pos_type;
+using namespace lyx::support;
using std::pair;
using std::endl;
* Copyright 2002 the LyX Team
* Read the file COPYING
*
+ * \author Lars Gullik Bjønnes
* \author various
*/
using std::min;
using lyx::pos_type;
+using namespace lyx::support;
using namespace bv_funcs;
extern BufferList bufferlist;
Buffer * b = bufferlist.newBuffer(s);
//attach to the error signal in the buffer
- b->parseError.connect(boost::bind(&BufferView::Pimpl::addError,
+ b->parseError.connect(boost::bind(&BufferView::Pimpl::addError,
this, _1));
bool loaded = ::loadLyXFile(b, s);
else
return false;
- }
+ }
buffer(b);
mark_set = bv_->text->selection.mark();
the_locking_inset = bv_->theLockingInset();
buffer_->resizeInsets(bv_);
- // I don't think the delete and new are necessary here we
+ // I don't think the delete and new are necessary here we
// just could call only init! (Jug 20020419)
delete bv_->text;
bv_->text = new LyXText(bv_);
b = bufferlist.newBuffer(fname);
::loadLyXFile(b, fname); // don't ask, just load it
}
- if (b != 0)
+ if (b != 0)
buffer(b);
}
#include "Bullet.h"
#include "support/LAssert.h"
+using namespace lyx::support;
+
/** The four LaTeX itemize environment default bullets
*/
extern
#ifdef ENABLE_ASSERTIONS
void Bullet::testInvariant() const {
- lyx::Assert(font >= MIN);
- lyx::Assert(font < FONTMAX);
- lyx::Assert(character >= MIN);
- lyx::Assert(character < CHARMAX);
- lyx::Assert(size >= MIN);
- lyx::Assert(size < SIZEMAX);
- lyx::Assert(user_text >= -1);
- lyx::Assert(user_text <= 1);
+ Assert(font >= MIN);
+ Assert(font < FONTMAX);
+ Assert(character >= MIN);
+ Assert(character < CHARMAX);
+ Assert(size >= MIN);
+ Assert(size < SIZEMAX);
+ Assert(user_text >= -1);
+ Assert(user_text <= 1);
// now some relational/operational tests
if (user_text == 1) {
- lyx::Assert(font == -1 && (character == -1 && size == -1));
+ Assert(font == -1 && (character == -1 && size == -1));
// Assert(!text.empty()); // this isn't necessarily an error
}
// else if (user_text == -1) {
+2003-07-01 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * introduce namespace lyx::support
2003-06-30 André Pönitz <poenitz@gmx.net>
#include <fstream>
+using namespace lyx::support;
+
using std::ifstream;
using std::getline;
token = split(token, warno, ':');
token = split(token, warning, ':');
- int const lineno = lyx::atoi(line);
+ int const lineno = atoi(line);
#if USE_BOOST_FORMAT
msg % warno;
using std::for_each;
using std::vector;
+using namespace lyx::support;
using lyx::pos_type;
using lyx::textclass_type;
ParagraphList::iterator endpit,
int start, int end, textclass_type tc)
{
- lyx::Assert(&*startpit);
- lyx::Assert(&*endpit);
- lyx::Assert(0 <= start && start <= startpit->size());
- lyx::Assert(0 <= end && end <= endpit->size());
- lyx::Assert(startpit != endpit || start <= end);
+ Assert(&*startpit);
+ Assert(&*endpit);
+ Assert(0 <= start && start <= startpit->size());
+ Assert(0 <= end && end <= endpit->size());
+ Assert(startpit != endpit || start <= end);
ParagraphList paragraphs;
if (!checkPastePossible())
return make_pair(PitPosPair(pit, pos), pit);
- lyx::Assert (pos <= pit->size());
+ Assert (pos <= pit->size());
// Make a copy of the CaP paragraphs.
ParagraphList simple_cut_clone = cuts[cut_index].first;
ParagraphList & pars,
ErrorList & errorlist)
{
- lyx::Assert(!pars.empty());
+ Assert(!pars.empty());
int ret = 0;
if (c1 == c2)
using std::time;
#endif
+using namespace lyx::support;
+
using std::make_pair;
using std::ofstream;
using std::ifstream;
di.crc_prev = 0;
if (upd) {
lyxerr[Debug::DEPEND] << " CRC..." << flush;
- di.crc_cur = lyx::sum(f);
+ di.crc_cur = sum(f);
lyxerr[Debug::DEPEND] << "done." << endl;
struct stat f_info;
stat(fi.c_str(), &f_info);
} else {
di.crc_prev = di.crc_cur;
lyxerr[Debug::DEPEND] << itr->first << " CRC... ";
- di.crc_cur = lyx::sum(itr->first);
+ di.crc_cur = sum(itr->first);
lyxerr[Debug::DEPEND] << "done";
}
} else {
#include <map>
+using namespace lyx::support;
+
using std::endl;
return;
}
lyxerr << "LyX internal error: color and such.\n";
- lyx::Assert(false);
+ Assert(false);
}
#define __STRING__
#endif
#include "support/lyxstring.h"
-// using lyx::string;
-typedef lyxstring string;
+using lyx::string;
#define STRCONV(STR) STR.c_str()
#endif
#include <fstream>
#include <cstdio> // sscanf
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::sscanf;
#endif
// What files do we have to delete?
// This will at least make latex do all the runs
- lyx::unlink(depfile);
+ unlink(depfile);
// but the reason for the error might be in a generated file...
// bibtex file
string const bbl = ChangeExtension(ofname, ".bbl");
- lyx::unlink(bbl);
+ unlink(bbl);
// makeindex file
string const ind = ChangeExtension(ofname, ".ind");
- lyx::unlink(ind);
+ unlink(ind);
// Also remove the aux file
string const aux = ChangeExtension(ofname, ".aux");
- lyx::unlink(aux);
+ unlink(aux);
}
bool rerun = false; // rerun requested
// The class LaTeX does not know the temp path.
- bufferlist.updateIncludedTeXfiles(lyx::getcwd(), runparams);
+ bufferlist.updateIncludedTeXfiles(getcwd(), runparams);
// Never write the depfile if an error was encountered.
#include "support/filetools.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
using lyx::textclass_type;
using std::endl;
#include "gettext.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
using std::pair;
extern BufferList bufferlist;
extern boost::scoped_ptr<kb_keymap> toplevel_keymap;
+using namespace lyx::support;
+
using std::endl;
using std::vector;
using std::max;
{
vector<string> const selL =
CutAndPaste::availableSelections(*view->buffer());
-
+
vector<string>::const_iterator cit = selL.begin();
vector<string>::const_iterator end = selL.end();
-
+
for (unsigned int index = 0; cit != end; ++cit, ++index) {
int const action = lyxaction.getPseudoAction(LFUN_PASTE,
tostr(index));
lyx::compare_memfun(&Menu::name, name));
if (cit == end())
lyxerr << "No submenu named " << name << endl;
- lyx::Assert(cit != end());
+ Assert(cit != end());
return (*cit);
}
MenuList::iterator it =
find_if(menulist_.begin(), menulist_.end(),
lyx::compare_memfun(&Menu::name, name));
- lyx::Assert(it != menulist_.end());
+ Assert(it != menulist_.end());
return (*it);
}
#include <iostream>
+using namespace lyx::support;
+
using std::ostream;
// Initialize static member var.
#ifdef ENABLE_ASSERTIONS
switch (target) {
case PRINTER:
- //Assert(!printer_name.empty());
+ //lyx::support::Assert(!printer_name.empty());
break;
case FILE:
- lyx::Assert(!file_name.empty());
+ lyx::support::Assert(!file_name.empty());
break;
default:
- lyx::Assert(false);
+ lyx::support::Assert(false);
break;
}
#endif
#include <vector>
+using namespace lyx::support;
+
using std::endl;
using std::vector;
using std::make_pair;
<< fullname << '\'' << endl;
return fullname;
}
-
- lyxerr[Debug::GUI] << "Cannot find icon for command \""
- << lyxaction.getActionName(f.action)
+
+ lyxerr[Debug::GUI] << "Cannot find icon for command \""
+ << lyxaction.getActionName(f.action)
<< ' ' << f.argument << '"' << endl;
return LibFileSearch("images", "unknown", "xpm");
}
#include "support/LIstream.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
bool operator==(Author const & l, Author const & r)
{
return l.name() == r.name() && l.email() == r.email();
void AuthorList::record(int id, Author const & a)
{
- lyx::Assert(unsigned(id) < authors_.size());
+ Assert(unsigned(id) < authors_.size());
authors_[id] = a;
}
Author const & AuthorList::get(int id)
{
Authors::const_iterator it(authors_.find(id));
- lyx::Assert(it != authors_.end());
+ Assert(it != authors_.end());
return it->second;
}
#include <exception>
+using namespace lyx::support;
+
using std::endl;
namespace boost {
{
lyxerr << "Exception caught:\n"
<< e.what() << endl;
- lyx::Assert(false);
+ Assert(false);
}
#include <locale>
#endif
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::pow;
#endif
// This code is reached if lyx2lyx failed (for
// some reason) to change the file format of
// the file.
- lyx::Assert(false);
+ Assert(false);
return false;
}
}
} else {
// Saving failed, so backup is not backup
if (lyxrc.make_backup) {
- lyx::rename(s, fileName());
+ rename(s, fileName());
}
return false;
}
sgmlparam = style->latexparam();
c_params = split(sgmlparam, c_depth,'|');
- cmd_depth = lyx::atoi(c_depth);
+ cmd_depth = atoi(c_depth);
if (command_flag) {
if (cmd_depth < command_base) {
extern BufferList bufferlist;
+using namespace lyx::support;
+
namespace {
b->markDirty();
} else {
// Here, we should delete the autosave
- lyx::unlink(a);
+ unlink(a);
}
}
}
b->lyxvc.file_found_hook(s);
return true;
}
- break;
- case -1:
+ break;
+ case -1:
string const file = MakeDisplayPath(s, 20);
// Here we probably should run
if (LyXVC::file_not_found_hook(s)) {
}
-Buffer * newFile(string const & filename, string const & templatename,
+Buffer * newFile(string const & filename, string const & templatename,
bool isNamed)
{
// get a free buffer
}
-void parseErrors(Buffer const & buf, TeXErrors const & terr)
+void parseErrors(Buffer const & buf, TeXErrors const & terr)
{
TeXErrors::Errors::const_iterator cit = terr.begin();
TeXErrors::Errors::const_iterator end = terr.end();
}
-void parseErrors(Buffer const & buf, ErrorList const & el)
+void parseErrors(Buffer const & buf, ErrorList const & el)
{
ErrorList::const_iterator it = el.begin();
ErrorList::const_iterator end = el.end();
- for (; it != end; ++it)
+ for (; it != end; ++it)
buf.parseError(*it);
}
#include <functional>
+using namespace lyx::support;
+
using std::vector;
using std::find;
using std::endl;
void BufferList::release(Buffer * buf)
{
- lyx::Assert(buf);
+ Assert(buf);
BufferStorage::iterator it = find(bstore.begin(), bstore.end(), buf);
if (it != bstore.end()) {
// Make sure that we don't store a LyXText in
bool BufferList::close(Buffer * buf, bool ask)
{
- lyx::Assert(buf);
+ Assert(buf);
// FIXME: is the quitting check still necessary ?
if (!ask || buf->isClean() || quitting || buf->paragraphs.empty()) {
bool BufferList::isLoaded(Buffer const * b) const
{
- lyx::Assert(b);
+ Assert(b);
BufferStorage::const_iterator cit =
find(bstore.begin(), bstore.end(), b);
#include <cstdlib>
#include <algorithm>
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
using std::pair;
#include "insets/updatableinset.h"
+using namespace lyx::support;
+
namespace {
#include "support/LAssert.h"
#include "support/LOstream.h"
+using namespace lyx::support;
+
using std::vector;
using std::endl;
using lyx::pos_type;
}
check();
- lyx::Assert(0);
+ Assert(false);
return Change(Change::UNCHANGED);
}
}
check();
- lyx::Assert(0);
+ Assert(0);
return Change::UNCHANGED;
}
if (lyxerr.debugging(Debug::CHANGES))
lyxerr[Debug::CHANGES] << "End" << endl;
- lyx::Assert(dont_assert);
+ Assert(dont_assert);
}
#include <fstream>
+using namespace lyx::support;
+
using std::ifstream;
using std::getline;
using std::pair;
cmatch sub;
#endif
if (regex_match(STRCONV(line), sub, reg)) {
- int const n = lyx::atoi(STRCONV(sub.str(1)));
+ int const n = atoi(STRCONV(sub.str(1)));
string const str = STRCONV(sub.str(2));
if (lyxerr.debugging(Debug::KBMAP))
lyxerr << "Chardef: " << n
#include <cctype>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::isdigit;
#endif
res = one.startscript(type, command);
if (!real_outfile.empty()) {
- if (!lyx::rename(outfile, real_outfile))
+ if (!rename(outfile, real_outfile))
res = -1;
else
lyxerr[Debug::FILES]
token_base, from_base);
string to = subst(conv.result_dir,
token_base, to_base);
- if (!lyx::rename(from, to)) {
+ if (!rename(from, to)) {
Alert::error(_("Cannot convert file"),
bformat(_("Could not move a temporary file from %1$s to %2$s."),
from, to));
lyxerr[Debug::FILES] << "moving " << from2
<< " to " << to2 << endl;
bool const moved = (copy)
- ? lyx::copy(from2, to2)
- : lyx::rename(from2, to2);
+ ? lyx::support::copy(from2, to2)
+ : rename(from2, to2);
if (!moved && no_errors) {
Alert::error(_("Cannot convert file"),
bformat(_("Could not move a temporary file from %1$s to %2$s."),
#include "support/lstrings.h"
#include "support/LAssert.h"
+using namespace lyx::support;
+
using std::endl;
using std::vector;
void Counters::reset(string const & match)
{
- lyx::Assert(!match.empty());
+ Assert(!match.empty());
CounterList::iterator it = counterList.begin();
CounterList::iterator end = counterList.end();
#include <iomanip>
+using namespace lyx::support;
+
using std::ostream;
using std::setw;
using std::endl;
#include <algorithm>
+using namespace lyx::support;
+
using std::vector;
using std::find;
}
return result;
}
-
#include <cstdio>
+using namespace lyx::support;
+
using std::endl;
Inset * createInset(FuncRequest const & cmd)
#include "support/systemcall.h"
#include "support/lyxfunctional.h"
+using namespace lyx::support;
+
namespace {
#include <config.h>
-
#include "LyXView.h"
#include "debug.h"
#include "intl.h"
#include <sys/time.h>
#include <unistd.h>
+using namespace lyx::support;
using std::endl;
string current_layout;
#include "Timeout.h"
#include "support/LAssert.h"
+using namespace lyx::support;
+
Timeout::~Timeout()
{
Timeout & Timeout::setTimeout(unsigned int msec)
{
// Can't have a timeout of zero!
- lyx::Assert(msec);
+ Assert(msec);
timeout_ms = msec;
return * this;
#include "support/LAssert.h"
#include "debug.h"
+using namespace lyx::support;
BCView & ButtonController::view() const
{
- lyx::Assert(view_.get());
+ Assert(view_.get());
return *view_.get();
}
ButtonPolicy & ButtonController::bp() const
{
- lyx::Assert(bp_.get());
+ Assert(bp_.get());
return *bp_.get();
}
+2003-07-01 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * introduce namespace lyx::support
+
2003-06-28 Lars Gullik Bjønnes <larsbj@gullik.net>
* Kernel.h: fix some \class issues
#include <fstream>
+using namespace lyx::support;
+
using std::ostream;
// needed for the browser
#include "support/filetools.h"
+using namespace lyx::support;
+
using std::pair;
using std::vector;
#include "lyxrc.h"
#include "support/LAssert.h"
+using namespace lyx::support;
ControlButtons::ControlButtons()
: emergency_exit_(false), is_closing_(false),
ButtonController & ControlButtons::bc()
{
- lyx::Assert(bc_ptr_.get());
+ Assert(bc_ptr_.get());
return *bc_ptr_.get();
}
ViewBase & ControlButtons::view()
{
- lyx::Assert(view_ptr_);
+ Assert(view_ptr_);
return *view_ptr_;
}
#include "author.h"
#include "support/lstrings.h"
+using namespace lyx::support;
ControlChanges::ControlChanges(Dialog & parent)
: Dialog::Controller(parent)
#include "support/lyxalgo.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
using std::vector;
using std::back_inserter;
using std::transform;
#include "support/lstrings.h"
#include "support/filetools.h"
+using namespace lyx::support;
+
using std::endl;
BufferParams & ControlDocument::params()
{
- lyx::Assert(bp_.get());
+ Assert(bp_.get());
return *bp_;
}
#include "support/LAssert.h"
#include <vector>
+using namespace lyx::support;
using std::vector;
void ControlExternal::setParams(InsetExternal::Params const & p)
{
- lyx::Assert(params_.get());
+ Assert(params_.get());
*params_ = p;
}
InsetExternal::Params const & ControlExternal::params() const
{
- lyx::Assert(params_.get());
+ Assert(params_.get());
return *params_;
}
void ControlExternal::editExternal()
{
- lyx::Assert(params_.get());
+ Assert(params_.get());
dialog().view().apply();
string const lfun = InsetExternalMailer::params2string(params());
return 0;
return &templ;
}
-
+
} // namespace anon
#include <boost/bind.hpp>
+using namespace lyx::support;
+
using std::vector;
#include "support/filetools.h"
#include "support/FileInfo.h"
+using namespace lyx::support;
+
using std::pair;
using std::make_pair;
using std::vector;
#include <utility>
+using namespace lyx::support;
+
using std::pair;
#include "support/lstrings.h"
#include "support/filetools.h"
+using namespace lyx::support;
ControlMath::ControlMath(Dialog & dialog)
: Dialog::Controller(dialog)
#include "support/LAssert.h"
#include "Lsstream.h"
+using namespace lyx::support;
ControlParagraph::ControlParagraph(Dialog & parent)
: Dialog::Controller(parent), ininset_(false)
ParagraphParameters & ControlParagraph::params()
{
- lyx::Assert(params_.get());
+ Assert(params_.get());
return *params_;
}
ParagraphParameters const & ControlParagraph::params() const
{
- lyx::Assert(params_.get());
+ Assert(params_.get());
return *params_;
}
extern string user_lyxdir;
extern BufferList bufferlist;
+using namespace lyx::support;
+
using std::endl;
using std::pair;
#include "support/path.h"
#include "support/systemcall.h"
-#include "debug.h" // for lyxerr
+#include "debug.h"
+
+using namespace lyx::support;
using std::endl;
PrinterParams & ControlPrint::params() const
{
- lyx::Assert(params_);
+ Assert(params_);
return *params_;
}
#include "support/filetools.h" // MakeAbsPath, MakeDisplayPath
+using namespace lyx::support;
+
using std::vector;
extern BufferList bufferlist;
#include "support/lstrings.h"
#include "support/systemcall.h"
+using namespace lyx::support;
+
using std::vector;
#include "ControlShowFile.h"
#include "support/filetools.h"
+using namespace lyx::support;
+
ControlShowFile::ControlShowFile(Dialog & parent)
: Dialog::Controller(parent)
#include "frontends/Alert.h"
+using namespace lyx::support;
+
using std::endl;
speller_->accept(word_);
check();
}
-
-
#include "insets/insettabular.h"
#include "support/LAssert.h"
+using namespace lyx::support;
+
ControlTabular::ControlTabular(Dialog & parent)
: Dialog::Controller(parent), active_cell_(-1)
LyXTabular const & ControlTabular::tabular() const
{
- lyx::Assert(params_.get());
+ Assert(params_.get());
return *params_.get();
}
#include "support/lyxlib.h"
#include <fstream>
+using namespace lyx::support;
+
using std::endl;
using std::ostream;
if (!found)
ss << _("No version control log file found.") << endl;
- lyx::unlink(name);
+ unlink(name);
}
#include "debug.h"
#include "support/LAssert.h"
+using namespace lyx::support;
Dialog::Dialog(LyXView & lv, string const & name)
: is_closing_(false), kernel_(lv), name_(name),
if (controller().disconnectOnApply() && !is_closing_) {
kernel().disconnect(name());
- controller().initialiseParams(string());
+ controller().initialiseParams(string());
view().update();
}
}
ButtonController & Dialog::bc() const
{
- lyx::Assert(bc_ptr_.get());
+ Assert(bc_ptr_.get());
return *bc_ptr_.get();
}
Dialog::Controller & Dialog::controller() const
{
- lyx::Assert(controller_ptr_.get());
+ Assert(controller_ptr_.get());
return *controller_ptr_.get();
}
Dialog::View & Dialog::view() const
{
- lyx::Assert(view_ptr_.get());
+ Assert(view_ptr_.get());
return *view_ptr_.get();
}
void Dialog::setController(Controller * i)
{
- lyx::Assert(i && !controller_ptr_.get());
+ Assert(i && !controller_ptr_.get());
controller_ptr_.reset(i);
}
void Dialog::setView(View * v)
{
- lyx::Assert(v && !view_ptr_.get());
+ Assert(v && !view_ptr_.get());
view_ptr_.reset(v);
}
#include "ControlButtons.h"
#include "support/LAssert.h"
+using namespace lyx::support;
ViewBase::ViewBase(string const & t)
: controller_ptr_(0), title_(t)
ControlButtons & ViewBase::getController()
{
- lyx::Assert(controller_ptr_);
+ Assert(controller_ptr_);
return *controller_ptr_;
}
ControlButtons const & ViewBase::getController() const
{
- lyx::Assert(controller_ptr_);
+ Assert(controller_ptr_);
return *controller_ptr_;
}
#include <algorithm>
+using namespace lyx::support;
+
using std::vector;
string const getAbbreviatedAuthor(InfoMap const & map, string const & key)
{
- lyx::Assert(!map.empty());
+ Assert(!map.empty());
InfoMap::const_iterator it = map.find(key);
if (it == map.end())
string const getYear(InfoMap const & map, string const & key)
{
- lyx::Assert(!map.empty());
+ Assert(!map.empty());
InfoMap::const_iterator it = map.find(key);
if (it == map.end())
string const getInfo(InfoMap const & map, string const & key)
{
- lyx::Assert(!map.empty());
+ Assert(!map.empty());
InfoMap::const_iterator it = map.find(key);
if (it == map.end())
#include "gettext.h" // _()
#include "frontends/Alert.h"
+using namespace lyx::support;
+
using std::pair;
using std::vector;
using std::make_pair;
#include <fstream>
#include <algorithm>
+using namespace lyx::support;
+
using std::vector;
using std::endl;
using std::sort;
std::vector<string>::iterator it = list.begin();
std::vector<string>::iterator end = list.end();
for (; it != end; ++it) {
- *it = STRCONV(regex.Merge(it->c_str(), "/"));
+ *it = STRCONV(regex.Merge(STRCONV((*it)), "/"));
}
lyx::eliminate_duplicates(list);
#include <qpushbutton.h>
#include <qcombobox.h>
+using namespace lyx::support;
+
BulletsModule::BulletsModule(QWidget * parent, const char * name, WFlags fl)
: BulletsModuleBase(parent, name, fl), tmpbulletset(0)
{
case 1: pb = bullet2PB; co = bulletsize2CO; break;
case 2: pb = bullet3PB; co = bulletsize3CO; break;
case 3: pb = bullet4PB; co = bulletsize4CO; break;
- default: lyx::Assert(false); break;
+ default: Assert(false); break;
}
setBullet(pb, co, bullet);
+2003-07-01 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * introduce namespace lyx::support
+
2003-06-28 Lars Gullik Bjønnes <larsbj@gullik.net>
* QLPopupMenu.C: fix \file
#include <qfiledialog.h>
#include <qtoolbutton.h>
+using namespace lyx::support;
namespace {
#include "Qt2BC.h"
#include "QAbout.h"
+using namespace lyx::support;
+
using std::getline;
typedef QController<ControlAboutlyx, QView<QAboutDialog> > base_class;
#include "QBibtex.h"
#include "Qt2BC.h"
+using namespace lyx::support;
+
using std::vector;
typedef QController<ControlBibtex, QView<QBibtexDialog> > base_class;
#include <vector>
+using namespace lyx::support;
QBibtexDialog::QBibtexDialog(QBibtex * form)
: QBibtexDialogBase(0, 0, false, 0),
#include "support/lstrings.h"
#include "helper_funcs.h"
+using namespace lyx::support;
using std::find;
using std::max;
#include "LString.h"
+using namespace lyx::support;
+
using std::vector;
using std::endl;
#include <qslider.h>
#include "lengthcombo.h"
+using namespace lyx::support;
QDocumentDialog::QDocumentDialog(QDocument * form)
: QDocumentDialogBase(0, 0, false, 0), form_(form)
textLayoutModule->fontsizeCO->clear();
textLayoutModule->fontsizeCO->insertItem("default");
- for (int n=0; !token(items,'|',n).empty(); ++n)
+ for (int n = 0; !token(items,'|',n).empty(); ++n)
textLayoutModule->fontsizeCO->
insertItem(toqstr(token(items,'|',n)));
#include <vector>
+using namespace lyx::support;
+
typedef QController<ControlExternal, QView<QExternalDialog> > base_class;
#include "support/tostr.h"
#include "support/FileInfo.h"
#include "support/filetools.h"
+#include "support/lyxlib.h"
#include "insets/insetgraphicsParams.h"
#include "lyxrc.h"
#include "lengthcombo.h"
#include "QGraphics.h"
#include "Qt2BC.h"
+using namespace lyx::support;
+
using std::vector;
using std::endl;
for (int i = 0; i < num_units; i++)
dialog_->widthUnit->insertItem(unit_name_gui[i], -1);
- if (!lyx::float_equal(igp.scale, 0.0, 0.05)) {
+ if (!float_equal(igp.scale, 0.0, 0.05)) {
// there is a scale value > 0.05
dialog_->width->setText(toqstr(tostr(igp.scale)));
dialog_->widthUnit->setCurrentItem(0);
#include <boost/tuple/tuple.hpp>
+using namespace lyx::support;
+
using std::find_if;
using std::endl;
#include <boost/scoped_ptr.hpp>
+using namespace lyx::support;
+
using std::endl;
using std::pair;
using std::make_pair;
#include <qcombobox.h>
#include <qlineedit.h>
+using namespace lyx::support;
+
typedef QController<ControlMinipage, QView<QMinipageDialog> > base_class;
#include <functional>
+using namespace lyx::support;
+
using std::vector;
using std::bind2nd;
using std::remove_if;
#include <qfontinfo.h>
#include "qcoloritem.h"
+using namespace lyx::support;
+
using std::vector;
using std::pair;
using std::ostringstream;
// FIXME: dubious, but it's what xforms does
if (qcol != ci->color()) {
ostringstream ostr;
-
+
ostr << '#' << std::setbase(16) << setfill('0')
<< setw(2) << ci->color().red()
<< setw(2) << ci->color().green()
// Bleh, default fonts, and the names couldn't be found. Hack
// for bug 1063. Qt makes baby Jesus cry.
-
+
QFont font;
if (family == lyx_gui::roman_font_name()) {
} else if (rc.isp_command == "hspell") {
spellmod->spellCommandCO->setCurrentItem(2);
}
-
+
if (rc.use_spell_lib) {
#if defined(USE_ASPELL) || defined(USE_PSPELL)
spellmod->spellCommandCO->setCurrentItem(3);
#include <qpushbutton.h>
#include <qcheckbox.h>
+using namespace lyx::support;
+
using std::vector;
typedef QController<ControlTexinfo, QView<QTexinfoDialog> > base_class;
#include "support/BoostFormat.h"
+using namespace lyx::support;
+
typedef QController<ControlVCLog, QView<QVCLogDialog> > base_class;
void QVCLog::update_contents()
{
- setTitle(bformat(_("Version control log for %1$s"),
+ setTitle(bformat(_("Version control log for %1$s"),
controller().getBufferFileName()));
dialog_->vclogTV->setText("");
#include <qcombobox.h>
#include <qlineedit.h>
+using namespace lyx::support;
typedef QController<ControlWrap, QView<QWrapDialog> > base_class;
#include <qmenubar.h>
#include <qstatusbar.h>
+using namespace lyx::support;
+
using std::endl;
namespace {
#include <qlayout.h>
#include <qgroupbox.h>
+using namespace lyx::support;
+
// FIXME: set disabled doesn't work properly
FloatPlacement::FloatPlacement(QWidget * parent, char * name)
#include <fcntl.h>
#include <cstdlib>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::exit;
#endif
#include <qlayout.h>
#include <qlistview.h>
+using namespace lyx::support;
+
using std::map;
if (!parent.empty()) {
PanelMap::iterator it = panel_map_.find(parent);
- lyx::Assert(it != panel_map_.end());
+ Assert(it != panel_map_.end());
QListViewItem * before = it->second->firstChild();
if (before) {
void PanelStack::setCurrentPanel(string const & name)
{
PanelMap::const_iterator cit = panel_map_.find(name);
- lyx::Assert(cit != panel_map_.end());
+ Assert(cit != panel_map_.end());
// force on first set
if (list_->currentItem() == cit->second)
#include "support/filetools.h"
#endif
+using namespace lyx::support;
+
using std::endl;
using std::vector;
using std::pair;
#include <boost/bind.hpp>
#include <boost/signals/trackable.hpp>
+using namespace lyx::support;
+
using std::min;
using std::max;
using std::endl;
- row->baseline() - vheight;
} else {
// scroll down, the scroll region must be so big!!
- newtop = cursor.y() - vheight / 2;
+ newtop = cursor.y() - vheight / 2;
}
} else if (static_cast<int>((cursor.y()) - row->baseline()) <
+2003-07-01 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * introcude namespace lyx::support
2003-06-30 André Pönitz <poenitz@gmx.net>
#include <cmath>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::pow;
#endif
lyxerr << bformat(
_(" Using closest allocated color with (r,g,b)=%1$s instead.\n"
- "Pixel [%2$s] is used."),
+ "Pixel [%2$s] is used."),
tostr(cmap[closest_pixel]), tostr(closest_pixel)) << endl;
val.foreground = cmap[closest_pixel].pixel;
#include "support/lstrings.h"
#include <utility>
+using namespace lyx::support;
using std::make_pair;
using std::pair;
#include <cmath> // abs()
+using namespace lyx::support;
+
using std::endl;
using std::abs;
string name(list[i]);
lyxerr[Debug::FONT] << "match #" << i << ' '
<< name << endl;
- sizes[i] = lyx::atoi(token(name, '-', 7));
+ sizes[i] = atoi(token(name, '-', 7));
strings[i] = name;
if (sizes[i] == 0) {
if (scaleindex == -1) {
scaleindex = i;
}
scalable = true;
- } else if (lyx::atoi(token(name, '-', 12)) == 0)
+ } else if (atoi(token(name, '-', 12)) == 0)
// Ignore bogus matches of scalable fonts.
sizes[i] = 0;
};
#include "lyx_forms.h"
+using namespace lyx::support;
+
extern "C" {
#if FL_VERSION == 0 || (FL_REVISION == 0 && FL_FIXLEVEL == 0)
{
// build() is/should be called from the controller, so form() should
// always exist.
- lyx::Assert(form());
+ Assert(form());
// we use minw_ to flag whether the dialog has ever been shown.
// In turn, prepare_to_show() initialises various bits 'n' pieces
void FormBase::setPrehandler(FL_OBJECT * ob)
{
- lyx::Assert(ob);
+ Assert(ob);
fl_set_object_prehandler(ob, C_PrehandlerCB);
}
void FormBase::setMessageWidget(FL_OBJECT * ob)
{
- lyx::Assert(ob && ob->objclass == FL_TEXT);
+ Assert(ob && ob->objclass == FL_TEXT);
message_widget_ = ob;
fl_set_object_lsize(message_widget_, FL_NORMAL_SIZE);
}
// preemptive handler for feedback messages
void FormBase::MessageCB(FL_OBJECT * ob, int event)
{
- lyx::Assert(ob);
+ Assert(ob);
switch (event) {
case FL_ENTER:
void FormBase::PrehandlerCB(FL_OBJECT * ob, int event, int key)
{
- lyx::Assert(ob);
+ Assert(ob);
if (ob->objclass == FL_INPUT && event == FL_PUSH && key == 2) {
// Trigger an input event when pasting in an xforms input object
void FormBase::clearMessage()
{
- lyx::Assert(message_widget_);
+ Assert(message_widget_);
warning_posted_ = false;
void FormBase::postMessage(string const & message)
{
- lyx::Assert(message_widget_);
+ Assert(message_widget_);
int const width = message_widget_->w - 10;
-
string const tmp = warning_posted_ ?
bformat(_("WARNING! %1$s"), message) :
message;
FormBase * GetForm(FL_OBJECT * ob)
{
- lyx::Assert(ob && ob->form && ob->form->u_vdata);
+ Assert(ob && ob->form && ob->form->u_vdata);
FormBase * ptr = static_cast<FormBase *>(ob->form->u_vdata);
return ptr;
}
static int C_WMHideCB(FL_FORM * form, void *)
{
// Close the dialog cleanly, even if the WM is used to do so.
- lyx::Assert(form && form->u_vdata);
+ Assert(form && form->u_vdata);
FormBase * ptr = static_cast<FormBase *>(form->u_vdata);
ptr->getController().CancelButton();
return FL_CANCEL;
{
// Note that the return value is important in the pre-emptive handler.
// Don't return anything other than 0.
- lyx::Assert(ob);
+ Assert(ob);
// Don't Assert this one, as it can happen quite naturally when things
// are being deleted in the d-tor.
#include "gettext.h"
#include "support/lstrings.h" // compare
+using namespace lyx::support;
+
typedef FormController<ControlCommand, FormView<FD_bibitem> > base_class;
FormBibitem::FormBibitem(Dialog & parent)
#include "support/filetools.h"
#include "support/lyxalgo.h"
+using namespace lyx::support;
using std::vector;
using std::sort;
* Full author contact details are available in file CREDITS
*/
-#include <vector>
-
-
#include <config.h>
#include "xformsBC.h"
#include "support/lstrings.h"
+#include <vector>
+
+using namespace lyx::support;
+
using std::vector;
using std::find;
*/
#include <config.h>
-#include <algorithm>
-
#include "xformsBC.h"
#include "ControlCitation.h"
#include "support/LAssert.h"
#include "support/lstrings.h"
+#include <algorithm>
+
+using namespace lyx::support;
+
using std::find;
using std::max;
using std::min;
#include "lyx_forms.h"
+using namespace lyx::support;
+
extern "C" {
#if FL_VERSION == 0 || (FL_REVISION == 0 && FL_FIXLEVEL == 0)
void FormDialogView::setPrehandler(FL_OBJECT * ob)
{
- lyx::Assert(ob);
+ Assert(ob);
fl_set_object_prehandler(ob, C_PrehandlerCB);
}
void FormDialogView::setMessageWidget(FL_OBJECT * ob)
{
- lyx::Assert(ob && ob->objclass == FL_TEXT);
+ Assert(ob && ob->objclass == FL_TEXT);
message_widget_ = ob;
fl_set_object_lsize(message_widget_, FL_NORMAL_SIZE);
}
// preemptive handler for feedback messages
void FormDialogView::MessageCB(FL_OBJECT * ob, int event)
{
- lyx::Assert(ob);
+ Assert(ob);
switch (event) {
case FL_ENTER:
void FormDialogView::PrehandlerCB(FL_OBJECT * ob, int event, int key)
{
- lyx::Assert(ob);
+ Assert(ob);
if (ob->objclass == FL_INPUT && event == FL_PUSH && key == 2) {
// Trigger an input event when pasting in an xforms input
void FormDialogView::clearMessage()
{
- lyx::Assert(message_widget_);
+ Assert(message_widget_);
warning_posted_ = false;
#warning isnt this the same as in FormBase?
void FormDialogView::postMessage(string const & message)
{
- lyx::Assert(message_widget_);
+ Assert(message_widget_);
int const width = message_widget_->w - 10;
-
-
string const tmp = warning_posted_ ?
bformat(_("WARNING! %1$s"), message) :
message;
FormDialogView * GetForm(FL_OBJECT * ob)
{
- lyx::Assert(ob && ob->form && ob->form->u_vdata);
+ Assert(ob && ob->form && ob->form->u_vdata);
FormDialogView * ptr =
static_cast<FormDialogView *>(ob->form->u_vdata);
return ptr;
static int C_WMHideCB(FL_FORM * form, void *)
{
// Close the dialog cleanly, even if the WM is used to do so.
- lyx::Assert(form && form->u_vdata);
+ Assert(form && form->u_vdata);
FormDialogView * ptr = static_cast<FormDialogView *>(form->u_vdata);
ptr->dialog().CancelButton();
return FL_CANCEL;
{
// Note that the return value is important in the pre-emptive handler.
// Don't return anything other than 0.
- lyx::Assert(ob);
+ Assert(ob);
// Don't Assert this one, as it can happen quite naturally when things
// are being deleted in the d-tor.
#include <functional>
+using namespace lyx::support;
+
using std::bind2nd;
using std::vector;
#include "support/lstrings.h"
#include "lyx_forms.h"
+using namespace lyx::support;
+
typedef FormController<ControlExternal, FormView<FD_external> > base_class;
FormExternal::FormExternal(Dialog & parent)
#include "forms/form_filedialog.h"
#include "lyx_forms.h"
+using namespace lyx::support;
+
namespace {
// six months, in seconds
Alert::err_alert(_("Warning! Couldn't open directory."),
directory_);
#endif
- directory_ = lyx::getcwd();
+ directory_ = getcwd();
dir = ::opendir(directory_.c_str());
}
{
string tmp;
if (path.empty())
- tmp = lyx::getcwd();
+ tmp = getcwd();
else
tmp = MakeAbsPath(ExpandPath(path), directory_);
#include "support/lstrings.h"
#include "lyx_forms.h"
+using namespace lyx::support;
+
namespace {
enum {
#include "lyx_forms.h"
#include "support/tostr.h"
+using namespace lyx::support;
+
using std::vector;
using std::find;
using std::find_if;
#include "lyx_forms.h"
+using namespace lyx::support;
+
using std::endl;
using std::vector;
// first item in choice_width means scaling
if (fl_get_choice(file_->choice_width) == 1) {
igp.scale = strToDbl(getString(file_->input_width));
- if (lyx::float_equal(igp.scale, 0.0, 0.05)) {
+ if (float_equal(igp.scale, 0.0, 0.05)) {
igp.scale = 100.0;
}
igp.width = LyXLength();
}
// set width input fields according to scaling or width/height input
- if (!lyx::float_equal(igp.scale, 0.0, 0.05)) {
+ if (!float_equal(igp.scale, 0.0, 0.05)) {
fl_set_input_filter(file_->input_width, fl_unsigned_float_filter);
fl_set_input_maxchars(file_->input_width, 0);
fl_set_input(file_->input_width, tostr(igp.scale).c_str());
igp.height, defaultUnit);
// disable height input in case of scaling
- bool const disable_height = !lyx::float_equal(igp.scale, 0.0, 0.05);
+ bool const disable_height = !float_equal(igp.scale, 0.0, 0.05);
setEnabled(file_->input_height, !disable_height);
setEnabled(file_->choice_height, !disable_height);
*/
#include <config.h>
-#include <algorithm>
-
#include "debug.h"
#include "support/lstrings.h" // strip
#include "lyx_forms.h"
+#include <algorithm>
+
+using namespace lyx::support;
+
typedef FormController<ControlInclude, FormView<FD_include> > base_class;
FormInclude::FormInclude(Dialog & parent)
extern "C" void C_FormDialogView_CancelCB(FL_OBJECT *, long);
extern "C" void C_FormDialogView_InputCB(FL_OBJECT *, long);
+using namespace lyx::support;
+
using std::vector;
using std::max;
void FormMathsBitmap::build()
{
- lyx::Assert(bitmaps_.size() > 0);
+ Assert(bitmaps_.size() > 0);
h_+= 42; // Allow room for a Close button
#include <algorithm>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::strlen;
#endif
int C_FormMathsMatrixAlignFilter(FL_OBJECT * ob, char const *,
char const * cur, int c)
{
- lyx::Assert(ob);
+ Assert(ob);
FormMathsMatrix * pre =
static_cast<FormMathsMatrix *>(ob->u_vdata);
- lyx::Assert(pre);
+ Assert(pre);
return pre->AlignFilter(cur, c);
}
#include "xforms_helpers.h"
#include "lyx_forms.h"
+using namespace lyx::support;
+
typedef FormController<ControlMinipage, FormView<FD_minipage> > base_class;
FormMinipage::FormMinipage(Dialog & parent)
#include <functional>
+using namespace lyx::support;
+
using std::vector;
using std::bind2nd;
using std::remove_if;
void validateVSpaceWidgets(FL_OBJECT * choice_type, FL_OBJECT * input_length)
{
// Paranoia check!
- lyx::Assert(choice_type && choice_type->objclass == FL_CHOICE &&
+ Assert(choice_type && choice_type->objclass == FL_CHOICE &&
input_length && input_length->objclass == FL_INPUT);
if (fl_get_choice(choice_type) != 7)
FL_OBJECT * check_keep)
{
// Paranoia check!
- lyx::Assert(choice_type && choice_type->objclass == FL_CHOICE &&
+ Assert(choice_type && choice_type->objclass == FL_CHOICE &&
input_length && input_length->objclass == FL_INPUT &&
choice_length && choice_length->objclass == FL_CHOICE &&
check_keep && check_keep->objclass == FL_CHECKBUTTON);
FL_OBJECT * check_keep)
{
// Paranoia check!
- lyx::Assert(choice_type && choice_type->objclass == FL_CHOICE &&
+ Assert(choice_type && choice_type->objclass == FL_CHOICE &&
input_length && input_length->objclass == FL_INPUT &&
choice_length && choice_length->objclass == FL_CHOICE &&
check_keep && check_keep->objclass == FL_CHECKBUTTON);
extern string system_lyxdir;
extern string user_lyxdir;
+using namespace lyx::support;
+
namespace {
// These should probably go inside the class definition...
string const FormPreferences::getFeedback(FL_OBJECT * ob)
{
- lyx::Assert(ob);
+ Assert(ob);
if (ob->form->fdui == colors_.dialog())
return colors_.feedback(ob);
ButtonPolicy::SMInput FormPreferences::input(FL_OBJECT * ob, long)
{
- lyx::Assert(ob);
+ Assert(ob);
bool valid = true;
#include "lyx_forms.h"
#include "support/tostr.h"
+using namespace lyx::support;
typedef FormCB<ControlPrint, FormDB<FD_print> > base_class;
*/
#include <config.h>
-#include <algorithm>
-
#include "xformsBC.h"
#include "ControlRef.h"
#include "support/lstrings.h" // trim
#include "lyx_forms.h"
+#include <algorithm>
+
+using namespace lyx::support;
+
using std::find;
using std::max;
using std::sort;
#include <config.h>
-
#include "FormSendto.h"
#include "forms/form_sendto.h"
#include "ControlSendto.h"
#include "lyx_forms.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
using std::vector;
typedef FormCB<ControlSendto, FormDB<FD_sendto> > base_class;
#include <config.h>
-
-#include <vector>
-#include <algorithm>
-
#include "ControlTabular.h"
#include "xformsBC.h"
#include "ButtonController.h"
#include "lyx_forms.h"
+#include <vector>
+#include <algorithm>
+
+using namespace lyx::support;
+
using std::vector;
using std::bind2nd;
#include "lyx_forms.h"
+using namespace lyx::support;
+
typedef FormController<ControlTexinfo, FormView<FD_texinfo> > base_class;
FormTexinfo::FormTexinfo(Dialog & parent)
#include "lyx_forms.h"
+using namespace lyx::support;
+
typedef FormController<ControlCommand, FormView<FD_text> > base_class;
FormText::FormText(Dialog & parent, string const & title, string const & label)
#include <config.h>
-
#include "ControlThesaurus.h"
#include "FormThesaurus.h"
#include "forms/form_thesaurus.h"
#include "debug.h"
#include "support/lstrings.h"
#include "lyx_forms.h"
+
#include <cctype>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::isupper;
using std::islower;
#include <vector>
+using namespace lyx::support;
+
using std::vector;
using std::endl;
#include "lyx_forms.h"
#include "support/tostr.h"
+using namespace lyx::support;
typedef FormController<ControlWrap, FormView<FD_wrap> > base_class;
#include <algorithm>
+using namespace lyx::support;
+
using std::endl;
using std::vector;
using std::max;
}
// Paranoia check
- lyx::Assert(item->kind() == MenuItem::Submenu);
+ Assert(item->kind() == MenuItem::Submenu);
// set tabstop length
fl_set_tabstop(menu_tabstop);
#include <algorithm>
#include <iterator>
+using namespace lyx::support;
+
using std::find_if;
using std::endl;
{
// Object must be a ROUND3DBUTTON (let all radio buttons look the same)
// and of type RADIO_BUTTON (otherwise it ain't work).
- lyx::Assert(ob && ob->objclass == FL_ROUND3DBUTTON
+ Assert(ob && ob->objclass == FL_ROUND3DBUTTON
&& ob->type == FL_RADIO_BUTTON);
map.push_back(ButtonValuePair(ob, value));
#include <boost/bind.hpp>
+using namespace lyx::support;
+
bool Tooltips::enabled_ = true;
boost::signal0<void> Tooltips::toggled;
void Tooltips::init(FL_OBJECT * ob, string const & tip)
{
- lyx::Assert(ob && ob->form);
+ Assert(ob && ob->form);
// Store the tooltip string
string const str = formatted(trim(tip), 400);
#include <boost/bind.hpp>
#include <boost/signals/connection.hpp>
+
+using namespace lyx::support;
+
using std::abs;
using std::endl;
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
- * \author unknown
+ * \author Lars Gullik Bjønnes
* \author John Levon
*
* Full author contact details are available in file CREDITS
#include <config.h>
-
#include "XPainter.h"
#include "LString.h"
#include "debug.h"
#include <cmath>
+using namespace lyx::support;
+
using std::endl;
using std::max;
#include "lyx_forms.h"
+using namespace lyx::support;
void addCheckedLyXLength(BCView & bcview,
FL_OBJECT * input, FL_OBJECT * label)
CheckedLyXLength::CheckedLyXLength(FL_OBJECT * input, FL_OBJECT * label)
: input_(input), label_(label ? label : input)
{
- lyx::Assert(input && input->objclass == FL_INPUT);
+ Assert(input && input->objclass == FL_INPUT);
}
CheckedGlueLength::CheckedGlueLength(FL_OBJECT * input, FL_OBJECT * label)
: input_(input), label_(label ? label : input)
{
- lyx::Assert(input && input->objclass == FL_INPUT);
+ Assert(input && input->objclass == FL_INPUT);
}
#include "forms_gettext.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
// Extract shortcut from "<identifier>|<shortcut>" string
string const scex(string const & str)
{
#include "support/lstrings.h"
#include "input_validators.h"
+using namespace lyx::support;
+
#if defined(__cplusplus)
extern "C"
{
#include <fcntl.h>
#include <boost/bind.hpp>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::exit;
#endif
XGetErrorText(display, xeev->error_code, etxt, 512);
lyxerr << etxt << " id: " << xeev->resourceid << endl;
// By doing an abort we get a nice backtrace. (hopefully)
- lyx::abort();
+ lyx::support::abort();
return 0;
}
#include "lyx_forms.h"
+using namespace lyx::support;
+
using std::endl;
// The global fontloader
#include <boost/scoped_array.hpp>
+using namespace lyx::support;
+
namespace {
inline
#include "support/LAssert.h"
#include "support/lstrings.h"
#include "support/lyxfunctional.h" // compare_memfun
+#include "support/lyxlib.h"
#include "lyx_forms.h"
#include <boost/tuple/tuple.hpp>
+using namespace lyx::support;
+
using std::find_if;
namespace {
if (!image_)
return ;
- if (lyx::float_equal(params.angle, 0.0, 0.1))
+ if (float_equal(params.angle, 0.0, 0.1))
// No rotation is necessary.
return;
// Work around xforms bug when params.angle == 270
// the 'InternalError: bad special angle' error.
// This bug fix is not needed in xforms 1.0 and greater.
- if (lyx::float_equal(params.angle, 270.0, 0.1)) {
+ if (float_equal(params.angle, 270.0, 0.1)) {
flimage_rotate(image_, 900, FLIMAGE_SUBPIXEL);
flimage_rotate(image_, 1800, FLIMAGE_SUBPIXEL);
} else {
int status_report(FL_IMAGE * ob, const char *s)
{
- lyx::Assert(ob && ob->u_vdata);
+ Assert(ob && ob->u_vdata);
string const str = s ? rtrim(s) : string();
if (str.empty())
static void error_report(FL_IMAGE * ob, const char *s)
{
- lyx::Assert(ob && ob->u_vdata);
+ Assert(ob && ob->u_vdata);
string const str = s ? rtrim(s) : string();
if (str.empty())
#include <fstream>
+using namespace lyx::support;
+
using std::ofstream;
using std::pair;
using std::vector;
}
break;
default:
- lyx::Assert(0);
+ Assert(0);
}
return vec;
string const getString(FL_OBJECT * ob, int line)
{
// Negative line value does not make sense.
- lyx::Assert(line >= 0);
+ Assert(line >= 0);
char const * tmp = 0;
switch (ob->objclass) {
break;
default:
- lyx::Assert(0);
+ Assert(0);
}
return tmp ? trim(tmp) : string();
string getLengthFromWidgets(FL_OBJECT * input, FL_OBJECT * choice)
{
// Paranoia check
- lyx::Assert(input && input->objclass == FL_INPUT &&
+ Assert(input && input->objclass == FL_INPUT &&
choice && choice->objclass == FL_CHOICE);
string const length = trim(fl_get_input(input));
string const & default_unit)
{
// Paranoia check
- lyx::Assert(input && input->objclass == FL_INPUT &&
+ Assert(input && input->objclass == FL_INPUT &&
choice && choice->objclass == FL_CHOICE);
if (len.empty()) {
#include <algorithm> // std::max. Use FL_max in .c code...
#include "lyx_forms.h"
+using namespace lyx::support;
+
namespace {
/* This is hacked straight out of the xforms source.
double get_tabfolder_scale_to_fit(FL_OBJECT * folder)
{
- lyx::Assert(folder && folder->objclass == FL_TABFOLDER);
+ Assert(folder && folder->objclass == FL_TABFOLDER);
fl_freeze_form(folder->form);
int const saved_folder_id = fl_get_folder_number(folder);
void scale_tabfolder_horizontally(FL_OBJECT * folder, double factor)
{
- lyx::Assert(folder && folder->objclass == FL_TABFOLDER);
+ Assert(folder && folder->objclass == FL_TABFOLDER);
fl_freeze_form(folder->form);
int const saved_folder_id = fl_get_folder_number(folder);
double get_scale_to_fit(FL_FORM * form)
{
- lyx::Assert(form);
+ Assert(form);
double factor = get_scaling_factor(form);
for (FL_OBJECT * ob = form->first; ob; ob = ob->next) {
void scale_form_horizontally(FL_FORM * form, double factor)
{
- lyx::Assert(form);
+ Assert(form);
if (factor <= 1.0)
return;
+2003-07-01 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * introcude namespace lyx::support
+
2003-06-04 Angus Leeming <leeming@lyx.org>
* GraphicsLoader.C (Loader copy c-tor): make it work as expected. ;-)
2003-05-12 André Pönitz <poenitz@gmx.net>
- * PreviewLoader.C: boost::format -> bformat
+ * PreviewLoader.C: boost::format -> bformat
2003-04-15 Angus Leeming <leeming@lyx.org>
* GraphicsLoader.[Ch],
* PreviewImage.[Ch],
- * PreviewedInset.C: Removed unneeded list of owner insets
+ * PreviewedInset.C: Removed unneeded list of owner insets
2003-02-25 Alfredo Braunstein <abraunst@libero.it>
* GraphicsConverter (startConversion): add the call to
- ForkedCallQueue::add
+ ForkedCallQueue::add
* GraphicsLoader.[Ch],
* PreviewImage.[Ch],
- * PreviewedInset.C: Removed unneeded BufferView
-
+ * PreviewedInset.C: Removed unneeded BufferView
+
2003-02-25 Alfredo Braunstein <abraunst@libero.it>
* LoaderQueue.[Ch]: a simplification of the code, eliminated
* PreviewLoader.C (FindFirst): use ==, not < with std::find.
2003-02-21 Alfredo Braunstein <abraunst@libero.it>
-
+
* LoaderQueue.[Ch] (setPriority): added
-
- * PreviewLoader.C (finishedGenerating): reversed the loading order so
+
+ * PreviewLoader.C (finishedGenerating): reversed the loading order so
first images get 'touched' last, and so load first.
2003-02-20 Alfredo Braunstein <abraunst@libero.it>
2002-12-17 Lars Gullik Bjønnes <larsbj@gullik.net>
- * Makefile.am (EXTRA_DIST): remove variable
+ * Makefile.am (EXTRA_DIST): remove variable
2002-12-13 Angus Leeming <leeming@lyx.org>
#include <map>
+using namespace lyx::support;
+
namespace grfx {
/** The cache contains one item per file, so use a map to find the
#include "support/LAssert.h"
#include "support/filetools.h"
+#include "support/lyxlib.h"
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <boost/signals/trackable.hpp>
+using namespace lyx::support;
+
using std::endl;
namespace grfx {
{
zipped_ = false;
if (!unzipped_filename_.empty())
- lyx::unlink(unzipped_filename_);
+ unlink(unzipped_filename_);
unzipped_filename_.erase();
if (remove_loaded_file_ && !file_to_load_.empty())
- lyx::unlink(file_to_load_);
+ unlink(file_to_load_);
remove_loaded_file_ = false;
file_to_load_.erase();
setStatus(ErrorConverting);
if (zipped_)
- lyx::unlink(unzipped_filename_);
+ unlink(unzipped_filename_);
return;
}
// Clean up after loading.
if (zipped_)
- lyx::unlink(unzipped_filename_);
+ unlink(unzipped_filename_);
if (remove_loaded_file_ && unzipped_filename_ != file_to_load_)
- lyx::unlink(file_to_load_);
+ unlink(file_to_load_);
cl_.disconnect();
FormatList const formats = grfx::Image::loadableFormats();
// There must be a format to load from.
- lyx::Assert(!formats.empty());
+ Assert(!formats.empty());
// First ascertain if we can load directly with no conversion
FormatList::const_iterator it = formats.begin();
// Add some stuff to create a uniquely named temporary file.
// This file is deleted in loadImage after it is loaded into memory.
- string const to_file_base = lyx::tempName(string(), temp);
+ string const to_file_base = tempName(string(), temp);
remove_loaded_file_ = true;
// Remove the temp file, we only want the name...
- lyx::unlink(to_file_base);
+ unlink(to_file_base);
// Connect a signal to this->imageConverted and pass this signal to
// the graphics converter so that we can load the modified file
#include <fstream>
#include <sys/types.h> // needed for pid_t
+using namespace lyx::support;
+
using std::endl;
using std::ostream;
return;
}
- Forkedcall::SignalTypePtr
+ Forkedcall::SignalTypePtr
ptr = ForkedCallQueue::get().add(script_command_);
ptr->connect(boost::bind(&Impl::converted, this, _1, _2));
finished_ = true;
// Clean-up behind ourselves
- lyx::unlink(script_file_);
+ unlink(script_file_);
if (retval > 0) {
- lyx::unlink(to_file_);
+ unlink(to_file_);
to_file_.erase();
finishedConversion(false);
} else {
// Remember to remove the temp file because we only want the name...
static int counter = 0;
string const tmp = "gconvert" + tostr(counter++);
- string const to_base = lyx::tempName(string(), tmp);
- lyx::unlink(to_base);
+ string const to_base = tempName(string(), tmp);
+ unlink(to_base);
string outfile = from_file;
#ifndef GRAPHICSTYPES_H
#define GRAPHICSTYPES_H
+#include "LString.h"
#include "support/translator.h"
namespace grfx {
#include <boost/bind.hpp>
#include <boost/signals/trackable.hpp>
+using namespace lyx::support;
namespace grfx {
PreviewImage::Impl::~Impl()
{
- lyx::unlink(iloader_.filename());
+ unlink(iloader_.filename());
}
break;
case Ready:
- lyx::unlink(iloader_.filename());
+ unlink(iloader_.filename());
ploader_.emitSignal(parent_);
break;
}
#include <utility>
#include <vector>
+using namespace lyx::support;
+
using std::endl;
using std::find;
using std::fill;
ForkedcallsController::get().kill(pid, 0);
if (!metrics_file.empty())
- lyx::unlink(metrics_file);
+ unlink(metrics_file);
BitmapFile::const_iterator vit = snippets.begin();
BitmapFile::const_iterator vend = snippets.end();
for (; vit != vend; ++vit) {
if (!vit->second.empty())
- lyx::unlink(vit->second);
+ unlink(vit->second);
}
}
string directory = buffer_.tmppath;
if (directory.empty())
directory = buffer_.filePath();
-
+
string const filename_base(unique_filename(directory));
// Create an InProgress instance to place in the map of all
double const a = ascent + tp_ascent;
double const d = descent - tp_descent;
- if (!lyx::float_equal(a + d, 0, 0.1))
+ if (!float_equal(a + d, 0, 0.1))
*it = a / (a + d);
if (++it == end)
#include "debug.h" // temporary
+using namespace lyx::support;
+
namespace grfx {
bool PreviewedInset::activated()
#include <map>
+using namespace lyx::support;
+
namespace grfx {
bool Previews::activated()
PreviewLoader & Previews::loader(Buffer const * buffer) const
{
- lyx::Assert(buffer);
+ Assert(buffer);
Impl::CacheType::iterator it = pimpl_->cache.find(buffer);
#include <algorithm>
+using namespace lyx::support;
+
using std::vector;
using std::find;
+2003-07-01 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * introduce namespace lyx::support
2003-06-30 André Pönitz <poenitz@gmx.net>
- * insetcite.C (localDispatch): fix case of missing return value
+ * insetcite.C (localDispatch): fix case of missing return value
- * insetcite.C (ascii): remove unneeded temporary
+ * insetcite.C (ascii): remove unneeded temporary
2003-06-28 Lars Gullik Bjønnes <larsbj@gullik.net>
#include "support/LAssert.h"
#include "support/filetools.h"
+using namespace lyx::support;
+
using std::endl;
using std::ostream;
using std::for_each;
default:
lex.printError("ExternalTemplate::readTemplate: "
"Wrong tag: $$Token");
- lyx::Assert(false);
+ Assert(false);
break;
}
}
}
-LyXText * Inset::getLyXText(BufferView const * bv, bool const recursive) const
+LyXText * Inset::getLyXText(BufferView const * bv, bool /*recursive*/) const
{
if (owner())
return owner()->getLyXText(bv, false);
// inside them without cast!!!
///
virtual LyXText * getLyXText(BufferView const *,
- bool const recursive = false) const;
+ bool recursive = false) const;
///
virtual void deleteLyXText(BufferView *, bool = true) const {}
///
#include "support/tostr.h"
#include "support/lstrings.h"
+using namespace lyx::support;
using std::max;
#include <fstream>
#include <cstdlib>
+using namespace lyx::support;
+
using std::ostream;
using std::ifstream;
using std::getline;
void InsetBibtex::fillWithBibKeys(Buffer const * buffer,
std::vector<std::pair<string, string> > & keys) const
{
- lyx::Assert(buffer);
+ Assert(buffer);
vector<string> const files = getFiles(*buffer);
for (vector<string>::const_iterator it = files.begin();
it != files.end(); ++ it) {
#include "support/LAssert.h"
#include "support/BoostFormat.h"
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
else if (i2->lyxCode() == WRAP_CODE)
type = static_cast<InsetWrap *>(i2)->params().type;
else
- lyx::Assert(0);
+ Assert(0);
FloatList const & floats =
pi.base.bv->buffer()->params.getLyXTextClass().floats();
#include <map>
+using namespace lyx::support;
+
using std::ostream;
using std::vector;
using std::map;
#include "support/LAssert.h"
#include "support/LOstream.h"
+using namespace lyx::support;
+
using std::vector;
using std::ostream;
using std::endl;
void InsetCollapsable::draw(PainterInfo & pi, int x, int y, bool inlined) const
{
- lyx::Assert(pi.base.bv);
+ Assert(pi.base.bv);
cache(pi.base.bv);
if (nodraw())
#include "support/LAssert.h"
#include "support/tostr.h"
+using namespace lyx::support;
using std::ostream;
using std::min;
#include <cstdio>
#include <utility>
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
: display(defaultDisplayType),
lyxscale(defaultLyxScale)
{
- tempname = lyx::tempName(string(), "lyxext");
- lyx::unlink(tempname);
+ tempname = tempName(string(), "lyxext");
+ unlink(tempname);
// must have an extension for the converter code to work correctly.
tempname += ".tmp";
}
InsetExternal::Params::~Params()
{
- lyx::unlink(tempname);
+ unlink(tempname);
}
if (bv)
bv->updateInset(this);
}
-
+
InsetExternal::Params const & InsetExternal::params() const
{
switch (cmd.action) {
case LFUN_EXTERNAL_EDIT: {
- lyx::Assert(cmd.view());
+ Assert(cmd.view());
InsetExternal::Params p;
InsetExternalMailer::string2params(cmd.argument, p);
editExternal(p, cmd.view()->buffer());
return DISPATCHED_NOUPDATE;
}
-
+
case LFUN_INSET_MODIFY: {
- lyx::Assert(cmd.view());
+ Assert(cmd.view());
InsetExternal::Params p;
InsetExternalMailer::string2params(cmd.argument, p);
grfx::Params gparams;
if (!eparams.filename.empty()) {
- lyx::Assert(AbsolutePath(filepath));
+ Assert(AbsolutePath(filepath));
gparams.filename = MakeAbsPath(eparams.filename, filepath);
}
#include "frontends/LyXView.h"
#include "frontends/Dialogs.h"
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
#include "support/lstrings.h"
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
extern string system_tempdir;
// set by Exporters
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
if (bv)
bv->updateInset(this);
}
-
+
dispatch_result InsetGraphics::localDispatch(FuncRequest const & cmd)
{
options << " draft,\n";
if (params().clip)
options << " clip,\n";
- if (!lyx::float_equal(params().scale, 0.0, 0.05)) {
- if (!lyx::float_equal(params().scale, 100.0, 0.05))
+ if (!float_equal(params().scale, 0.0, 0.05)) {
+ if (!float_equal(params().scale, 100.0, 0.05))
options << " scale=" << params().scale / 100.0
<< ",\n";
} else {
// Make sure rotation angle is not very close to zero;
// a float can be effectively zero but not exactly zero.
- if (!lyx::float_equal(params().rotateAngle, 0, 0.001)) {
+ if (!float_equal(params().rotateAngle, 0, 0.001)) {
options << " angle=" << params().rotateAngle << ",\n";
if (!params().rotateOrigin.empty()) {
options << " origin=" << params().rotateOrigin[0];
temp_file = MakeAbsPath(OnlyFilename(temp_file), buf->tmppath);
lyxerr[Debug::GRAPHICS]
<< "\ttemp_file: " << temp_file << endl;
- if (graphic_->hasFileChanged() || !IsFileReadable(temp_file)) {
- bool const success = lyx::copy(orig_file, temp_file);
+ if (graphic_->hasFileChanged() || !IsFileReadable(temp_file)) {
+ bool const success = copy(orig_file, temp_file);
lyxerr[Debug::GRAPHICS]
<< "\tCopying zipped file from "
<< orig_file << " to " << temp_file
<< "\tthe orig file is: " << orig_file << endl;
if (lyxrc.use_tempdir) {
- temp_file = copyFileToDir(buf->tmppath, orig_file);
+ temp_file = copyFileToDir(buf->tmppath, orig_file);
if (temp_file.empty()) {
string str = bformat(_("Could not copy the file\n%1$s\n"
"into the temporary directory."),
orig_file);
Alert::error(_("Graphics display failed"), str);
return orig_file;
- }
+ }
if (from == to) {
// No conversion is needed. LaTeX can handle the
// Copy the new parameters.
params_ = p;
- // Update the display using the new parameters.
- graphic_->update(params().as_grfxParams());
+ // Update the display using the new parameters.
+ graphic_->update(params().as_grfxParams());
// We have changed data, report it.
return true;
#include "lyxlex.h"
#include "frontends/lyx_gui.h"
+using namespace lyx::support;
+
using std::ostream;
left.bb == right.bb &&
left.clip == right.clip &&
- lyx::float_equal(left.rotateAngle, right.rotateAngle, 0.001) &&
+ float_equal(left.rotateAngle, right.rotateAngle, 0.001) &&
left.rotateOrigin == right.rotateOrigin &&
left.subcaption == right.subcaption &&
left.subcaptionText == right.subcaptionText &&
os << "\tlyxscale " << lyxscale << '\n';
if (display != grfx::DefaultDisplay)
os << "\tdisplay " << grfx::displayTranslator.find(display) << '\n';
- if (!lyx::float_equal(scale, 0.0, 0.05)) {
- if (!lyx::float_equal(scale, 100.0, 0.05))
+ if (!float_equal(scale, 0.0, 0.05)) {
+ if (!float_equal(scale, 100.0, 0.05))
os << "\tscale " << scale << '\n';
} else {
if (!width.zero())
#include <cstdlib>
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
using std::vector;
#include "support/LOstream.h"
#include "support/lstrings.h" //frontStrip, strip
+using namespace lyx::support;
+
using std::ostream;
using std::vector;
using std::pair;
#include "lyxlex.h"
#include "metricsinfo.h"
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
#include "support/LAssert.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
{
// How do we get the local language here??
lyx::pos_type curr_pos = parOwner()->getPositionOfInset(this);
- lyx::Assert(curr_pos != -1);
+ Assert(curr_pos != -1);
#warning FIXME. We _must_ find another way to get the language. (Lgb)
#if 0
#include "BufferView.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
using std::ostream;
InsetRef::InsetRef(InsetCommandParams const & p, Buffer const & buf)
//#include <signal.h>
+using namespace lyx::support;
+
using std::vector;
using std::ostream;
using std::ifstream;
void InsetTabular::drawCellSelection(Painter & pain, int x, int y,
int row, int column, int cell) const
{
- lyx::Assert(hasSelection());
+ Assert(hasSelection());
int cs = tabular.column_of_cell(sel_cell_start);
int ce = tabular.column_of_cell(sel_cell_end);
if (cs > ce) {
WordLangTuple InsetTabular::selectNextWordInt(BufferView * bv, float & value) const
{
// when entering this function the inset should be ALWAYS locked!
- lyx::Assert(the_locking_inset);
+ Assert(the_locking_inset);
WordLangTuple word(the_locking_inset->selectNextWordToSpellcheck(bv, value));
if (!word.word().empty())
using std::pair;
using std::for_each;
+using namespace lyx::support;
+
using lyx::pos_type;
using lyx::textclass_type;
return;
t->selection.set(true);
- // at this point just to avoid the DEPM when setting the cursor
+ // at this point just to avoid the DEPM when setting the cursor
t->selection.mark(sstate.selection.mark());
if (sstate.selection.set()) {
t->setCursor(sstate.selection.start.par(),
if (recursive && the_locking_inset)
return the_locking_inset->getLyXText(lbv, true);
LyXText * lt = cached_text.get();
-
lyx::Assert(lt && lt->rows().begin()->par() == const_cast<ParagraphList&>(paragraphs).begin());
+ Assert(lt && lt->rows().begin()->par() == const_cast<ParagraphList&>(paragraphs).begin());
return lt;
}
// Super UGLY! (Lgb)
resizeLyXText(do_resize);
} else {
if (lt || !it->second.remove) {
- lyx::Assert(it->second.text.get());
+ Assert(it->second.text.get());
cached_text = it->second.text;
if (recursive && the_locking_inset) {
return the_locking_inset->getLyXText(bv, true);
return;
}
- lyx::Assert(it->second.text.get());
+ Assert(it->second.text.get());
it->second.remove = true;
if (recursive) {
return;
}
- lyx::Assert(it->second.text.get());
+ Assert(it->second.text.get());
LyXText * t = it->second.text.get();
saveLyXTextState(t);
do_reinit = false;
do_resize = 0;
for (Cache::iterator it = cache.begin(); it != cache.end(); ++it) {
- lyx::Assert(it->second.text.get());
+ Assert(it->second.text.get());
LyXText * t = it->second.text.get();
BufferView * bv = it->first;
#include "support/lstrings.h"
#include "gettext.h"
+using namespace lyx::support;
+
using std::ostream;
#include "support/LAssert.h"
#include "Lsstream.h"
+using namespace lyx::support;
void MailInset::showDialog(BufferView * bv) const
{
- lyx::Assert(bv);
+ Assert(bv);
bv->owner()->getDialogs().show(name(), inset2string(), &inset());
}
void MailInset::updateDialog(BufferView * bv) const
{
- lyx::Assert(bv);
+ Assert(bv);
if(bv->owner()->getDialogs().visible(name()))
bv->owner()->getDialogs().update(name(), inset2string());
}
#include "support/filetools.h"
+using namespace lyx::support;
+
RenderInset::RenderInset()
{}
void ButtonRenderer::metrics(MetricsInfo & mi, Dimension & dim) const
{
- lyx::Assert(mi.base.bv);
+ Assert(mi.base.bv);
LyXFont font(LyXFont::ALL_SANE);
font.decSize();
void ButtonRenderer::draw(PainterInfo & pi, int x, int y) const
{
- lyx::Assert(pi.base.bv);
+ Assert(pi.base.bv);
view_ = pi.base.bv->owner()->view();
// Draw it as a box with the LaTeX text
params_ = params;
if (!params_.filename.empty()) {
- lyx::Assert(AbsolutePath(params_.filename));
+ Assert(AbsolutePath(params_.filename));
loader_.reset(params_.filename, params_);
}
}
void GraphicRenderer::draw(PainterInfo & pi, int x, int y) const
{
- lyx::Assert(pi.base.bv);
+ Assert(pi.base.bv);
view_ = pi.base.bv->owner()->view();
#if 0
#include "lyxtext.h"
#include "support/lstrings.h"
+using namespace lyx::support;
// some stuff for inset locking
#endif
#include <sys/time.h>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::strcpy;
using std::strlen;
namespace {
-class LaunchIspell : public ForkedProcess {
+class LaunchIspell : public lyx::support::ForkedProcess {
public:
///
LaunchIspell(BufferParams const & p, string const & l,
int * in, int * out, int * err)
: params(p), lang(l), pipein(in), pipeout(out), pipeerr(err) {}
///
- virtual ForkedProcess * clone() const {
+ virtual lyx::support::ForkedProcess * clone() const {
return new LaunchIspell(*this);
}
///
#include <cstdio>
class BufferParams;
+namespace lyx {
+namespace support {
class ForkedProcess;
+}
+}
/// i/a spell process-based spellchecker
class ISpell : public SpellBase {
/// spell error
string error_;
- boost::scoped_ptr<ForkedProcess> child_;
+ boost::scoped_ptr<lyx::support::ForkedProcess> child_;
// vileness below ... please FIXME
/// str ???
#include <iterator>
+using namespace lyx::support;
+
using std::ifstream;
using std::ofstream;
using std::getline;
#include <utility>
#include <cerrno>
+using namespace lyx::support;
+
using std::vector;
using std::ifstream;
using std::copy;
// anyway.
bool failed = false;
- string const tmp_ret = lyx::tempName(string(), "lyxauto");
+ string const tmp_ret = tempName(string(), "lyxauto");
if (!tmp_ret.empty()) {
bv_.buffer()->writeFile(tmp_ret);
// assume successful write of tmp_ret
- if (!lyx::rename(tmp_ret, fname_)) {
+ if (!rename(tmp_ret, fname_)) {
failed = true;
// most likely couldn't move between filesystems
// unless write of tmp_ret failed
// so remove tmp file (if it exists)
- lyx::unlink(tmp_ret);
+ unlink(tmp_ret);
}
} else {
failed = true;
#include <csignal>
#include <iostream>
+using namespace lyx::support;
+
using std::vector;
using std::endl;
vector<string>::const_iterator end = files.end();
for (; it != end; ++it) {
- // get absolute path of file and add ".lyx" to
+ // get absolute path of file and add ".lyx" to
// the filename if necessary
string s = FileSearch(string(), *it, "lyx");
if (s.empty()) {
lyxerr << "Bye." << endl;
if (err_sig!= SIGHUP &&
(!GetEnv("LYXDEBUG").empty() || err_sig == SIGSEGV))
- lyx::abort();
+ lyx::support::abort();
exit(0);
}
void LyX::printError(ErrorItem const & ei)
{
- std::cerr << _("LyX: ") << ei.error
+ std::cerr << _("LyX: ") << ei.error
<< ':' << ei.description << std::endl;
}
system_lcolor = lcolor;
string prefsfile = "preferences";
- // back compatibility to lyxs < 1.1.6
+ // back compatibility to lyxs < 1.1.6
if (LibFileSearch(string(), prefsfile).empty())
prefsfile = "lyxrc";
if (!LibFileSearch(string(), prefsfile).empty())
#include "insets/insettext.h"
#include "changes.h"
+using namespace lyx::support;
+
using lyx::pos_type;
using std::endl;
#include "support/lstrings.h"
#include "bufferparams.h" // stateText
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
#include <utility>
#include <algorithm>
+using namespace lyx::support;
+
using std::pair;
using std::make_pair;
using std::endl;
disable = !mathcursor;
break;
- case LFUN_DIALOG_SHOW: {
+ case LFUN_DIALOG_SHOW: {
string const name = ev.getArg(0);
if (!buf) {
disable = !(name == "aboutlyx" ||
BufferView * LyXFunc::view() const
{
- lyx::Assert(owner);
+ Assert(owner);
return owner->view().get();
}
#include "support/lstrings.h"
+using namespace lyx::support;
+
using std::endl;
// The order of the LayoutTags enum is no more important. [asierra300396]
#include "support/filetools.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
using std::ostream;
using std::istream;
using std::endl;
#include <algorithm>
+using namespace lyx::support;
+
using std::sort;
using std::ostream;
using std::ios;
#include "support/lstrings.h"
#include "support/userinfo.h"
+using namespace lyx::support;
+
using std::ostream;
using std::ofstream;
using std::cout;
preview_hashed_labels = false;
preview_scale_factor = 0.9;
- user_name = lyx::user_name();
+ user_name = lyx::support::user_name();
- user_email = lyx::user_email();
+ user_email = lyx::support::user_email();
if (user_email.empty())
user_email = _("email address unknown");
#include "support/os2_errortable.h"
#endif
+
+using namespace lyx::support;
+
using std::endl;
// provide an empty mkfifo() if we do not have one. This disables the
if (fd < 0) {
lyxerr << "LyXComm: Could not open pipe " << filename << '\n'
<< strerror(errno) << endl;
- lyx::unlink(filename);
+ unlink(filename);
return -1;
}
// OS/2 pipes are deleted automatically
#ifndef __EMX__
- if (lyx::unlink(filename) < 0) {
+ if (unlink(filename) < 0) {
lyxerr << "LyXComm: Could not remove pipe " << filename
<< '\n' << strerror(errno) << endl;
};
#include <algorithm>
+using namespace lyx::support;
+
using std::endl;
using std::find_if;
using std::remove_if;
LyXLayout_ptr const & LyXTextClass::operator[](string const & name) const
{
- lyx::Assert(!name.empty());
+ Assert(!name.empty());
LayoutList::const_iterator cit =
find_if(layoutlist_.begin(),
lyxerr << " " << it->get()->name() << endl;
// we require the name to exist
- lyx::Assert(false);
+ Assert(false);
}
return (*cit);
#include <utility>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::exit;
#endif
#include <unistd.h>
+using namespace lyx::support;
+
using std::endl;
using std::pair;
if (!vcs)
return string();
- string tmpf = lyx::tempName(string(), "lyxvclog");
+ string tmpf = tempName(string(), "lyxvclog");
lyxerr[Debug::LYXVC] << "Generating logfile " << tmpf << endl;
vcs->getLog(tmpf);
return tmpf;
#include <ios>
#endif
+using namespace lyx::support;
+
int main(int argc, char * argv[])
{
#ifdef HAVE_IOS
+2003-07-01 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * introduce namespace lyx::support
+
2003-06-28 Lars Gullik Bjønnes <larsbj@gullik.net>
* math_symbolinset.C (MathSymbolInset): fix type const order
#include "metricsinfo.h"
#include "math_data.h"
#include "support/lstrings.h"
+#include "support/lyxlib.h"
#include "frontends/LyXView.h"
#include "frontends/font_metrics.h"
#include "frontends/mouse_state.h"
#include <fstream>
+using namespace lyx::support;
+
using std::endl;
using std::ostream;
using std::vector;
bv->lockedInsetStoreUndo(Undo::EDIT);
if (argument.size() == 1)
result = mathcursor->interpret(argument[0]) ? DISPATCHED : FINISHED_RIGHT;
- else
+ else
mathcursor->insert(argument);
}
break;
mathcursor->normalize();
mathcursor->touch();
- lyx::Assert(mathcursor);
+ Assert(mathcursor);
if (mathcursor->selection() || was_selection)
toggleInsetSelection(bv);
else {
string s = cmd.argument;
string const s1 = token(s, ' ', 1);
- int const na = s1.empty() ? 0 : lyx::atoi(s1);
+ int const na = s1.empty() ? 0 : atoi(s1);
openNewInset(bv, new InsetFormulaMacro(token(s, ' ', 0), na));
}
break;
#include "lyxtext.h"
#include "Lsstream.h"
+using namespace lyx::support;
+
using std::ostream;
extern MathCursor * mathcursor;
-
#include <config.h>
#include "LString.h"
#include <fstream>
#include <vector>
+using namespace lyx::support;
+
using std::ifstream;
using std::istream;
using std::ostream;
//#define FILEDEBUG 1
+using namespace lyx::support;
+
using std::endl;
using std::min;
using std::max;
MathAtom const & MathCursor::prevAtom() const
{
- lyx::Assert(pos() > 0);
+ Assert(pos() > 0);
return array()[pos() - 1];
}
MathAtom & MathCursor::prevAtom()
{
- lyx::Assert(pos() > 0);
+ Assert(pos() > 0);
return array()[pos() - 1];
}
MathAtom const & MathCursor::nextAtom() const
{
- lyx::Assert(pos() < size());
+ Assert(pos() < size());
return array()[pos()];
}
MathAtom & MathCursor::nextAtom()
{
- lyx::Assert(pos() < size());
+ Assert(pos() < size());
return array()[pos()];
}
CursorPos & MathCursor::cursor()
{
- lyx::Assert(depth());
+ Assert(depth());
return Cursor_.back();
}
CursorPos const & MathCursor::cursor() const
{
- lyx::Assert(depth());
+ Assert(depth());
return Cursor_.back();
}
#include "frontends/Painter.h"
#include "textpainter.h"
+using namespace lyx::support;
using std::max;
using std::min;
MathAtom & MathArray::operator[](pos_type pos)
{
- lyx::Assert(pos < size());
+ Assert(pos < size());
return base_type::operator[](pos);
}
MathAtom const & MathArray::operator[](pos_type pos) const
{
- lyx::Assert(pos < size());
+ Assert(pos < size());
return base_type::operator[](pos);
}
void MathArray::insert(size_type pos, MathArray const & ar)
{
- lyx::Assert(pos <= size());
+ Assert(pos <= size());
base_type::insert(begin() + pos, ar.begin(), ar.end());
}
-
#include <config.h>
#include "math_exfuncinset.h"
}
-void MathExFuncInset::metrics(MetricsInfo & mi, Dimension & dim) const
+void MathExFuncInset::metrics(MetricsInfo & mi, Dimension & /*dim*/) const
{
mathed_string_dim(mi.base.font, name_, dim_);
}
#include <algorithm>
+using namespace lyx::support;
+
using std::ostream;
using std::istringstream;
using std::find_if;
-
#include <config.h>
#include "math_parser.h"
#include <map>
#include <fstream>
-bool has_math_fonts;
+using namespace lyx::support;
using std::endl;
+bool has_math_fonts;
+
namespace {
return ar[0].nucleus();
}
-
}
-void MathFontInset::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
+void MathFontInset::metricsT(TextMetricsInfo const & mi, Dimension & /*dim*/) const
{
cell(0).metricsT(mi, dim_);
}
#include <vector>
+using namespace lyx::support;
+
using std::vector;
using std::max;
using std::endl;
string MathHullInset::label(row_type row) const
{
row_type n = nrows();
- lyx::Assert(row < n);
+ Assert(row < n);
return label_[row];
}
void MathHullInset::check() const
{
- lyx::Assert(nonum_.size() == nrows());
- lyx::Assert(label_.size() == nrows());
+ Assert(nonum_.size() == nrows());
+ Assert(label_.size() == nrows());
}
-
#include <config.h>
#include "math_iterator.h"
#include "debug.h"
#include "support/LAssert.h"
+using namespace lyx::support;
MathIterator::MathIterator()
{}
void MathIterator::pop()
{
//lyxerr << "pop: " << endl;
- lyx::Assert(size());
+ Assert(size());
pop_back();
}
void MathIterator::jump(difference_type i)
{
back().pos_ += i;
- //lyx::Assert(back().pos_ >= 0);
- lyx::Assert(back().pos_ <= cell().size());
+ //Assert(back().pos_ >= 0);
+ Assert(back().pos_ <= cell().size());
}
-
#include "config.h"
#include "math_pos.h"
#include "math_inset.h"
#include "support/LAssert.h"
#include "support/LOstream.h"
+using namespace lyx::support;
CursorPos::CursorPos()
: inset_(0), idx_(0), pos_(0)
CursorPos::CursorPos(MathInset * p)
: inset_(p), idx_(0), pos_(0)
{
- lyx::Assert(inset_);
+ Assert(inset_);
}
MathArray & CursorPos::cell(MathArray::idx_type idx) const
{
- lyx::Assert(inset_);
+ Assert(inset_);
return inset_->cell(idx);
}
MathArray & CursorPos::cell() const
{
- lyx::Assert(inset_);
+ Assert(inset_);
return inset_->cell(idx_);
}
-
#include "math_scriptinset.h"
#include "math_support.h"
#include "math_symbolinset.h"
#include "support/LAssert.h"
#include "debug.h"
+using namespace lyx::support;
using std::max;
int MathScriptInset::dx0() const
{
- lyx::Assert(hasDown());
+ Assert(hasDown());
return hasLimits() ? (dim_.wid - down().width()) / 2 : nwid();
}
int MathScriptInset::dx1() const
{
- lyx::Assert(hasUp());
+ Assert(hasUp());
return hasLimits() ? (dim_.wid - up().width()) / 2 : nwid();
}
}
-void MathTabularInset::metrics(MetricsInfo & mi, Dimension & dim) const
+void MathTabularInset::metrics(MetricsInfo & mi, Dimension & /*dim*/) const
{
FontSetChanger dummy(mi.base, "textnormal");
return MathGridInset::metrics(mi);
#include "debug.h"
#include "support/filetools.h"
+using namespace lyx::support;
+
#ifdef ENABLE_NLS
#include <csignal>
#include <ctime>
+using namespace lyx::support;
+
using std::ostream;
using std::endl;
using std::fstream;
Inset * Paragraph::getInset(pos_type pos)
{
- lyx::Assert(pos < size());
+ Assert(pos < size());
return insetlist.get(pos);
}
Inset const * Paragraph::getInset(pos_type pos) const
{
- lyx::Assert(pos < size());
+ Assert(pos < size());
return insetlist.get(pos);
}
LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
pos_type pos) const
{
- lyx::Assert(pos <= size());
+ Assert(pos <= size());
Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
LyXFont const & outerfont) const
{
- lyx::Assert(pos >= 0);
+ Assert(pos >= 0);
LyXLayout_ptr const & lout = layout();
void Paragraph::setFont(pos_type pos, LyXFont const & font)
{
- lyx::Assert(pos <= size());
+ Assert(pos <= size());
// First, reduce font against layout/label font
// Update: The SetCharFont() routine in text2.C already
Change::Type Paragraph::lookupChange(lyx::pos_type pos) const
{
- lyx::Assert(!size() || pos < size());
+ Assert(!size() || pos < size());
return pimpl_->lookupChange(pos);
}
Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const
{
- lyx::Assert(!size() || pos < size());
+ Assert(!size() || pos < size());
return pimpl_->lookupChangeFull(pos);
}
extern string bibitemWidest(Buffer const *);
+using namespace lyx::support;
+
using lyx::pos_type;
//using lyx::layout_type;
using std::endl;
string const s = bformat(_("Unknown token: %1$s %2$s\n"),
token, lex.getString());
- buf.parseError(ErrorItem(_("Unknown token"), s,
+ buf.parseError(ErrorItem(_("Unknown token"), s,
par.id(), 0, par.size()));
return 1;
}
#include "support/LAssert.h"
+using namespace lyx::support;
using lyx::pos_type;
using std::endl;
using std::ostream;
void Paragraph::Pimpl::markErased()
{
- lyx::Assert(tracking());
+ Assert(tracking());
// FIXME: we should actually remove INSERTED chars.
// difficult because owning insettexts/tabulars need
// This is in the critical path for loading!
pos_type const siz = size();
- lyx::Assert(pos <= siz);
+ Assert(pos <= siz);
if (pos == siz) {
lyxerr << "getChar() on pos " << pos << " in par id "
return text[pos];
#else
- lyx::Assert(pos < size());
+ Assert(pos < size());
return text[pos];
#endif
}
void Paragraph::Pimpl::insertChar(pos_type pos, value_type c,
LyXFont const & font, Change change)
{
- lyx::Assert(pos <= size());
+ Assert(pos <= size());
if (tracking()) {
changes_->record(change, pos);
void Paragraph::Pimpl::insertInset(pos_type pos,
Inset * inset, LyXFont const & font, Change change)
{
- lyx::Assert(inset);
- lyx::Assert(pos <= size());
+ Assert(inset);
+ Assert(pos <= size());
insertChar(pos, META_INSET, font, change);
- lyx::Assert(text[pos] == META_INSET);
+ Assert(text[pos] == META_INSET);
// Add a new entry in the insetlist.
owner_->insetlist.insert(inset, pos);
bool Paragraph::Pimpl::erase(pos_type pos)
{
- lyx::Assert(pos < size());
+ Assert(pos < size());
if (tracking()) {
Change::Type changetype(changes_->lookup(pos));
#include "pspell.h"
#include "WordLangTuple.h"
+using namespace lyx::support;
+
using std::endl;
PSpell::PSpell(BufferParams const &, string const & lang)
PspellManager * m = it->second.manager;
int word_ok = pspell_manager_check(m, word.word().c_str());
- lyx::Assert(word_ok != -1);
+ Assert(word_ok != -1);
if (word_ok) {
res = OK;
} else {
PspellWordList const * sugs =
pspell_manager_suggest(m, word.word().c_str());
- lyx::Assert(sugs != 0);
+ Assert(sugs != 0);
els = pspell_word_list_elements(sugs);
if (pspell_word_list_empty(sugs))
res = UNKNOWN;
#include <config.h>
-#include <algorithm>
-
#include "frontends/Painter.h"
#include "frontends/screen.h"
#include "frontends/font_metrics.h"
#include "lyxrow_funcs.h"
#include "metricsinfo.h"
+#include <algorithm>
+
+using namespace lyx::support;
+
using std::max;
using lyx::pos_type;
{
Inset * inset = const_cast<Inset*>(pit_->getInset(pos));
- lyx::Assert(inset);
+ Assert(inset);
#warning inset->update FIXME
inset->update(perv(bv_), false);
+2003-07-01 Lars Gullik Bjønnes <larsbj@gullik.net>
+
+ * introduce namespace lyx::support
2003-06-30 André Pönitz <poenitz@gmx.net>
} // namespace anon
+namespace lyx {
+namespace support {
+
FileInfo::FileInfo()
{
init();
// should not be in FileInfo
char FileInfo::typeIndicator() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
if (S_ISDIR(buf_.st_mode))
return '/';
#ifdef S_ISLNK
mode_t FileInfo::getMode() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return buf_.st_mode;
}
// should not be in FileInfo
string FileInfo::modeString() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
char str[11];
str[0] = typeLetter(buf_.st_mode);
flagRWX((buf_.st_mode & 0700) << 0, &str[1]);
time_t FileInfo::getModificationTime() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return buf_.st_mtime;
}
time_t FileInfo::getAccessTime() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return buf_.st_atime;
}
time_t FileInfo::getStatusChangeTime() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return buf_.st_ctime;
}
nlink_t FileInfo::getNumberOfLinks() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return buf_.st_nlink;
}
uid_t FileInfo::getUid() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return buf_.st_uid;
}
gid_t FileInfo::getGid() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return buf_.st_gid;
}
off_t FileInfo::getSize() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return buf_.st_size;
}
bool FileInfo::isLink() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return S_ISLNK(buf_.st_mode);
}
bool FileInfo::isRegular() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return S_ISREG(buf_.st_mode);
}
bool FileInfo::isDir() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return S_ISDIR(buf_.st_mode);
}
bool FileInfo::isChar() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return S_ISCHR(buf_.st_mode);
}
bool FileInfo::isBlock() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return S_ISBLK(buf_.st_mode);
}
bool FileInfo::isFifo() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
return S_ISFIFO(buf_.st_mode);
}
bool FileInfo::isSocket() const
{
- lyx::Assert(isOK());
+ Assert(isOK());
#ifdef S_ISSOCK
return S_ISSOCK(buf_.st_mode);
#else
// the file access failed.
return ::access(fname_.c_str(), p) == 0;
}
+
+} // namespace support
+} // namespace lyx
#include <boost/utility.hpp>
#include "LString.h"
+namespace lyx {
+namespace support {
+
/** Use objects of this class to get information about files.
*
* Users must make sure to check fi.isOK() before any operations
string fname_;
};
+} // namespace support
+} // namespace lyx
+
#endif
#include <boost/bind.hpp>
#include <boost/signals/trackable.hpp>
+namespace lyx {
+namespace support {
+
struct FileMonitor::Impl : public boost::signals::trackable {
///
return;
pimpl_->timestamp_ = finfo.getModificationTime();
- pimpl_->checksum_ = lyx::sum(pimpl_->filename_);
+ pimpl_->checksum_ = sum(pimpl_->filename_);
if (pimpl_->timestamp_ && pimpl_->checksum_) {
pimpl_->timer_.start();
// If we aren't actively monitoring the file, then recompute the
// checksum explicitly.
if (!pimpl_->timer_.running() && !pimpl_->filename_.empty())
- return lyx::sum(pimpl_->filename_);
+ return sum(pimpl_->filename_);
return pimpl_->checksum_;
}
if (new_timestamp != timestamp_) {
timestamp_ = new_timestamp;
- unsigned long const new_checksum = lyx::sum(filename_);
+ unsigned long const new_checksum = sum(filename_);
if (new_checksum != checksum_) {
checksum_ = new_checksum;
changed = true;
if (changed)
fileChanged_();
}
+
+} // namespace support
+} // namespace lyx
#include <boost/scoped_ptr.hpp>
#include <boost/signals/signal0.hpp>
+namespace lyx {
+namespace support {
+
class FileMonitor : boost::noncopyable {
public:
/** Once monitoring begins, the file will be monitored every
boost::scoped_ptr<Impl> const pimpl_;
};
+} // namespace support
+} // namespace lyx
+
#endif // FILEMONITOR_H
#include <config.h>
#include "LAssert.h"
+#include "support/lyxlib.h"
#ifdef ENABLE_ASSERTIONS
#include "lyx_main.h"
-void emergencyCleanup() {
+namespace lyx {
+namespace support {
+
+namespace {
+
+void emergencyCleanup()
+{
static bool didCleanup;
if (didCleanup)
return;
LyX::emergencyCleanup();
}
+} // namespace anon
+
+void Assert(bool assertion)
+{
+ if (!assertion) {
+ emergencyCleanup();
+ lyx::support::abort();
+ }
+}
+
+} // namespace support
+} // namespace lyx
+
#endif
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
*
* Full author contact details are available in file CREDITS
*/
#ifndef LASSERT_H
#define LASSERT_H
-#include "support/lyxlib.h"
-
-extern void emergencyCleanup();
-
namespace lyx {
+namespace support {
#ifdef ENABLE_ASSERTIONS
we run #emergencyCleanup()# and then #lyx::abort".
@param assertion this should evaluate to true unless you want an abort.
*/
-template<class A>
-inline
-void Assert(A assertion)
-{
- if (!assertion) {
- ::emergencyCleanup();
- lyx::abort();
- }
-}
+void Assert(bool assertion);
#else
/** Dummy assertion.
When compiling without assertions we use this no-op function.
*/
-template<class A>
inline
-void Assert(A /*assertion*/) {}
+void Assert(bool /*assertion*/) {}
#endif /* ENABLE_ASSERTIONS */
-} // end of namespace LyX
+} // namespace support
+} // namespace lyx
#endif /* LASSERT_H */
#include "support/lyxlib.h"
-void lyx::abort()
+void lyx::support::abort()
{
::abort();
}
using std::atoi;
#endif
-int lyx::atoi(string const & nstr)
+int lyx::support::atoi(string const & nstr)
{
return ::atoi(nstr.c_str());
}
#include "support/lyxlib.h"
-int lyx::chdir(string const & name)
+int lyx::support::chdir(string const & name)
{
#ifndef __EMX__
return ::chdir(name.c_str());
using std::ofstream;
using std::ios;
-bool lyx::copy(string const & from, string const & to)
+bool lyx::support::copy(string const & from, string const & to)
{
ifstream ifs(from.c_str());
if (!ifs)
extern string build_lyxdir;
extern string user_lyxdir;
+namespace lyx {
+namespace support {
bool IsLyXFilename(string const & filename)
{
{
lyxerr[Debug::FILES] << "IsDirWriteable: " << path << endl;
- string const tmpfl(lyx::tempName(path, "lyxwritetest"));
+ string const tmpfl(tempName(path, "lyxwritetest"));
if (tmpfl.empty())
return false;
- lyx::unlink(tmpfl);
+ unlink(tmpfl);
return true;
}
FileInfo fi(unlinkpath);
if (fi.isOK() && fi.isDir())
deleted = (DeleteAllFilesInDir(unlinkpath) == 0);
- deleted &= (lyx::unlink(unlinkpath) == 0);
+ deleted &= (unlink(unlinkpath) == 0);
if (!deleted)
return_value = -1;
}
<< "CreateTmpDir: tempdir=`" << tempdir << "'\n"
<< "CreateTmpDir: mask=`" << mask << '\'' << endl;
- string const tmpfl(lyx::tempName(tempdir, mask));
+ string const tmpfl(tempName(tempdir, mask));
// lyx::tempName actually creates a file to make sure that it
// stays unique. So we have to delete it before we can create
// a dir with the same name. Note also that we are not thread
// safe because of the gap between unlink and mkdir. (Lgb)
- lyx::unlink(tmpfl.c_str());
+ unlink(tmpfl);
- if (tmpfl.empty() || lyx::mkdir(tmpfl, 0700))
+ if (tmpfl.empty() || mkdir(tmpfl, 0700))
return string();
return MakeAbsPath(tmpfl);
if (DeleteAllFilesInDir(tmpdir))
return -1;
- if (lyx::rmdir(tmpdir))
+ if (rmdir(tmpdir))
return -1;
return 0;
// In fact I wrote this code to circumvent a problematic behaviour (bug?)
// of EMX mkstemp().
string const tmpfl = tmpdir + "/lyx_tmpbuf" + tostr(count++);
- if (lyx::mkdir(tmpfl, 0777)) {
+ if (mkdir(tmpfl, 0777)) {
return string();
}
return tmpfl;
string const CreateLyXTmpDir(string const & deflt)
{
if ((!deflt.empty()) && (deflt != "/tmp")) {
- if (lyx::mkdir(deflt, 0777)) {
+ if (mkdir(deflt, 0777)) {
#ifdef __EMX__
Path p(user_lyxdir);
#endif
{
string temp(rtrim(os::slashify_path(path), "/"));
- lyx::Assert(!temp.empty());
+ Assert(!temp.empty());
- if (lyx::mkdir(temp, permission))
+ if (mkdir(temp, permission))
return false;
return true;
if (os::is_absolute_path(BasePath))
TempBase = BasePath;
else
- TempBase = AddPath(lyx::getcwd(), BasePath);
+ TempBase = AddPath(getcwd(), BasePath);
// Handle /./ at the end of the path
while (suffixIs(TempBase, "/./"))
RTemp = split(RTemp, Temp, '/');
if (Temp == ".") {
- return lyx::getcwd() /*GetCWD()*/ + '/' + RTemp;
+ return getcwd() + '/' + RTemp;
}
if (Temp == "~") {
return GetEnvPath("HOME") + '/' + RTemp;
string const unzipFile(string const & zipped_file)
{
string const file = ChangeExtension(zipped_file, string());
- string const tempfile = lyx::tempName(string(), file);
+ string const tempfile = tempName(string(), file);
// Run gunzip
string const command = "gunzip -c " + zipped_file + " > " + tempfile;
Systemcall one;
a += '#';
FileInfo const fileinfo(a);
if (fileinfo.exist())
- lyx::unlink(a);
+ unlink(a);
}
{
lyxerr[Debug::GRAPHICS] << "[readBB_from_PSFile] "
<< message << std::endl;
+#warning Why is this func deleting a file? (Lgb)
if (zipped)
- lyx::unlink(file);
+ unlink(file);
}
string const copyFileToDir(string const & path, string const & file_in)
{
- lyx::Assert(AbsolutePath(path));
+ Assert(AbsolutePath(path));
// First, make the file path relative to path.
string file_out = MakeRelPath(path, NormalizePath(file_in));
if (!fi2.exist() ||
difftime(fi.getModificationTime(),
fi2.getModificationTime()) >= 0)
- success = lyx::copy(file_in, file_out);
+ success = copy(file_in, file_out);
}
return success ? file_out : string();
}
+
+} //namespace support
+} // namespace lyx
#include "os.h"
+namespace lyx {
+namespace support {
+
/// remove directory and all contents, returns 0 on success
int destroyDir(string const & tmpdir);
cmd_ret const RunCommand(string const & cmd);
+} // namespace support
+} // namespace lyx
+
#endif
using std::strerror;
#endif
+namespace lyx {
+namespace support {
+
namespace {
if (secs > 0) {
new Murder(secs, pid);
} else if (pid != 0) {
- lyx::kill(pid, SIGKILL);
+ lyx::support::kill(pid, SIGKILL);
}
}
void kill()
{
if (pid_ != 0) {
- lyx::kill(pid_, SIGKILL);
+ lyx::support::kill(pid_, SIGKILL);
}
lyxerr << "Killed " << pid_ << std::endl;
delete this;
Murder::killItDead(0, pid());
} else {
- int ret = lyx::kill(pid(), SIGHUP);
+ int ret = lyx::support::kill(pid(), SIGHUP);
// The process is already dead if wait_for_death is false
bool const wait_for_death = (ret == 0 && errno != ESRCH);
return cpid;
}
+
+} // namespace support
+} // namespace lyx
#include <sys/types.h>
+namespace lyx {
+namespace support {
+
class ForkedProcess {
public:
///
virtual int generateChild();
};
+} // namespace support
+} // namespace lyx
+
#endif // FORKEDCALL_H
using std::endl;
using std::queue;
+namespace lyx {
+namespace support {
+
ForkedCallQueue & ForkedCallQueue::get()
{
static ForkedCallQueue singleton;
{
return running_ ;
}
+
+} // namespace support
+} // namespace lyx
* Licence details can be found in the file COPYING.
*
* \author Alfredo Braunstein (based on an idea from Angus Leeming)
- *
+ *
* Full author contact details are available in file CREDITS
- *
- * This class implements a queue of forked processes. In order not to
- * hose the system with multiple processes running simultaneously, you can
- * request the addition of your process to this queue and it will be
+ *
+ * This class implements a queue of forked processes. In order not to
+ * hose the system with multiple processes running simultaneously, you can
+ * request the addition of your process to this queue and it will be
* executed when its turn comes.
- *
+ *
*/
#ifndef FORKEDCALLQUEUE_H
#include <utility>
#include "LString.h"
+namespace lyx {
+namespace support {
+
class ForkedCallQueue {
public:
/// A process in the queue
private:
- /** this class is a singleton class... use
+ /** this class is a singleton class... use
* ForkedCallQueue::get() instead
*/
ForkedCallQueue();
- /// in-progress queue
+ /// in-progress queue
std::queue<Process> callQueue_;
///
bool running_;
void callback(pid_t, int);
};
+} // namespace support
+} // namespace lyx
+
#endif // FORKEDCALLQUEUE_H
using std::strerror;
#endif
+namespace lyx {
+namespace support {
+
// Ensure, that only one controller exists inside process
ForkedcallsController & ForkedcallsController::get()
{
timeout_->stop();
}
}
+
+} // namespace support
+} // namespace lyx
#include <list>
#include <vector>
-class ForkedProcess;
class Timeout;
+namespace lyx {
+namespace support {
+
+class ForkedProcess;
+
class ForkedcallsController : public boost::signals::trackable {
public:
/// We need this to avoid warnings.
Timeout * timeout_;
};
+} // namespace support
+} // namespace lyx
+
#endif // FORKEDCONTR_H
// Returns current working directory
-string const lyx::getcwd()
+string const lyx::support::getcwd()
{
int n = 256; // Assume path is less than 256 chars
char * err;
#include <sys/types.h>
#include <csignal>
-int lyx::kill(int pid, int sig)
+int lyx::support::kill(int pid, int sig)
{
return ::kill(pid, sig);
}
#include "Lsstream.h"
#include "debug.h"
#include "BoostFormat.h"
+#include "lyxlib.h"
#include <boost/regex.hpp>
#include <boost/tokenizer.hpp>
using std::toupper;
#endif
+namespace lyx {
+namespace support {
int compare_no_case(string const & s, string const & s2)
{
// Remove leading and trailing white space chars.
string const tmpstr = trim(str);
// Do the conversion proper.
- return lyx::atoi(tmpstr);
+ return atoi(tmpstr);
} else {
return 0;
}
// Remove leading and trailing white space chars.
string const tmpstr = trim(str);
// Do the conversion proper.
- return lyx::atoi(tmpstr);
+ return atoi(tmpstr);
} else {
return 0;
}
string const trim(string const & a, char const * p)
{
- lyx::Assert(p);
+ Assert(p);
if (a.empty() || !*p)
return a;
string const rtrim(string const & a, char const * p)
{
- lyx::Assert(p);
+ Assert(p);
if (a.empty() || !*p)
return a;
string const ltrim(string const & a, char const * p)
{
- lyx::Assert(p);
+ Assert(p);
if (a.empty() || !*p)
return a;
string bformat(string const & fmt, string const & arg1)
{
- lyx::Assert(contains(fmt, "%1$s"));
+ Assert(contains(fmt, "%1$s"));
string const str = subst(fmt, "%1$s", arg1);
return subst(str, "%%", "%");
}
string bformat(string const & fmt, string const & arg1, string const & arg2)
{
- lyx::Assert(contains(fmt, "%1$s"));
- lyx::Assert(contains(fmt, "%2$s"));
+ Assert(contains(fmt, "%1$s"));
+ Assert(contains(fmt, "%2$s"));
string str = subst(fmt, "%1$s", arg1);
str = subst(str, "%2$s", arg2);
return subst(str, "%%", "%");
string bformat(string const & fmt, string const & arg1, string const & arg2,
string const & arg3)
{
- lyx::Assert(contains(fmt, "%1$s"));
- lyx::Assert(contains(fmt, "%2$s"));
- lyx::Assert(contains(fmt, "%3$s"));
+ Assert(contains(fmt, "%1$s"));
+ Assert(contains(fmt, "%2$s"));
+ Assert(contains(fmt, "%3$s"));
string str = subst(fmt, "%1$s", arg1);
str = subst(str, "%2$s", arg2);
str = subst(str, "%3$s", arg3);
string bformat(string const & fmt, string const & arg1, string const & arg2,
string const & arg3, string const & arg4)
{
- lyx::Assert(contains(fmt, "%1$s"));
- lyx::Assert(contains(fmt, "%2$s"));
- lyx::Assert(contains(fmt, "%3$s"));
- lyx::Assert(contains(fmt, "%4$s"));
+ Assert(contains(fmt, "%1$s"));
+ Assert(contains(fmt, "%2$s"));
+ Assert(contains(fmt, "%3$s"));
+ Assert(contains(fmt, "%4$s"));
string str = subst(fmt, "%1$s", arg1);
str = subst(str, "%2$s", arg2);
str = subst(str, "%3$s", arg3);
}
#endif
+
+} // namespace support
+} // namespace lyx
#include "LString.h"
+namespace lyx {
+namespace support {
+
///
int compare_no_case(string const & s, string const & s2);
string bformat(string const & fmt, string const & arg1, string const & arg2,
string const & arg3, string const & arg4);
+} // namespace support
+} // namespace lyx
+
#endif
#include "LString.h"
namespace lyx {
+namespace support {
/// get the current working directory
string const getcwd();
return (number - error <= var && var <= number + error);
}
+} // namespace support
} // namespace lyx
#endif /* LYX_LIB_H */
#endif
#include "lyxstring.h"
-#include <cstdlib>
-#include <cctype>
-#include <algorithm>
#include "LAssert.h"
#include "debug.h"
+#include <iostream>
+#include <cstdlib>
+#include <cctype>
+#include <algorithm>
+
using std::min;
using std::istream;
using std::ostream;
// Lgb.
+namespace lyx {
+
+using support::Assert;
///////////////////////////////////////
// The internal string representation
///////////////////////////////////////
-struct lyxstring::Srep {
+struct string::Srep {
/// size
size_t sz;
/// Reference count
/// The total amount of data reserved for this representaion
size_t res;
/// Data. At least 1 char for trailing null.
- lyxstring::value_type * s;
+ string::value_type * s;
///
- Srep(lyxstring::size_type nsz, const lyxstring::value_type * p);
+ Srep(string::size_type nsz, const string::value_type * p);
///
- Srep(lyxstring::size_type nsz, lyxstring::value_type ch);
+ Srep(string::size_type nsz, string::value_type ch);
///
~Srep() { delete[] s; }
///
}
///
- void assign(lyxstring::size_type nsz, const lyxstring::value_type * p);
+ void assign(string::size_type nsz, const string::value_type * p);
///
- void assign(lyxstring::size_type nsz, lyxstring::value_type ch);
+ void assign(string::size_type nsz, string::value_type ch);
///
- void append(lyxstring::size_type asz, const lyxstring::value_type * p);
+ void append(string::size_type asz, const string::value_type * p);
///
- void push_back(lyxstring::value_type c);
+ void push_back(string::value_type c);
///
- void insert(lyxstring::size_type pos,
- const lyxstring::value_type * p,
- lyxstring::size_type n);
+ void insert(string::size_type pos,
+ const string::value_type * p,
+ string::size_type n);
///
- void resize(lyxstring::size_type n, lyxstring::value_type c);
+ void resize(string::size_type n, string::value_type c);
///
- void reserve(lyxstring::size_type res_arg);
+ void reserve(string::size_type res_arg);
///
- void replace(lyxstring::size_type i, lyxstring::size_type n,
- lyxstring::value_type const * p, lyxstring::size_type n2);
+ void replace(string::size_type i, string::size_type n,
+ string::value_type const * p, string::size_type n2);
private:
Srep(const Srep &);
Srep & operator=(const Srep &);
};
-lyxstring::Srep::Srep(lyxstring::size_type nsz, const value_type * p)
+string::Srep::Srep(string::size_type nsz, const value_type * p)
{
// can be called with p == 0 by
- // lyxstring::assign(const value_type *, size_type)
+ // string::assign(const value_type *, size_type)
sz = nsz;
ref = 1;
}
-lyxstring::Srep::Srep(lyxstring::size_type nsz, value_type ch)
+string::Srep::Srep(string::size_type nsz, value_type ch)
{
sz = nsz;
ref = 1;
s = new value_type[res + 1]; // add space for terminator
memset(s, ch, sz);
if (!ch) {
- // if ch == '\0' strlen(lyxstring.c_str()) == 0 so sz = 0
+ // if ch == '\0' strlen(string.c_str()) == 0 so sz = 0
// allows for large but empty string
sz = 0;
}
}
-void lyxstring::Srep::assign(lyxstring::size_type nsz, const value_type * p)
+void string::Srep::assign(string::size_type nsz, const value_type * p)
{
// can be called with p == 0
- // by lyxstring::assign(const value_type *, size_type)
+ // by string::assign(const value_type *, size_type)
if (res < nsz) {
delete[] s;
}
-void lyxstring::Srep::assign(lyxstring::size_type nsz, value_type ch)
+void string::Srep::assign(string::size_type nsz, value_type ch)
{
sz = nsz;
if (res < nsz) {
}
memset(s, ch, sz);
if (!ch) {
- // if ch == '\0' strlen(lyxstring.c_str()) == 0 so sz = 0
+ // if ch == '\0' strlen(string.c_str()) == 0 so sz = 0
// allows for a large empty string
sz = 0;
}
}
-void lyxstring::Srep::append(lyxstring::size_type asz, const value_type * p)
+void string::Srep::append(string::size_type asz, const value_type * p)
{
register unsigned int const len = sz + asz;
if (res < len) {
}
-void lyxstring::Srep::push_back(value_type c)
+void string::Srep::push_back(value_type c)
{
s[sz] = c; // it is always room to put a value_type at the end
++sz;
}
-void lyxstring::Srep::insert(lyxstring::size_type pos, const value_type * p,
- lyxstring::size_type n)
+void string::Srep::insert(string::size_type pos, const value_type * p,
+ string::size_type n)
{
if (res < n + sz) {
do {
}
-void lyxstring::Srep::resize(size_type n, value_type c)
+void string::Srep::resize(size_type n, value_type c)
{
// This resets sz to res_arg
res = min(n, npos - 2); // We keep no xtra when we resize
}
-void lyxstring::Srep::reserve(lyxstring::size_type res_arg)
+void string::Srep::reserve(string::size_type res_arg)
{
// This keeps the old sz, but
// increases res with res_arg
}
-void lyxstring::Srep::replace(lyxstring::size_type i, lyxstring::size_type n,
+void string::Srep::replace(string::size_type i, string::size_type n,
value_type const * p, size_type n2)
{
// can be called with p= 0 and n2= 0
///////////////////////////////////////
-// The lyxstring Invariant tester
+// The string Invariant tester
///////////////////////////////////////
-// There are no know bugs in lyxstring now, and it have been
+// There are no know bugs in string now, and it have been
// tested for a long time. so we disable the invariant checker. (Lgb)
#undef ENABLE_ASSERTIONS
#ifdef ENABLE_ASSERTIONS
-/** Testing of the lyxstring invariant
- * By creating an object that tests the lyxstring invariant during its
+/** Testing of the string invariant
+ * By creating an object that tests the string invariant during its
* construction *and* its deconstruction we greatly simplify our code.
- * Calling TestlyxstringInvariant() upon entry to an lyxstring method
+ * Calling TeststringInvariant() upon entry to an string method
* will test the invariant upon entry to the code. If the Asserts fail
* then we know from the stack trace that the corruption occurred *before*
* entry to this method. We can also be sure it didn't happen in any of
- * the tested lyxstring methods. It is therefore likely to be due to some
+ * the tested string methods. It is therefore likely to be due to some
* other external force.
- * Several lyxstring methods have multiple exit points which would otherwise
+ * Several string methods have multiple exit points which would otherwise
* require us to insert a separate test before each return. But since we
* created an object its destructor will be called upon exit (any exit!).
* We thus get testing at both start and end of a method with one line of
* everytime we run the code.
* NOTE: just because we test the invariant doesn't mean we can forget
* about testing pre and post conditions specific to any given method.
- * This test simply proves that the lyxstring/Srep is in a valid state it
+ * This test simply proves that the string/Srep is in a valid state it
* does *not* prove that the method did what it was supposed to.
*/
-class lyxstringInvariant {
+class stringInvariant {
public:
- lyxstringInvariant(lyxstring const *);
- ~lyxstringInvariant();
+ stringInvariant(string const *);
+ ~stringInvariant();
private:
void helper() const;
- lyxstring const * object;
+ string const * object;
};
// To test if this scheme works "as advertised" uncomment the printf's in
// the constructor and destructor below and then uncomment the printf and the
-// call to TestlyxstringInvariant() in lyxstring::operator=(char const *).
+// call to TestlyxstringInvariant() in string::operator=(char const *).
// The correct output when LyX has been recompiled and run is:
// lyxstringInvariant constructor
-// lyxstring::operator=(char const *)
+// string::operator=(char const *)
// lyxstringInvariant constructor
// lyxstringInvariant destructor completed
// lyxstringInvariant destructor completed
// NOTE: The easiest way to catch this snippet of the output is to wait for
// the splash screen to disappear and then open and close Help->Credits
//
-lyxstringInvariant::lyxstringInvariant(lyxstring const * ls) : object(ls)
+stringInvariant::stringInvariant(string const * ls) : object(ls)
{
- // printf("lyxstringInvariant constructor\n");
+ // printf("stringInvariant constructor\n");
helper();
}
-lyxstringInvariant::~lyxstringInvariant()
+stringInvariant::~stringInvariant()
{
helper();
- // printf("lyxstringInvariant destructor completed\n");
+ // printf("stringInvariant destructor completed\n");
}
-void lyxstringInvariant::helper() const
+void stringInvariant::helper() const
{
// Some of these tests might look pointless but they are
// all part of the invariant and if we want to make sure
// test every last little thing we *know* should be true.
// I may have missed a test or two, so feel free to fill
// in the gaps. ARRae.
- using lyx::Assert;
Assert(object);
Assert(object->rep);
Assert(object->rep->s); // s is never 0
// if it does ever == then we should be generating a new copy
// and starting again. (Is char always 8-bits?)
}
-#define TestlyxstringInvariant(s) lyxstringInvariant lyxstring_invariant(s);
+#define TeststringInvariant(s) stringInvariant string_invariant(s);
#else
-#define TestlyxstringInvariant(s)
+#define TeststringInvariant(s)
#endif /* ENABLE_ASSERTIONS */
// Constructors and Deconstructors.
///////////////////////////////////////
-lyxstring::size_type const lyxstring::npos =
-static_cast<lyxstring::size_type>(-1);
+string::size_type const string::npos =
+static_cast<string::size_type>(-1);
-lyxstring::lyxstring()
+string::string()
{
static Srep empty_rep(0, "");
++empty_rep.ref;
}
-lyxstring::lyxstring(lyxstring const & x, size_type pos, size_type n)
+string::string(string const & x, size_type pos, size_type n)
{
- lyx::Assert(pos <= x.rep->sz); // STD!
+ Assert(pos <= x.rep->sz); // STD!
if (pos == 0 && n >= x.length()) { // this is the default
x.rep->ref++;
rep = x.rep;
}
-lyxstring::lyxstring(value_type const * s, size_type n)
+string::string(value_type const * s, size_type n)
{
- lyx::Assert(s && n < npos); // STD!
+ Assert(s && n < npos); // STD!
static Srep empty_rep(0, "");
if (n) { // n > 0
rep = new Srep(n, s);
}
-lyxstring::lyxstring(value_type const * s)
+string::string(value_type const * s)
{
- lyx::Assert(s); // STD!
+ Assert(s); // STD!
static Srep empty_rep(0, "");
if (*s) { // s is not empty string
rep = new Srep(strlen(s), s);
}
-lyxstring::lyxstring(size_type n, value_type c)
+string::string(size_type n, value_type c)
{
- lyx::Assert(n < npos); // STD!
+ Assert(n < npos); // STD!
rep = new Srep(n, c);
}
-#warning lyxstring user, have a look here. (Lgb)
+#warning string user, have a look here. (Lgb)
#if 0
// Commented out to avoid warnings from doxygen. (Lgb)
-lyxstring::lyxstring(const_iterator first, const_iterator last)
+string::string(const_iterator first, const_iterator last)
{
rep = new Srep(last - first, first);
}
#endif
-lyxstring::~lyxstring()
+string::~string()
{
if (--rep->ref == 0) delete rep;
}
// Iterators
///////////////////////
-lyxstring::iterator lyxstring::begin()
+string::iterator string::begin()
{
rep = rep->get_own_copy();
return rep->s;
}
-lyxstring::const_iterator lyxstring::begin() const
+string::const_iterator string::begin() const
{
return rep->s;
}
-lyxstring::iterator lyxstring::end()
+string::iterator string::end()
{
rep = rep->get_own_copy();
return rep->s + rep->sz;
}
-lyxstring::const_iterator lyxstring::end() const
+string::const_iterator string::end() const
{
return rep->s + rep->sz;
}
#if 0
-reverse_iterator lyxstring::rbegin()
+reverse_iterator string::rbegin()
{
return reverse_iterator( end() );
}
-const_reverse_iterator lyxstring::rbegin() const
+const_reverse_iterator string::rbegin() const
{
return const_reverse_iterator( end() );
}
-reverse_iterator lyxstring::rend()
+reverse_iterator string::rend()
{
return reverse_iterator( begin() );
}
-const_reverse_iterator lyxstring::rend() const
+const_reverse_iterator string::rend() const
{
return const_reverse_iterator( begin() );
}
// Size and Capacity
///////////////////////
-lyxstring::size_type lyxstring::size() const
+string::size_type string::size() const
{
return rep->sz;
}
-void lyxstring::resize(size_type n, value_type c)
+void string::resize(size_type n, value_type c)
{
- lyx::Assert(n <= npos); // STD!
- TestlyxstringInvariant(this);
+ Assert(n <= npos); // STD!
+ TeststringInvariant(this);
// This resets sz to res_arg
rep = rep->get_own_copy();
}
-lyxstring::size_type lyxstring::capacity() const
+string::size_type string::capacity() const
{
return rep->res;
}
-void lyxstring::reserve(size_type res_arg)
+void string::reserve(size_type res_arg)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
rep = rep->get_own_copy();
rep->reserve(res_arg);
// Assignment
////////////////
-lyxstring & lyxstring::operator=(lyxstring const & x)
+string & string::operator=(string const & x)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
return assign(x);
}
-lyxstring & lyxstring::operator=(value_type const * s)
+string & string::operator=(value_type const * s)
{
- lyx::Assert(s); // OURS!
- TestlyxstringInvariant(this);
-// printf("lyxstring::operator= (value_type const *)\n");
+ Assert(s); // OURS!
+ TeststringInvariant(this);
+// printf("string::operator= (value_type const *)\n");
return assign(s);
}
-lyxstring & lyxstring::operator=(value_type c)
+string & string::operator=(value_type c)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
value_type s[1];
s[0] = c;
}
-lyxstring & lyxstring::assign(lyxstring const & x)
+string & string::assign(string const & x)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
x.rep->ref++; // protect against ``st = st''
if (--rep->ref == 0) delete rep;
}
-lyxstring & lyxstring::assign(lyxstring const & x, size_type pos, size_type n)
+string & string::assign(string const & x, size_type pos, size_type n)
{
- lyx::Assert(pos <= x.rep->sz); // STD!
- TestlyxstringInvariant(this);
+ Assert(pos <= x.rep->sz); // STD!
+ TeststringInvariant(this);
return assign(x.substr(pos, n));
}
-lyxstring & lyxstring::assign(value_type const * s, size_type n)
+string & string::assign(value_type const * s, size_type n)
{
- lyx::Assert(s && n < npos); // STD!
- TestlyxstringInvariant(this);
+ Assert(s && n < npos); // STD!
+ TeststringInvariant(this);
if (rep->ref == 1) // recycle rep
rep->assign(n, s);
}
-lyxstring & lyxstring::assign(value_type const * s)
+string & string::assign(value_type const * s)
{
- lyx::Assert(s); // OURS!
- TestlyxstringInvariant(this);
+ Assert(s); // OURS!
+ TeststringInvariant(this);
return assign(s, strlen(s));
}
-lyxstring & lyxstring::assign(size_type n, value_type ch)
+string & string::assign(size_type n, value_type ch)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
rep = rep->get_own_copy();
rep->assign(n, ch);
}
-lyxstring & lyxstring::assign(const_iterator first, const_iterator last)
+string & string::assign(const_iterator first, const_iterator last)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
rep = rep->get_own_copy();
rep->assign(last - first, first);
// Element Access
////////////////////
-lyxstring::const_reference lyxstring::operator[](size_type pos) const
+string::const_reference string::operator[](size_type pos) const
{
#if 0
// This is actually what the standard requires,
- lyx::Assert(pos <= rep->sz); // OURS!
+ Assert(pos <= rep->sz); // OURS!
static char const helper = '\0';
return pos == rep->sz ? helper : rep->s[pos];
#else
// but we use this one since it is stricter
// and more according to the real intent of std::string.
- lyx::Assert(pos < rep->sz); // OURS!
+ Assert(pos < rep->sz); // OURS!
return rep->s[pos];
#endif
}
-lyxstring::reference lyxstring::operator[](size_type pos)
+string::reference string::operator[](size_type pos)
{
- lyx::Assert(pos < rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(pos < rep->sz); // OURS!
+ TeststringInvariant(this);
rep = rep->get_own_copy();
return rep->s[pos];
}
-lyxstring::const_reference lyxstring::at(size_type n) const
+string::const_reference string::at(size_type n) const
{
- lyx::Assert(n < rep->sz); // STD!
+ Assert(n < rep->sz); // STD!
return rep->s[n];
}
-lyxstring::reference lyxstring::at(size_type n)
+string::reference string::at(size_type n)
{
- lyx::Assert(n < rep->sz); // STD!
- TestlyxstringInvariant(this);
+ Assert(n < rep->sz); // STD!
+ TeststringInvariant(this);
rep = rep->get_own_copy();
return rep->s[n];
// Insert
/////////////
-lyxstring & lyxstring::operator+=(lyxstring const & x)
+string & string::operator+=(string const & x)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
return append(x);
}
-lyxstring & lyxstring::operator+=(value_type const * x)
+string & string::operator+=(value_type const * x)
{
- lyx::Assert(x); // OURS!
- TestlyxstringInvariant(this);
+ Assert(x); // OURS!
+ TeststringInvariant(this);
return append(x);
}
-lyxstring & lyxstring::operator+=(value_type c)
+string & string::operator+=(value_type c)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
push_back(c);
return *this;
}
-void lyxstring::push_back(value_type c)
+void string::push_back(value_type c)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
rep = rep->get_own_copy();
rep->push_back(c);
}
-lyxstring & lyxstring::append(lyxstring const & x)
+string & string::append(string const & x)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
if (x.empty()) return *this;
rep = rep->get_own_copy();
}
-lyxstring & lyxstring::append(lyxstring const & x, size_type pos, size_type n)
+string & string::append(string const & x, size_type pos, size_type n)
{
- lyx::Assert(pos <= x.rep->sz); // STD!
- TestlyxstringInvariant(this);
+ Assert(pos <= x.rep->sz); // STD!
+ TeststringInvariant(this);
return append(x.substr(pos, n));
}
-lyxstring & lyxstring::append(value_type const * p, size_type n)
+string & string::append(value_type const * p, size_type n)
{
- lyx::Assert(p); // OURS!
- TestlyxstringInvariant(this);
+ Assert(p); // OURS!
+ TeststringInvariant(this);
if (!*p || !n) return *this;
rep = rep->get_own_copy();
}
-lyxstring & lyxstring::append(value_type const * p)
+string & string::append(value_type const * p)
{
- lyx::Assert(p); // OURS!
+ Assert(p); // OURS!
return append(p, strlen(p));
}
-lyxstring & lyxstring::append(size_type n, value_type c)
+string & string::append(size_type n, value_type c)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
value_type * tmp = new value_type[n];
memset(tmp, c, n);
}
-lyxstring & lyxstring::append(iterator first, iterator last)
+string & string::append(iterator first, iterator last)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
rep = rep->get_own_copy();
rep->append(last - first, first);
// insert characters before (*this)[pos]
-lyxstring & lyxstring::insert(size_type pos, lyxstring const & x)
+string & string::insert(size_type pos, string const & x)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
return insert(pos, x, 0, x.rep->sz);
}
-lyxstring & lyxstring::insert(size_type pos, lyxstring const & x,
+string & string::insert(size_type pos, string const & x,
size_type pos2, size_type n)
{
- lyx::Assert(pos <= rep->sz && pos2 <= x.rep->sz); // STD!
- TestlyxstringInvariant(this);
+ Assert(pos <= rep->sz && pos2 <= x.rep->sz); // STD!
+ TeststringInvariant(this);
rep = rep->get_own_copy();
rep->insert(pos, &(x.rep->s[pos2]), min(n, x.rep->sz));
}
-lyxstring & lyxstring::insert(size_type pos, value_type const * p, size_type n)
+string & string::insert(size_type pos, value_type const * p, size_type n)
{
- lyx::Assert(p); // OURS!
- TestlyxstringInvariant(this);
+ Assert(p); // OURS!
+ TeststringInvariant(this);
if (*p && n) {
// insert nothing and you change nothing
}
-lyxstring & lyxstring::insert(size_type pos, value_type const * p)
+string & string::insert(size_type pos, value_type const * p)
{
- lyx::Assert(p); // OURS!
+ Assert(p); // OURS!
return insert(pos, p, strlen(p));
}
-lyxstring & lyxstring::insert(size_type pos, size_type n, value_type c)
+string & string::insert(size_type pos, size_type n, value_type c)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
rep = rep->get_own_copy();
value_type * tmp = new value_type[n];
}
-lyxstring::iterator lyxstring::insert(iterator p, value_type c)
+string::iterator string::insert(iterator p, value_type c)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
// what iterator is this supposed to return??
size_type tmp = p - begin();
}
-void lyxstring::insert(iterator p, size_type n , value_type c)
+void string::insert(iterator p, size_type n , value_type c)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
insert(p - begin(), n , c);
}
-void lyxstring::insert(iterator p, iterator first, iterator last)
+void string::insert(iterator p, iterator first, iterator last)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
insert(p - begin(), first, last - first);
}
// some of the parameters wrong, also some of the funcs can surely
// be written more effectively.
-lyxstring::size_type lyxstring::find(lyxstring const & a, size_type i) const
+string::size_type string::find(string const & a, size_type i) const
{
if (!rep->sz || i >= rep->sz) return npos;
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
size_type n = a.length();
if (!n) return npos;
}
-lyxstring::size_type lyxstring::find(value_type const * ptr, size_type i,
+string::size_type string::find(value_type const * ptr, size_type i,
size_type n) const
{
- lyx::Assert(ptr); // OURS!
+ Assert(ptr); // OURS!
if (!rep->sz || !*ptr || i >= rep->sz) return npos;
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
// What is "n" here? is it the number of value_types to use in ptr
// or does "i" and "n" togeter form a substring to search
}
-lyxstring::size_type lyxstring::find(value_type const * s, size_type i) const
+string::size_type string::find(value_type const * s, size_type i) const
{
- lyx::Assert(s); // OURS!
+ Assert(s); // OURS!
if (!rep->sz || i >= rep->sz) return npos;
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
if (!s || !*s) return npos;
return find(s, i, strlen(s));
}
-lyxstring::size_type lyxstring::find(value_type c, size_type i) const
+string::size_type string::find(value_type c, size_type i) const
{
if (!rep->sz || i >= rep->sz) return npos;
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
for (size_type t = 0; t + i < rep->sz; ++t) {
if (rep->s[t + i] == c) return t + i;
}
-lyxstring::size_type lyxstring::rfind(lyxstring const & a, size_type i) const
+string::size_type string::rfind(string const & a, size_type i) const
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
size_type n = a.length();
if (!n || rep->sz < n)
}
-lyxstring::size_type lyxstring::rfind(value_type const * ptr, size_type i,
+string::size_type string::rfind(value_type const * ptr, size_type i,
size_type n) const
{
- lyx::Assert(ptr); // OURS!
- TestlyxstringInvariant(this);
+ Assert(ptr); // OURS!
+ TeststringInvariant(this);
n = min(n, strlen(ptr));
if (!n || rep->sz < n)
}
-lyxstring::size_type lyxstring::rfind(value_type const * ptr,
+string::size_type string::rfind(value_type const * ptr,
size_type i) const
{
- lyx::Assert(ptr); // OURS!
+ Assert(ptr); // OURS!
if (!ptr || !*ptr) return npos;
return rfind(ptr, i, strlen(ptr));
}
-lyxstring::size_type lyxstring::rfind(value_type c, size_type i) const
+string::size_type string::rfind(value_type c, size_type i) const
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
size_type const sz = rep->sz;
if (sz < 1) return npos;
}
-lyxstring::size_type lyxstring::find_first_of(lyxstring const & a,
+string::size_type string::find_first_of(string const & a,
size_type i) const
{
- lyx::Assert(i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(i <= rep->sz); // OURS!
+ TeststringInvariant(this);
for (size_type t = i; t < rep->sz; ++t) {
if (a.find(rep->s[t]) != npos) return t;
}
-lyxstring::size_type lyxstring::find_first_of(value_type const * ptr,
+string::size_type string::find_first_of(value_type const * ptr,
size_type i,
size_type n) const
{
- lyx::Assert(ptr && i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(ptr && i <= rep->sz); // OURS!
+ TeststringInvariant(this);
if (!n) return npos;
for (size_type t = i; t < rep->sz; ++t) {
}
-lyxstring::size_type lyxstring::find_first_of(value_type const * ptr,
+string::size_type string::find_first_of(value_type const * ptr,
size_type i) const
{
- lyx::Assert(ptr && i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(ptr && i <= rep->sz); // OURS!
+ TeststringInvariant(this);
for (size_type t = i; t < rep->sz; ++t) {
if (strchr(ptr, rep->s[t]) != 0) return t;
}
-lyxstring::size_type lyxstring::find_first_of(value_type c, size_type i) const
+string::size_type string::find_first_of(value_type c, size_type i) const
{
- lyx::Assert(i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(i <= rep->sz); // OURS!
+ TeststringInvariant(this);
for (size_type t = i; t < rep->sz; ++t) {
if (rep->s[t] == c) return t;
}
-lyxstring::size_type lyxstring::find_last_of(lyxstring const & a,
+string::size_type string::find_last_of(string const & a,
size_type i) const
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
size_type ii = min(rep->sz - 1, i);
for (int t = ii; t >= 0; --t) {
}
-lyxstring::size_type lyxstring::find_last_of(value_type const * ptr,
+string::size_type string::find_last_of(value_type const * ptr,
size_type i,
size_type n) const
{
- lyx::Assert(ptr); // OURS!
- TestlyxstringInvariant(this);
+ Assert(ptr); // OURS!
+ TeststringInvariant(this);
if (!n) return npos;
size_type ii = min(rep->sz - 1, i);
}
-lyxstring::size_type lyxstring::find_last_of(value_type const * ptr,
+string::size_type string::find_last_of(value_type const * ptr,
size_type i) const
{
- lyx::Assert(ptr); // OURS!
- TestlyxstringInvariant(this);
+ Assert(ptr); // OURS!
+ TeststringInvariant(this);
size_type ii = min(rep->sz - 1, i);
for (int t = ii; t >= 0; --t) {
}
-lyxstring::size_type lyxstring::find_last_of(value_type c, size_type i) const
+string::size_type string::find_last_of(value_type c, size_type i) const
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
if (!rep->sz) return npos;
size_type ii = min(rep->sz - 1, i);
}
-lyxstring::size_type lyxstring::find_first_not_of(lyxstring const & a,
+string::size_type string::find_first_not_of(string const & a,
size_type i) const
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
if (!rep->sz) return npos;
- lyx::Assert(i <= rep->sz);
+ Assert(i <= rep->sz);
for (size_type t = i; t < rep->sz; ++t) {
if (a.find(rep->s[t]) == npos) return t;
}
}
-lyxstring::size_type lyxstring::find_first_not_of(value_type const * ptr,
+string::size_type string::find_first_not_of(value_type const * ptr,
size_type i,
size_type n) const
{
- lyx::Assert(ptr && i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(ptr && i <= rep->sz); // OURS!
+ TeststringInvariant(this);
if (!n) return (i < rep->sz) ? i : npos;
for (size_type t = i; t < rep->sz; ++t) {
}
-lyxstring::size_type lyxstring::find_first_not_of(value_type const * ptr,
+string::size_type string::find_first_not_of(value_type const * ptr,
size_type i) const
{
- lyx::Assert(ptr && i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(ptr && i <= rep->sz); // OURS!
+ TeststringInvariant(this);
for (size_type t = i; t < rep->sz; ++t) {
if (strchr(ptr, rep->s[t]) == 0) return t;
}
-lyxstring::size_type lyxstring::find_first_not_of(value_type c,
+string::size_type string::find_first_not_of(value_type c,
size_type i) const
{
if (!rep->sz) return npos;
- lyx::Assert(i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(i <= rep->sz); // OURS!
+ TeststringInvariant(this);
for (size_type t = i; t < rep->sz; ++t) {
if (rep->s[t] != c) return t;
}
-lyxstring::size_type lyxstring::find_last_not_of(lyxstring const & a,
+string::size_type string::find_last_not_of(string const & a,
size_type i) const
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
size_type ii = min(rep->sz - 1, i);
for (int t = ii; t >= 0; --t) {
}
-lyxstring::size_type lyxstring::find_last_not_of(value_type const * ptr,
+string::size_type string::find_last_not_of(value_type const * ptr,
size_type i,
size_type n) const
{
- lyx::Assert(ptr); // OURS!
- TestlyxstringInvariant(this);
+ Assert(ptr); // OURS!
+ TeststringInvariant(this);
if (!n) return npos;
size_type ii = min(rep->sz - 1, i);
}
-lyxstring::size_type lyxstring::find_last_not_of(value_type const * ptr,
+string::size_type string::find_last_not_of(value_type const * ptr,
size_type i) const
{
- lyx::Assert(ptr); // OURS!
- TestlyxstringInvariant(this);
+ Assert(ptr); // OURS!
+ TeststringInvariant(this);
size_type ii = min(rep->sz - 1, i);
for (int t = ii; t >= 0; --t) {
}
-lyxstring::size_type lyxstring::find_last_not_of(value_type c,
+string::size_type string::find_last_not_of(value_type c,
size_type i) const
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
size_type ii = min(rep->sz - 1, i);
for (int t = ii; t >= 0; --t) {
// Replace
/////////////////
-lyxstring & lyxstring::replace(size_type i, size_type n, lyxstring const & x)
+string & string::replace(size_type i, size_type n, string const & x)
{
- lyx::Assert(i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(i <= rep->sz); // OURS!
+ TeststringInvariant(this);
return replace(i, n, x, 0, x.rep->sz);
}
-lyxstring & lyxstring::replace(size_type i, size_type n, lyxstring const & x,
+string & string::replace(size_type i, size_type n, string const & x,
size_type i2, size_type n2)
{
- lyx::Assert(i <= rep->sz && i2 <= x.rep->sz); // STD!
- TestlyxstringInvariant(this);
+ Assert(i <= rep->sz && i2 <= x.rep->sz); // STD!
+ TeststringInvariant(this);
rep = rep->get_own_copy();
rep->replace(i, min(n, rep->sz), &(x.rep->s[i2]), min(n2, x.rep->sz));
}
-lyxstring & lyxstring::replace(size_type i, size_type n,
+string & string::replace(size_type i, size_type n,
value_type const * p, size_type n2)
{
- lyx::Assert(p && i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(p && i <= rep->sz); // OURS!
+ TeststringInvariant(this);
rep = rep->get_own_copy();
rep->replace(i, min(n, rep->sz), p, min(n2, strlen(p)));
}
-lyxstring & lyxstring::replace(size_type i, size_type n, value_type const * p)
+string & string::replace(size_type i, size_type n, value_type const * p)
{
- lyx::Assert(p && i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(p && i <= rep->sz); // OURS!
+ TeststringInvariant(this);
return replace(i, min(n, rep->sz), p, (!p) ? 0 : strlen(p));
}
-lyxstring & lyxstring::replace(size_type i, size_type n,
+string & string::replace(size_type i, size_type n,
size_type n2, value_type c)
{
- lyx::Assert(i <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(i <= rep->sz); // OURS!
+ TeststringInvariant(this);
rep = rep->get_own_copy();
value_type * tmp = new value_type[n2];
/// FY! FY! FY! go away !
-lyxstring & lyxstring::replace(size_type i, size_type n, value_type c)
+string & string::replace(size_type i, size_type n, value_type c)
{
return replace(i, n, 1, c);
}
-lyxstring & lyxstring::replace(iterator i, iterator i2, const lyxstring & str)
+string & string::replace(iterator i, iterator i2, const string & str)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
return replace(i - begin(), i2 - i, str);
}
-lyxstring & lyxstring::replace(iterator i, iterator i2,
+string & string::replace(iterator i, iterator i2,
value_type const * p, size_type n)
{
- lyx::Assert(p); // OURS!
- TestlyxstringInvariant(this);
+ Assert(p); // OURS!
+ TeststringInvariant(this);
return replace(i - begin(), i2 - i, p, n);
}
-lyxstring & lyxstring::replace(iterator i, iterator i2, value_type const * p)
+string & string::replace(iterator i, iterator i2, value_type const * p)
{
- lyx::Assert(p); // OURS!
- TestlyxstringInvariant(this);
+ Assert(p); // OURS!
+ TeststringInvariant(this);
return replace(i - begin(), i2 - i, p);
}
-lyxstring & lyxstring::replace(iterator i, iterator i2,
+string & string::replace(iterator i, iterator i2,
size_type n , value_type c)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
return replace(i - begin(), i2 - i, n, c);
}
-lyxstring & lyxstring::replace(iterator i, iterator i2,
+string & string::replace(iterator i, iterator i2,
iterator j, iterator j2)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
return replace(i - begin(), i2 - i, j, j2 - j);
}
-void lyxstring::swap(lyxstring & str)
+void string::swap(string & str)
{
if (rep == str.rep) return;
Srep * tmp = str.rep;
}
-lyxstring & lyxstring::erase(size_type i, size_type n)
+string & string::erase(size_type i, size_type n)
{
- lyx::Assert(i <= rep->sz); // STD!
- TestlyxstringInvariant(this);
+ Assert(i <= rep->sz); // STD!
+ TeststringInvariant(this);
rep = rep->get_own_copy();
if (i == 0 && n >= rep->sz) {
}
-lyxstring::iterator lyxstring::erase(iterator i)
+string::iterator string::erase(iterator i)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
// what iterator is this supposed to return?
// the iterator after the one erased
}
-lyxstring::iterator lyxstring::erase(iterator first, iterator last)
+string::iterator string::erase(iterator first, iterator last)
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
erase(first - begin(), last - first);
return begin(); // BUG
// Conversion to C-style Strings
/////////////////////////////////////
-lyxstring::value_type const * lyxstring::c_str() const
+string::value_type const * string::c_str() const
{
rep->s[length()] = '\0';
return rep->s;
}
-lyxstring::value_type const * lyxstring::data() const
+string::value_type const * string::data() const
{
return rep->s;
}
-lyxstring::size_type lyxstring::copy(value_type * buf, size_type len,
+string::size_type string::copy(value_type * buf, size_type len,
size_type pos) const
{
- lyx::Assert(buf); // OURS!
- lyx::Assert(pos <= rep->sz); // STD!
- TestlyxstringInvariant(this);
+ Assert(buf); // OURS!
+ Assert(pos <= rep->sz); // STD!
+ TeststringInvariant(this);
register int nn = min(len, length() - pos);
memcpy(buf, &(rep->s[pos]), nn);
// Compare funcs should be verified.
-int lyxstring::internal_compare(size_type pos, size_type n,
+int string::internal_compare(size_type pos, size_type n,
value_type const * s,
size_type slen, size_type n2) const
{
}
-int lyxstring::compare(lyxstring const & str) const
+int string::compare(string const & str) const
{
- TestlyxstringInvariant(this);
+ TeststringInvariant(this);
return internal_compare(0, rep->sz, str.rep->s,
str.rep->sz, str.rep->sz);
}
-int lyxstring::compare(value_type const * s) const
+int string::compare(value_type const * s) const
{
- lyx::Assert(s); //OURS!
- TestlyxstringInvariant(this);
+ Assert(s); //OURS!
+ TeststringInvariant(this);
int n = (!s) ? 0 : strlen(s);
return internal_compare(0, rep->sz, s, n, n);
}
-int lyxstring::compare(size_type pos, size_type n,
- lyxstring const & str) const
+int string::compare(size_type pos, size_type n,
+ string const & str) const
{
- lyx::Assert(pos <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(pos <= rep->sz); // OURS!
+ TeststringInvariant(this);
return internal_compare(pos, n, str.rep->s, str.rep->sz, str.rep->sz);
}
-int lyxstring::compare(size_type pos, size_type n, lyxstring const & str,
+int string::compare(size_type pos, size_type n, string const & str,
size_type pos2, size_type n2) const
{
- lyx::Assert(pos <= rep->sz); // OURS!
- lyx::Assert(pos2 <= str.rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(pos <= rep->sz); // OURS!
+ Assert(pos2 <= str.rep->sz); // OURS!
+ TeststringInvariant(this);
return internal_compare(pos, n,
str.rep->s + pos2,
str.rep->sz - pos2, n2);
}
-int lyxstring::compare(size_type pos, size_type n, value_type const * s,
+int string::compare(size_type pos, size_type n, value_type const * s,
size_type n2) const
{
- lyx::Assert(s && pos <= rep->sz); // OURS!
- TestlyxstringInvariant(this);
+ Assert(s && pos <= rep->sz); // OURS!
+ TeststringInvariant(this);
return internal_compare(pos, n, s, (!s) ? 0 : strlen(s), n2);
}
/////////////////
// i = index, n = length
-lyxstring lyxstring::substr(size_type i, size_type n) const
+string string::substr(size_type i, size_type n) const
{
- lyx::Assert(i <= rep->sz); // STD!
- TestlyxstringInvariant(this);
+ Assert(i <= rep->sz); // STD!
+ TeststringInvariant(this);
- return lyxstring(*this, i, n);
+ return string(*this, i, n);
}
// String operators, non member functions
/////////////////////////////////////////////
-bool operator==(lyxstring const & a, lyxstring const & b)
+bool operator==(string const & a, string const & b)
{
return a.compare(b) == 0;
}
-bool operator==(lyxstring::value_type const * a, lyxstring const & b)
+bool operator==(string::value_type const * a, string const & b)
{
- lyx::Assert(a); // OURS!
+ Assert(a); // OURS!
return b.compare(a) == 0;
}
-bool operator==(lyxstring const & a, lyxstring::value_type const * b)
+bool operator==(string const & a, string::value_type const * b)
{
- lyx::Assert(b); // OURS!
+ Assert(b); // OURS!
return a.compare(b) == 0;
}
-bool operator!=(lyxstring const & a, lyxstring const & b)
+bool operator!=(string const & a, string const & b)
{
return a.compare(b) != 0;
}
-bool operator!=(lyxstring::value_type const * a, lyxstring const & b)
+bool operator!=(string::value_type const * a, string const & b)
{
- lyx::Assert(a); // OURS!
+ Assert(a); // OURS!
return b.compare(a) != 0;
}
-bool operator!=(lyxstring const & a, lyxstring::value_type const * b)
+bool operator!=(string const & a, string::value_type const * b)
{
- lyx::Assert(b); // OURS!
+ Assert(b); // OURS!
return a.compare(b) != 0;
}
-bool operator>(lyxstring const & a, lyxstring const & b)
+bool operator>(string const & a, string const & b)
{
return a.compare(b) > 0;
}
-bool operator>(lyxstring::value_type const * a, lyxstring const & b)
+bool operator>(string::value_type const * a, string const & b)
{
- lyx::Assert(a); // OURS!
+ Assert(a); // OURS!
return b.compare(a) < 0; // since we reverse the parameters
}
-bool operator>(lyxstring const & a, lyxstring::value_type const * b)
+bool operator>(string const & a, string::value_type const * b)
{
- lyx::Assert(b); // OURS!
+ Assert(b); // OURS!
return a.compare(b) > 0;
}
-bool operator<(lyxstring const & a, lyxstring const & b)
+bool operator<(string const & a, string const & b)
{
return a.compare(b) < 0;
}
-bool operator<(lyxstring::value_type const * a, lyxstring const & b)
+bool operator<(string::value_type const * a, string const & b)
{
- lyx::Assert(a); // OURS!
+ Assert(a); // OURS!
return b.compare(a) > 0; // since we reverse the parameters
}
-bool operator<(lyxstring const & a, lyxstring::value_type const * b)
+bool operator<(string const & a, string::value_type const * b)
{
- lyx::Assert(b); // OURS!
+ Assert(b); // OURS!
return a.compare(b) < 0;
}
-bool operator>=(lyxstring const & a, lyxstring const & b)
+bool operator>=(string const & a, string const & b)
{
return a.compare(b) >= 0;
}
-bool operator>=(lyxstring::value_type const * a, lyxstring const & b)
+bool operator>=(string::value_type const * a, string const & b)
{
- lyx::Assert(a); // OURS!
+ Assert(a); // OURS!
return b.compare(a) <= 0; // since we reverse the parameters
}
-bool operator>=(lyxstring const & a, lyxstring::value_type const * b)
+bool operator>=(string const & a, string::value_type const * b)
{
- lyx::Assert(b); // OURS!
+ Assert(b); // OURS!
return a.compare(b) >= 0;
}
-bool operator<=(lyxstring const & a, lyxstring const & b)
+bool operator<=(string const & a, string const & b)
{
return a.compare(b) <= 0;
}
-bool operator<=(lyxstring::value_type const * a, lyxstring const & b)
+bool operator<=(string::value_type const * a, string const & b)
{
- lyx::Assert(a); // OURS!
+ Assert(a); // OURS!
return b.compare(a) >= 0; // since we reverse the parameters
}
-bool operator<=(lyxstring const & a, lyxstring::value_type const * b)
+bool operator<=(string const & a, string::value_type const * b)
{
- lyx::Assert(b); // OURS!
+ Assert(b); // OURS!
return a.compare(b) <= 0;
}
-lyxstring operator+(lyxstring const & a, lyxstring const & b)
+string operator+(string const & a, string const & b)
{
- lyxstring tmp(a);
+ string tmp(a);
tmp += b;
return tmp;
}
-lyxstring operator+(lyxstring::value_type const * a, lyxstring const & b)
+string operator+(string::value_type const * a, string const & b)
{
- lyx::Assert(a); // OURS!
- lyxstring tmp(a);
+ Assert(a); // OURS!
+ string tmp(a);
tmp += b;
return tmp;
}
-lyxstring operator+(lyxstring::value_type a, lyxstring const & b)
+string operator+(string::value_type a, string const & b)
{
- lyxstring tmp;
+ string tmp;
tmp += a;
tmp += b;
return tmp;
}
-lyxstring operator+(lyxstring const & a, lyxstring::value_type const * b)
+string operator+(string const & a, string::value_type const * b)
{
- lyx::Assert(b); // OURS!
- lyxstring tmp(a);
+ Assert(b); // OURS!
+ string tmp(a);
tmp += b;
return tmp;
}
-lyxstring operator+(lyxstring const & a, lyxstring::value_type b)
+string operator+(string const & a, string::value_type b)
{
- lyxstring tmp(a);
+ string tmp(a);
tmp += b;
return tmp;
}
-void swap(lyxstring & str1, lyxstring & str2)
+void swap(string & str1, string & str2)
{
str1.swap(str2);
}
-#include <iostream>
-
-istream & operator>>(istream & is, lyxstring & s)
+istream & operator>>(istream & is, string & s)
{
#if 0
// very bad solution
char * nome = new char[1024];
is >> nome;
- lyxstring tmp(nome);
+ string tmp(nome);
delete [] nome;
if (!tmp.empty()) s = tmp;
#else
}
-ostream & operator<<(ostream & o, lyxstring const & s)
+ostream & operator<<(ostream & o, string const & s)
{
return o.write(s.data(), s.length());
}
-istream & getline(istream & is, lyxstring & s,
- lyxstring::value_type delim)
+istream & getline(istream & is, string & s,
+ string::value_type delim)
{
// very bad solution
char tmp = 0;
return is;
}
+} // namespace lyx
+
#ifdef TEST_MAIN
int main() {
- lyxstring a = "abcac";
+ lyx::string a = "abcac";
cout << a.rfind("ab") << endl;
cout << a.rfind("c") << endl;
cout << a.rfind("d") << endl;
#include <cstring> // for size_t
+namespace lyx {
+
/** A string class for LyX
This is a permanent String class. It is modeled closely after the C++ STL
The class automatically handles deep copying when required.
*/
-class lyxstring {
+class string {
public:
/* Typedefs */
/// "all characters" marker
static const size_type npos;
- /// #lyxstring x;#
- lyxstring();
+ /// #string x;#
+ string();
- /// #lyxstring x(lyxstring ...)#
- lyxstring(lyxstring const &, size_type pos = 0, size_type n = npos);
+ /// #string x(string ...)#
+ string(string const &, size_type pos = 0, size_type n = npos);
- /// #lyxstring x("abc", 2) -> "ab"#
- lyxstring(value_type const *, size_type n);
+ /// #string x("abc", 2) -> "ab"#
+ string(value_type const *, size_type n);
- // #lyxstring x("abc")#
- lyxstring(value_type const *);
+ // #string x("abc")#
+ string(value_type const *);
- /// lyxstring(5, 'n') -> "nnnnn"
- lyxstring(size_type n, value_type c);
+ /// string(5, 'n') -> "nnnnn"
+ string(size_type n, value_type c);
#if 0
///
- lyxstring(const_iterator first, const_iterator last);
+ string(const_iterator first, const_iterator last);
#else
///
template<class InputIterator>
- lyxstring::lyxstring(InputIterator begin, InputIterator end) {
+ string(InputIterator begin, InputIterator end) {
while (begin != end) {
push_back(*begin);
++begin;
}
#endif
///
- ~lyxstring();
+ ~string();
/// number of characters
size_type size() const;
void reserve(size_type res_arg = 0);
///
- lyxstring & operator=(lyxstring const &);
+ string & operator=(string const &);
///
- lyxstring & operator=(value_type const *);
+ string & operator=(value_type const *);
///
- lyxstring & operator=(value_type);
+ string & operator=(value_type);
///
- lyxstring & assign(lyxstring const &);
+ string & assign(string const &);
///
- lyxstring & assign(lyxstring const &, size_type pos, size_type n);
+ string & assign(string const &, size_type pos, size_type n);
///
- lyxstring & assign(value_type const * p, size_type n);
+ string & assign(value_type const * p, size_type n);
///
- lyxstring & assign(value_type const * p);
+ string & assign(value_type const * p);
///
- lyxstring & assign(size_type n, value_type c);
+ string & assign(size_type n, value_type c);
#if 1
///
- lyxstring & assign(const_iterator first, const_iterator last);
+ string & assign(const_iterator first, const_iterator last);
#else
///
template<class InputIterator>
- lyxstring & assign(InputIterator begin, InputIterator end) {
+ string & assign(InputIterator begin, InputIterator end) {
clear;
while (begin != end) {
push_back((*begin));
// add characters after (*this)[length()-1]:
///
- lyxstring & operator+=(lyxstring const &);
+ string & operator+=(string const &);
///
- lyxstring & operator+=(value_type const *);
+ string & operator+=(value_type const *);
///
- lyxstring & operator+=(value_type);
+ string & operator+=(value_type);
///
void push_back(value_type);
///
- lyxstring & append(lyxstring const &);
+ string & append(string const &);
///
- lyxstring & append(lyxstring const &, size_type pos, size_type n);
+ string & append(string const &, size_type pos, size_type n);
///
- lyxstring & append(value_type const *, size_type n);
+ string & append(value_type const *, size_type n);
///
- lyxstring & append(value_type const *);
+ string & append(value_type const *);
///
- lyxstring & append(size_type n, value_type);
+ string & append(size_type n, value_type);
#if 1
///
- lyxstring & append(iterator first, iterator last);
+ string & append(iterator first, iterator last);
#else
///
template<class InputIterator>
- lyxstring & append(InputIterator begin, InputIterator end) {
+ string & append(InputIterator begin, InputIterator end) {
while (begin != end) {
push_back((*begin));
++begin;
// insert characters before (*this)[pos]:
///
- lyxstring & insert(size_type pos, lyxstring const &);
+ string & insert(size_type pos, string const &);
///
- lyxstring & insert(size_type pos, lyxstring const &,
+ string & insert(size_type pos, string const &,
size_type pos2, size_type n);
///
- lyxstring & insert(size_type pos, value_type const * p,
+ string & insert(size_type pos, value_type const * p,
size_type n);
///
- lyxstring & insert(size_type pos, value_type const * p);
+ string & insert(size_type pos, value_type const * p);
///
- lyxstring & insert(size_type pos, size_type n, value_type c);
+ string & insert(size_type pos, size_type n, value_type c);
// insert characters before p
#endif
///
- size_type find(lyxstring const &, size_type i = 0) const;
+ size_type find(string const &, size_type i = 0) const;
///
size_type find(value_type const * p,
size_type find(value_type c, size_type i = 0) const;
///
- size_type rfind(lyxstring const &, size_type i = npos) const;
+ size_type rfind(string const &, size_type i = npos) const;
///
size_type rfind(value_type const * p, size_type i, size_type n) const;
size_type rfind(value_type c, size_type i = npos) const;
///
- size_type find_first_of(lyxstring const &, size_type i = 0) const;
+ size_type find_first_of(string const &, size_type i = 0) const;
///
size_type find_first_of(value_type const * p, size_type i,
size_type find_first_of(value_type c, size_type i = 0) const;
///
- size_type find_last_of(lyxstring const &, size_type i = npos) const;
+ size_type find_last_of(string const &, size_type i = npos) const;
///
size_type find_last_of(value_type const * p, size_type i,
size_type find_last_of(value_type c, size_type i = npos) const;
///
- size_type find_first_not_of(lyxstring const &, size_type i = 0) const;
+ size_type find_first_not_of(string const &, size_type i = 0) const;
///
size_type find_first_not_of(value_type const * p, size_type i,
size_type find_first_not_of(value_type c, size_type i = 0) const;
///
- size_type find_last_not_of(lyxstring const &,
+ size_type find_last_not_of(string const &,
size_type i = npos) const;
///
// replace [(*this)[i], (*this)[i+n]] with other characters:
///
- lyxstring & replace(size_type i, size_type n, lyxstring const & str);
+ string & replace(size_type i, size_type n, string const & str);
///
- lyxstring & replace(size_type i, size_type n, lyxstring const & s,
+ string & replace(size_type i, size_type n, string const & s,
size_type i2, size_type n2);
///
- lyxstring & replace(size_type i, size_type n, value_type const * p,
+ string & replace(size_type i, size_type n, value_type const * p,
size_type n2);
///
- lyxstring & replace(size_type i, size_type n, value_type const * p);
+ string & replace(size_type i, size_type n, value_type const * p);
///
- lyxstring & replace(size_type i, size_type n,
+ string & replace(size_type i, size_type n,
size_type n2, value_type c);
/// FY! FY! FY! go away !
- lyxstring & replace(size_type i, size_type n,
+ string & replace(size_type i, size_type n,
value_type c);
///
- lyxstring & replace(iterator i, iterator i2, const lyxstring & str);
+ string & replace(iterator i, iterator i2, const string & str);
///
- lyxstring & replace(iterator i, iterator i2,
+ string & replace(iterator i, iterator i2,
value_type const * p, size_type n);
///
- lyxstring & replace(iterator i, iterator i2, value_type const * p);
+ string & replace(iterator i, iterator i2, value_type const * p);
///
- lyxstring & replace(iterator i, iterator i2,
+ string & replace(iterator i, iterator i2,
size_type n , value_type c);
///
- lyxstring & replace(iterator i, iterator i2, iterator j, iterator j2);
+ string & replace(iterator i, iterator i2, iterator j, iterator j2);
///
- void swap(lyxstring & str);
+ void swap(string & str);
/// Erase n chars from position i.
- lyxstring & erase(size_type i = 0, size_type n = npos);
+ string & erase(size_type i = 0, size_type n = npos);
///
- lyxstring & clear() {
+ string & clear() {
return erase(0, npos);
}
///
- int compare(lyxstring const & str) const;
+ int compare(string const & str) const;
///
int compare(value_type const * p) const;
///
- int compare(size_type pos, size_type n, lyxstring const & str) const;
+ int compare(size_type pos, size_type n, string const & str) const;
///
- int compare(size_type pos, size_type n, lyxstring const & str,
+ int compare(size_type pos, size_type n, string const & str,
size_type pos2, size_type n2) const;
///
///
- lyxstring substr(size_type i = 0, size_type n = npos) const;
+ string substr(size_type i = 0, size_type n = npos) const;
private:
// These three operators can be used to discover erronous use of
// in. Use them for debugging only (or perhaps not even then.)
// Lgb.
//
- //lyxstring & operator+(int);
+ //string & operator+(int);
//
- //lyxstring & operator=(int);
+ //string & operator=(int);
//
- //lyxstring & operator+=(int);
+ //string & operator+=(int);
/// Compare this with s. works with embedded '\0' chars also.
int internal_compare(size_type pos, size_type n,
Srep * rep;
/* Note: The empty_rep is a local static in each function that
- benefits from one. There is no "global" empty srep but lyxstring
+ benefits from one. There is no "global" empty srep but string
doesn't need one (no code actually relies upon a single
empty srep).
This overcomes *all* "static initialization" problems,
#ifdef ENABLE_ASSERTIONS
/// lyxstringInvariant is used to test the lyxstring Invariant
- friend class lyxstringInvariant;
+ friend class stringInvariant;
#endif
};
// The usual comparison operators ==, !=, >, <, >=, <= are
// provided for lyxstrings
-bool operator==(lyxstring const &, lyxstring const &);
-bool operator==(lyxstring::value_type const *, lyxstring const &);
-bool operator==(lyxstring const &, lyxstring::value_type const *);
+bool operator==(string const &, string const &);
+bool operator==(string::value_type const *, string const &);
+bool operator==(string const &, string::value_type const *);
-bool operator!=(lyxstring const &, lyxstring const &);
-bool operator!=(lyxstring::value_type const *, lyxstring const &);
-bool operator!=(lyxstring const &, lyxstring::value_type const *);
+bool operator!=(string const &, string const &);
+bool operator!=(string::value_type const *, string const &);
+bool operator!=(string const &, string::value_type const *);
-bool operator>(lyxstring const &, lyxstring const &);
-bool operator>(lyxstring::value_type const *, lyxstring const &);
-bool operator>(lyxstring const &, lyxstring::value_type const *);
+bool operator>(string const &, string const &);
+bool operator>(string::value_type const *, string const &);
+bool operator>(string const &, string::value_type const *);
-bool operator<(lyxstring const &, lyxstring const &);
-bool operator<(lyxstring::value_type const *, lyxstring const &);
-bool operator<(lyxstring const &, lyxstring::value_type const *);
+bool operator<(string const &, string const &);
+bool operator<(string::value_type const *, string const &);
+bool operator<(string const &, string::value_type const *);
-bool operator>=(lyxstring const &, lyxstring const &);
-bool operator>=(lyxstring::value_type const *, lyxstring const &);
-bool operator>=(lyxstring const &, lyxstring::value_type const *);
+bool operator>=(string const &, string const &);
+bool operator>=(string::value_type const *, string const &);
+bool operator>=(string const &, string::value_type const *);
-bool operator<=(lyxstring const &, lyxstring const &);
-bool operator<=(lyxstring::value_type const *, lyxstring const &);
-bool operator<=(lyxstring const &, lyxstring::value_type const *);
+bool operator<=(string const &, string const &);
+bool operator<=(string::value_type const *, string const &);
+bool operator<=(string const &, string::value_type const *);
// Concatenation
-lyxstring operator+(lyxstring const & a, lyxstring const & b);
-lyxstring operator+(char const * a, lyxstring const & b);
-lyxstring operator+(lyxstring::value_type a, lyxstring const & b);
-lyxstring operator+(lyxstring const & a, lyxstring::value_type const * b);
-lyxstring operator+(lyxstring const & a, lyxstring::value_type b);
+string operator+(string const & a, string const & b);
+string operator+(char const * a, string const & b);
+string operator+(string::value_type a, string const & b);
+string operator+(string const & a, string::value_type const * b);
+string operator+(string const & a, string::value_type b);
+
+void swap(string & s1, string & s2);
-void swap(lyxstring & s1, lyxstring & s2);
+std::istream & operator>>(std::istream &, string &);
+std::ostream & operator<<(std::ostream &, string const &);
+std::istream & getline(std::istream &, string &, string::value_type delim = '\n');
-std::istream & operator>>(std::istream &, lyxstring &);
-std::ostream & operator<<(std::ostream &, lyxstring const &);
-std::istream & getline(std::istream &, lyxstring &, lyxstring::value_type delim = '\n');
+} // namespace lyx
#endif
#include <sys/mman.h>
-unsigned long lyx::sum(string const & file)
+unsigned long lyx::support::sum(string const & file)
{
lyxerr[Debug::FILES] << "lyx::sum() using mmap (lightning fast)"
<< endl;
using std::ifstream;
using std::istreambuf_iterator;
-unsigned long lyx::sum(string const & file)
+unsigned long lyx::support::sum(string const & file)
{
lyxerr[Debug::FILES] << "lyx::sum() using istreambuf_iterator (fast)"
<< endl;
using std::istream_iterator;
using std::ios;
-unsigned long lyx::sum(string const & file)
+unsigned long lyx::support::sum(string const & file)
{
lyxerr[Debug::FILES]
<< "lyx::sum() using istream_iterator (slow as a snail)"
#include "lyxlib.h"
-int lyx::mkdir(string const & pathname, unsigned long int mode)
+int lyx::support::mkdir(string const & pathname, unsigned long int mode)
{
// FIXME: why don't we have mode_t in lyx::mkdir prototype ??
return ::mkdir(pathname.c_str(), mode_t(mode));
#include "LString.h"
/// wrap OS specific stuff
+namespace lyx {
+namespace support {
namespace os {
- //
- enum shell_type {
- UNIX, // Do we have to distinguish sh and csh?
- CMD_EXE
- };
- // do some work just once
- void init(int * argc, char ** argv[]);
- // returns path of LyX binary
- string binpath();
- // returns name of LyX binary
- string binname();
- // system_tempdir actually doesn't belong here
- // I put it here only to avoid a global variable.
- void setTmpDir(string const & p);
- //
- string getTmpDir();
- //
- string current_root();
- //
- shell_type shell();
- // DBCS aware!
- string::size_type common_path(string const & p1, string const & p2);
- // no-op on UNIX, '\\'->'/' on OS/2 and Win32, ':'->'/' on MacOS, etc.
- string slashify_path(string const & p);
- // converts a host OS path to unix style
- string external_path(string const & p);
- // converts a unix path to host OS style
- string internal_path(string const & p);
- // is path absolute?
- bool is_absolute_path(string const & p);
- // returns a string suitable to be passed to popen when
- // same for popen().
+//
+enum shell_type {
+ UNIX, // Do we have to distinguish sh and csh?
+ CMD_EXE
+};
+
+// do some work just once
+void init(int * argc, char ** argv[]);
+// returns path of LyX binary
+string binpath();
+// returns name of LyX binary
+string binname();
+// system_tempdir actually doesn't belong here
+// I put it here only to avoid a global variable.
+void setTmpDir(string const & p);
+//
+string getTmpDir();
+//
+string current_root();
+//
+shell_type shell();
+// DBCS aware!
+string::size_type common_path(string const & p1, string const & p2);
+// no-op on UNIX, '\\'->'/' on OS/2 and Win32, ':'->'/' on MacOS, etc.
+string slashify_path(string const & p);
+// converts a host OS path to unix style
+string external_path(string const & p);
+// converts a unix path to host OS style
+string internal_path(string const & p);
+// is path absolute?
+bool is_absolute_path(string const & p);
+// returns a string suitable to be passed to popen when
+// same for popen().
char const * popen_read_mode();
- //
- void warn(string const & mesg);
-}
+//
+void warn(string const & mesg);
+
+} // namespace os
+} // namespace support
+} // namespace lyx
#endif
}
-
+namespace lyx {
+namespace support {
namespace os {
void init(int * /*argc*/, char ** argv[])
return UNIX;
}
-} // end namespace os
+} // namespace os
+} // namespace support
+} // namespace lyx
#include "path.h"
+namespace lyx {
+namespace support {
+
int Path::pop()
{
if (popped_) {
return 0;
}
- if (lyx::chdir(pushedDir_)) {
+ if (chdir(pushedDir_)) {
// should throw an exception
// throw DirChangeError();
}
return 0;
}
+
+} // namespace support
+} // namespace lyx
#include "lyxlib.h"
#include <boost/utility.hpp>
+namespace lyx {
+namespace support {
+
/**
* Path - utility closs for stackable working directories
*
: popped_(false)
{
if (!path.empty()) {
- pushedDir_ = lyx::getcwd();
- if (pushedDir_.empty() || lyx::chdir(path))
+ pushedDir_ = getcwd();
+ if (pushedDir_.empty() || chdir(path))
/* FIXME: throw */;
} else {
popped_ = true;
#define Path(x) unnamed_Path;
// Tip gotten from Bobby Schmidt's column in C/C++ Users Journal
+} // namespace support
+} // namespace lyx
+
#endif // PATH_H
#include <cstdlib>
-int lyx::putenv(char const * str)
+int lyx::support::putenv(char const * str)
{
return ::putenv(const_cast<char*>(str));
}
#include "support/lyxlib.h"
-bool lyx::rename(string const & from, string const & to)
+bool lyx::support::rename(string const & from, string const & to)
{
#ifdef __EMX__
- lyx::unlink(to.c_str());
+ unlink(to);
#endif
if (::rename(from.c_str(), to.c_str()) == -1)
- if (lyx::copy(from, to)) {
- lyx::unlink(from);
+ if (copy(from, to)) {
+ unlink(from);
return true;
} else
return false;
#include "lyxlib.h"
-int lyx::rmdir(string const & dir)
+int lyx::support::rmdir(string const & dir)
{
return ::rmdir(dir.c_str());
}
using std::system;
#endif
+namespace lyx {
+namespace support {
+
// Reuse of instance
int Systemcall::startscript(Starttype how, string const & what)
{
return ::system(command.c_str());
}
+
+} // namespace support
+} // namespace lyx
#include "LString.h"
+namespace lyx {
+namespace support {
+
/**
* An instance of Class Systemcall represents a single child process.
*
int startscript(Starttype how, string const & what);
};
+} // namespace support
+} // namespace lyx
+
#endif // SYSTEMCALL_H
using std::endl;
-
namespace {
inline
} // namespace anon
-string const lyx::tempName(string const & dir, string const & mask)
+string const lyx::support::tempName(string const & dir, string const & mask)
{
string const tmpdir(dir.empty() ? os::getTmpDir() : dir);
string tmpfl(AddName(tmpdir, mask));
/// Find the mapping for the first argument
T2 const & find(T1 const & first) const {
- lyx::Assert(!map.empty());
+ Assert(!map.empty());
// For explanation see the next find() function.
typename Map::const_iterator it =
/// Find the mapping for the second argument
T1 const & find(T2 const & second) const {
- lyx::Assert(!map.empty());
+ Assert(!map.empty());
// The idea is as follows:
// find_if() will try to compare the data in the vector with
#include "lyxlib.h"
-int lyx::unlink(string const & pathname)
+int lyx::support::unlink(string const & pathname)
{
return ::unlink(pathname.c_str());
}
#include <sys/types.h>
namespace lyx {
+namespace support {
string const user_name()
{
struct passwd * pw(getpwuid(geteuid()));
- lyx::Assert(pw);
+ Assert(pw);
string name = pw->pw_gecos;
if (name.empty())
return email;
}
-
+} // namespace support
} // namespace lyx
#include "LString.h"
namespace lyx {
+namespace support {
/// return the current user's real name
string const user_name();
/// return the current user's e-mail address
string const user_email();
-}; // namespace lyx
+} // namespace support
+} // namespace lyx
#endif // USERINFO_H
#include <algorithm>
#include <cstdlib>
+using namespace lyx::support;
+
using std::abs;
using std::ostream;
using std::istream;
// If this and lt is not of the same size we have a serious bug
// So then it is ok to throw an exception, or for now
// call abort()
- lyx::Assert(rows_ == lt.rows_ && columns_ == lt.columns_);
+ Assert(rows_ == lt.rows_ && columns_ == lt.columns_);
cur_cell = -1;
cell_info = lt.cell_info;
row_info = lt.row_info;
}
-// returns 1 if there is a topline, returns 0 if not
+// returns 1 if there is a topline, returns 0 if not
bool LyXTabular::topLine(int cell, bool onlycolumn) const
{
int const row = row_of_cell(cell);
l_getline(is, line);
if (!prefixIs(line, "<lyxtabular ")
&& !prefixIs(line, "<LyXTabular ")) {
- lyx::Assert(false);
+ Assert(false);
return;
}
int version;
if (!getTokenValue(line, "version", version))
return;
- lyx::Assert(version >= 2);
+ Assert(version >= 2);
int rows_arg;
if (!getTokenValue(line, "rows", rows_arg))
else if (row < 0)
row = 0;
#else
- lyx::Assert(column >= 0 || column < columns_ || row >= 0 || row < rows_);
+ Assert(column >= 0 || column < columns_ || row >= 0 || row < rows_);
#endif
return cell_info[row][column].cellno;
}
#include "support/LIstream.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::strlen;
#endif
#include <algorithm>
+using namespace lyx::support;
+
using std::max;
using std::min;
using std::endl;
BufferView * LyXText::bv()
{
- lyx::Assert(bv_owner != 0);
+ Assert(bv_owner != 0);
return bv_owner;
}
BufferView * LyXText::bv() const
{
- lyx::Assert(bv_owner != 0);
+ Assert(bv_owner != 0);
return bv_owner;
}
ParagraphList::iterator par = std::find(ownerParagraphs().begin(),
ownerParagraphs().end(),
*inset->parOwner());
- //lyx::Assert(par);
+ //Assert(par);
pos_type pos = par->getPositionOfInset(inset);
- lyx::Assert(pos != -1);
+ Assert(pos != -1);
LyXLayout_ptr const & layout = par->layout();
pos_type last = pit->beginningOfBody();
- lyx::Assert(last > 0);
+ Assert(last > 0);
// -1 because a label ends either with a space that is in the label,
// or with the beginning of a footnote that is outside the label.
void LyXText::setHeightOfRow(RowList::iterator rit)
{
- lyx::Assert(rit != rows().end());
+ Assert(rit != rows().end());
// get the maximum ascent and the maximum descent
float layoutasc = 0;
// start at the implicit given position
void LyXText::appendParagraph(RowList::iterator rowit)
{
- lyx::Assert(rowit != rowlist_.end());
+ Assert(rowit != rowlist_.end());
pos_type const last = rowit->par()->size();
bool done = false;
void LyXText::breakAgain(RowList::iterator rit)
{
- lyx::Assert(rit != rows().end());
+ Assert(rit != rows().end());
bool not_ready = true;
// this is just a little changed version of break again
void LyXText::breakAgainOneRow(RowList::iterator rit)
{
- lyx::Assert(rit != rows().end());
+ Assert(rit != rows().end());
pos_type z = rowBreakPoint(*rit);
RowList::iterator tmprit = rit;
#include <boost/tuple/tuple.hpp>
+using namespace lyx::support;
+
using std::vector;
using std::copy;
using std::endl;
LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
pos_type pos) const
{
- lyx::Assert(pos >= 0);
+ Assert(pos >= 0);
LyXLayout_ptr const & layout = pit->layout();
else if (in->lyxCode() == Inset::WRAP_CODE)
type = static_cast<InsetWrap*>(in)->params().type;
else
- lyx::Assert(0);
+ Assert(0);
Floating const & fl = textclass.floats().getType(type);
void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
pos_type pos, bool boundary)
{
- lyx::Assert(pit != ownerParagraphs().end());
+ Assert(pit != ownerParagraphs().end());
cur.par(pit);
cur.pos(pos);
#include <ctime>
#include <clocale>
+using namespace lyx::support;
+
using std::endl;
using std::find;
using std::vector;
return 0;
// get inset dimensions
- lyx::Assert(par->getInset(pos));
+ Assert(par->getInset(pos));
LyXFont const & font = text.getFont(bv->buffer(), par, pos);
}
case LFUN_INSET_SETTINGS:
- lyx::Assert(bv->theLockingInset());
+ Assert(bv->theLockingInset());
bv->theLockingInset()->getLockingInset()->showInsetDialog(bv);
break;
#include "debug.h"
#include "trans_mgr.h"
+using namespace lyx::support;
+
using std::map;
using std::endl;
#include "lyxrc.h"
#include "support/lstrings.h"
+using namespace lyx::support;
+
using std::endl;
using std::pair;
// Set the right(new) inset-owner of the paragraph if there is any.
UpdatableInset * inset =
static_cast<UpdatableInset *>(buf->getInsetFromID(undo.inset_id));
-
+
ParagraphList::iterator pit = undo.pars.begin();
ParagraphList::iterator end = undo.pars.end();
for ( ; pit != end; ++pit)
inset->localDispatch(cmd);
}
}
-
+
if (inset) {
lyxerr << "fit cursor...\n";
bv->fitCursor();
plist = &buf->paragraphs;
// this is what we'd like to have in the end for small grained undo
for (ParIterator it = buf->par_iterator_begin(); it != null; ++it) {
- if (it->id() == first->id())
- first = it.outerPar();
+ if (it->id() == first->id())
+ first = it.outerPar();
if (it->id() == last->id())
- last = it.outerPar();
+ last = it.outerPar();
}
#endif
#include <fstream>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::asctime;
using std::gmtime;
#include <cstdio>
+using namespace lyx::support;
+
#ifndef CXX_GLOBAL_CSTD
using std::sscanf;
#endif
projects / features.git / commitdiff