typedef std::map<std::string, Speller> Spellers;
typedef map<std::string, PersonalWordList *> LangPersonalWordList;
-} // anon namespace
+} // namespace
struct AspellChecker::Private
{
return ret;
}
-} // anon namespace
+} // namespace
//////////////////////////////////////////////////////////////////////
}
-} // anon namespace
+} // namespace
/* FIXME
Bug #9131 revealed an oddity in how we are generating citation information
}
};
-} // namespace anon
+} // namespace
vector<docstring> const BiblioInfo::getXRefs(BibTeXInfo const & data, bool const nested) const
|| (lauth == rauth && lyear == ryear && ltitl < rtitl);
}
-}
+} // namespace
void BiblioInfo::collectCitedEntries(Buffer const & buf)
docstring name_;
};
-}
+} // namespace
Branch::Branch()
typedef map<string, bool> DepClean;
typedef map<docstring, pair<InsetLabel const *, Buffer::References> > RefCache;
-} // namespace anon
+} // namespace
// A storehouse for the cloned buffers.
return pid;
}
-} // namespace anon
+} // namespace
FileName Buffer::getEmergencyFileName() const
namespace frontend {
class GuiBufferDelegate;
class WorkAreaManager;
-}
+} // namespace frontend
namespace support {
class DocFileName;
class FileName;
class FileNamePairList;
-}
+} // namespace support
namespace graphics {
class PreviewLoader;
class Cache;
-}
+} // namespace graphics
class Buffer;
namespace support {
class FileName;
class FileNameList;
-}
+} // namespace support
/**
* The class holds all all open buffers, and handles construction
return false;
}
-} // anon namespace
+} // namespace
class BufferParams::Impl
return "\"" + str + "\"";
return str;
}
-}
+} // namespace
void BufferParams::writeFile(ostream & os, Buffer const * buf) const
DecorationUpdate
};
-} // anon namespace
+} // namespace
/////////////////////////////////////////////////////////////////////
return ods.str();
}
-} //namespace anon
+} // namespace
int Changes::latexMarkChange(otexstream & os, BufferParams const & bparams,
return translator;
}
-} // namespace anon
+} // namespace
string CiteEnginesList::getTypeAsString(CiteEngineType const & et) const
};
extern CiteEnginesList theCiteEnginesList;
-}
+} // namespace lyx
#endif
string const to_;
};
-} // namespace anon
+} // namespace
Converter::Converter(string const & f, string const & t,
unsigned long checksum;
};
-}
+} // namespace
/** The cache contains one item per orig file and target format, so use a
};
}
-} // namespace anon
+} // namespace
docstring Counters::labelItem(docstring const & ctr,
}
-} // namespace anon
+} // namespace
CursorData::CursorData()
return cit != row.end() && !cit->isVirtual();
}
-}
+} // namespace
void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) const
{
return os.str();
}
-}
+} // namespace
docstring Cursor::selectionAsString(bool with_label) const
cutstack.push(make_pair(copy_pars, dc));
}
-} // namespace anon
-
-
+} // namespace
namespace cap {
}
}
-}
+} // namespace
void cutSelection(Cursor & cur, bool doclear, bool realcut)
{
}
}
-}
+} // namespace
void copySelectionToStack()
/// is the tabular paste stack newer than the ordinary one?
bool tabularStackDirty();
} // namespace cap
-} // namespce lyx
+} // namespace lyx
#endif
typedef std::shared_ptr<DocumentClass> DocumentClassPtr;
typedef std::shared_ptr<DocumentClass const> DocumentClassConstPtr;
-}
+} // namespace lyx
#endif // DISPATCH_RESULT_H
typedef map<string, Speller> Spellers;
-} // anon namespace
+} // namespace
struct EnchantChecker::Private
{
/// The highest code point in UCS4 encoding (1<<20 + 1<<16)
char_type const max_ucs4 = 0x110000;
-} // namespace anon
+} // namespace
EncodingException::EncodingException(char_type c)
{ "tiny", "scriptsize", "footnotesize", "small", "normalsize", "large",
"Large", "LARGE", "huge", "Huge", "error8", "error9", "error10", "error11" };
-} // namespace anon
+} // namespace
Font::Font(FontInfo bits, Language const * l)
return "";
}
-} // namespace anonymous
+} // namespace
// FIXME This does not yet handle color
};
-} //namespace anon
+} // namespace
bool Format::formatSorter(Format const * lhs, Format const * rhs)
{
return string();
}
-}
+} // namespace
string Formats::getFormatFromFile(FileName const & filename) const
return translator;
}
-}
+} // namespace
std::string flavor2format(OutputParams::FLAVOR flavor)
}
}
-}
+} // namespace
string FuncRequest::getArg(unsigned int i) const
{
typedef vector<WordLangTuple> IgnoreList;
-} // anon namespace
+} // namespace
struct HunspellChecker::Private
docstring shortc_;
};
-}
+} // namespace
/////////////////////////////////////////////////////////////////////
}
};
-} // namespace anon
+} // namespace
InsetList::InsetList(InsetList const & il) : list_(il.list_)
return bformat(_("Waiting for LaTeX run number %1$d"), count);
}
-} // anon namespace
+} // namespace
/*
* CLASS TEXERRORS
return result;
}
-} // anon namespace
+} // namespace
void LaTeX::deplog(DepTable & head)
return snip.release();
}
-} //anon namespace
+} // namespace
void LaTeXFeatures::addPreambleSnippet(TexString ts, bool allow_dupes)
int const nb_simplefeatures = sizeof(simplefeatures) / sizeof(char const *);
-}
+} // namespace
string const LaTeXFeatures::getColorOptions() const
return from_utf8(preamble);
}
-}
+} // namespace
docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel,
return NoMatch;
}
-}
+} // namespace
void Languages::readLayoutTranslations(support::FileName const & filename)
return os.str();
}
-}
+} // namespace
void Layout::makeDefaultCSS() const
///
std::list<std::string> lml_;
};
-}
+} // namespace lyx
#endif
}
};
-} // end of anon namespace
+} // namespace
Lexer::Pimpl::Pimpl(LexerKeyword * tab, int num)
"Please check your installation."), from_utf8(error)));
}
-} // namespace anon
+} // namespace
/// The main application class private implementation.
struct LyX::Impl {
return std::string(line, nameLen);
}
}
-}
+} // namespace
void cleanDuplicateEnvVars()
{
}
-} // namespace anon
+} // namespace
void LyX::easyParse(int & argc, char * argv[])
const int lyxrcCount = sizeof(lyxrcTags) / sizeof(lyxrcTags[0]);
-} // namespace anon
+} // namespace
LyXRC::LyXRC()
foundry.erase();
}
-} // namespace anon
+} // namespace
bool LyXRC::read(FileName const & filename, bool check_format)
"\"", "\\\"");
}
-}
+} // namespace
void LyXRC::write(ostream & os, bool ignore_system_lyxrc, string const & name) const
};
extern ModuleList theModuleList;
-}
+} // namespace lyx
#endif
/// Inset identifier (above 0x10ffff, for ucs-4)
char_type const META_INSET = 0x200001;
-}
+} // namespace
/////////////////////////////////////////////////////////////////////
s.erase();
}
-}
+} // namespace
void Paragraph::write(ostream & os, BufferParams const & bparams,
return true;
}
-} // namespace anon
+} // namespace
int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
flag = false;
}
}
-}
+} // namespace
docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
return message;
}
-} // namespace anon
+} // namespace
DWORD WINAPI pipeServerWrapper(void * arg)
}
};
-} // namespace anon
+} // namespace
bool LyXComm::loadFilesInOtherInstance()
string const sec_lastcommands = "[last commands]";
string const sec_authfiles = "[auth files]";
-} // anon namespace
+} // namespace
namespace lyx {
}
-}
+} // namespace lyx
/// Implemented in LyX.cpp.
Session & theSession();
-} // lyx
+} // namespace lyx
#endif
return useSetSpace ? name : support::ascii_lowercase(name);
}
-}
+} // namespace
string const Spacing::writeEnvirBegin(bool useSetSpace) const
{
return true;
}
-}
+} // namespace
// insert a character, moves all the following breaks in the
return lang.empty() ? cur.getFont().language() : languages.getLanguage(lang);
}
-}
+} // namespace
void Text::dispatch(Cursor & cur, FuncRequest & cmd)
return string();
}
-} // namespace anon
+} // namespace
// This string should not be translated here,
{ "tocdepth", TC_TOCDEPTH }
};
-} //namespace anon
+} // namespace
bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType rt)
}
-}
+} // namespace
/////////////////////////////////////////////////////////////////////
//
pos_type bodypos_;
};
-} // anon namespace
+} // namespace
/** This is the function where the hard work is done. The code here is
* very sensitive to small changes :) Note that part of the
typedef std::map<docstring, MyThes *> Thesauri;
-} // namespace anon
+} // namespace
struct Thesaurus::Private
{
return d->filter_;
}
-} // namespace frontend
-} // namespace lyx
+} // namespace frontend
+} // namespace lyx
#include "moc_CategorizedCombo.cpp"
}
}
-}
+} // namespace
void ColorCache::init()
}
-} // frontend
-} // lyx
+} // namespace frontend
+} // namespace lyx
#include "moc_DockView.cpp"
void onBufferViewChanged() {} //override
};
-} // frontend
-} // lyx
+} // namespace frontend
+} // namespace lyx
#endif // DOCK_VIEW_H
}
}
-}
+} // namespace frontend
-}
+} // namespace lyx
#endif // QT_VERSION >= 0x040600
QString m_oldText;
};
-}
-}
+} // namespace frontend
+} // namespace lyx
#endif // FANCYLINEEDIT_H
return img_name;
}
-} // namespace anon
+} // namespace
QString themeIconName(QString const & action)
const QFontInfo fi(font);
return fi.fixedPitch();
}
-}
+} // namespace
QFont const GuiApplication::typewriterSystemFont()
combo->addItem(qt_("Reset"), "inherit");
}
-} // namespace anon
+} // namespace
GuiCharacter::GuiCharacter(GuiView & lv)
: GuiDialog(lv, "character", qt_("Text Style")), font_(ignore_font, ignore_language),
converter.setHtml(input);
return converter.toHtml("utf-8");
}
-}
+} // namespace
docstring const GuiClipboard::getAsText(TextType type) const
}
};
-} // end of anon
+} // namespace
GuiCommandBuffer::GuiCommandBuffer(GuiView * view)
bool operator()(string const & s) const { return prefixIs(s, p); }
};
-} // end of anon namespace
+} // namespace
string const GuiCommandBuffer::historyUp()
}
-} // anon namespace
+} // namespace
GuiDelimiter::GuiDelimiter(GuiView & lv)
}
};
-}
+} // namespace
namespace frontend {
namespace {
return s;
}
-} // namespace anon
+} // namespace
namespace lyx {
namespace frontend {
N_("Top right"), N_("Bottom right"), N_("Baseline right")
};
-} // namespace anon
+} // namespace
GuiExternal::GuiExternal(GuiView & lv)
return font;
}
-} // namespace anon
+} // namespace
FontLoader::FontLoader()
return font;
}
-} // anon namespace
+} // namespace
GuiFontInfo::GuiFontInfo(FontInfo const & f)
s.size() * sizeof(lyx::docstring::value_type)));
}
-}
+} // namespace std
namespace lyx {
namespace frontend {
LATTEST(is_utf16(ucs4));
return QChar(static_cast<unsigned short>(ucs4));
}
-} // anon namespace
+} // namespace
GuiFontMetrics::GuiFontMetrics(QFont const & font)
static string const autostr = N_("automatically");
-} // namespace anon
+} // namespace
namespace lyx {
namespace frontend {
bool operator==(lyx::docstring const & d, char const * c)
{ return lyx::operator ==(d, c); }
- }
-}
+ } // namespace frontend
+} // namespace lyx
#endif
};
-}
-}
+} // namespace frontend
+} // namespace lyx
#endif //GUIIDLISTMODEL_H
}
} // namespace graphics
-} // lyx
+} // namespace lyx
return split(l10n_format, '|');
}
-} // namespace anon
+} // namespace
void PrefFileformats::applyRC(LyXRC & rc) const
}
}
}
-}
+} // namespace
void PrefFileformats::updateViewers()
{
return a.second < b.second;
}
-}
+} // namespace
GuiProgressView::GuiProgressView(GuiView & parent, Qt::DockWidgetArea area,
}
-} // namespace anon
+} // namespace
/////////////////////////////////////////////////////////////////////
}
};
-}
+} // namespace
MenuButton::MenuButton(GuiToolbar * bar, ToolbarItem const & item, bool const sticky)
typedef shared_ptr<Dialog> DialogPtr;
-} // namespace anon
+} // namespace
class GuiView::GuiViewPrivate
cmpCStr(name.c_str())) != end_dialognames;
}
-} // namespace anon
+} // namespace
void GuiView::resetDialogs()
};
-} // namesapce frontend
+} // namespace frontend
} // namespace lyx
#endif // LENGTHCOMBO_H
}
}
-} // namespace anon
+} // namespace
/////////////////////////////////////////////////////////////////////
return res;
}
-} // namespace anon
+} // namespace
namespace frontend {
typedef InProgressProcesses::value_type InProgressProcess;
-} // namespace anon
-
+} // namespace
namespace lyx {
}
}
-} // namespace anon
+} // namespace
namespace lyx {
string const snippet_;
};
-} // namespace anon
+} // namespace
PreviewLoader::Status
PreviewLoader::Impl::status(string const & latex_snippet) const
string const & snippet_;
};
-} // namespace anon
+} // namespace
void PreviewLoader::Impl::remove(string const & latex_snippet)
return subst(input, placeholder, path2);
}
-} // namespace anon
+} // namespace
string const doSubstitution(InsetExternalParams const & params,
string const substituteOptions(InsetExternalParams const & params,
string const & input, string const & format);
-} // namespace anon
+} // namespace
void writeExternal(InsetExternalParams const & params,
return output;
}
-} // namespace anon
+} // namespace
} // namespace external
transform_class_not_found(lyxerr, transformer_class);
}
-} // namespace anon
+} // namespace
void Template::Format::readFormat(Lexer & lex)
typedef Translator<RotationData::OriginType, string> OriginTranslator;
OriginTranslator const & originTranslator();
-} // namespace anon
+} // namespace
void RotationData::origin(string const & o)
return os;
}
-} // namespace anon
+} // namespace
string const RotationLatexCommand::front_impl() const
transformer = factory(data);
}
-} // namespace anon
+} // namespace
TransformCommand::ptr_type
return translator;
}
-} // namespace anon
+} // namespace
} // namespace external
} // namespace lyx
return true;
}
-}
+} // namespace
void InsetBibtex::collectBibKeys(InsetIterator const & /*di*/) const
namespace support {
class FileName;
class FileNamePairList;
-}
+} // namespace support
/** Used to insert BibTeX's information
*/
return translator;
}
-} // namespace anon
+} // namespace
/////////////////////////////////////////////////////////////////////////
string defaultTemplateName;
-} // namespace anon
+} // namespace
namespace lyx {
data = T();
}
-} // namespace anon
+} // namespace
void InsetExternalParams::settemplate(string const & name)
return gui;
}
-} // namespace anon
-
+} // namespace
InsetExternal::InsetExternal(Buffer * buf)
return gparams;
}
-} // namespace anon
+} // namespace
static bool isPreviewWanted(InsetExternalParams const & params)
}
}
-} // namespace anon
+} // namespace
InsetGraphics::InsetGraphics(Buffer * buf)
return latex_path(file, EXCLUDE_EXTENSION);
}
-} // namespace anon
+} // namespace
string InsetGraphics::prepareFile(OutputParams const & runparams) const
void unifyGraphicsGroups(Buffer &, std::string const &);
InsetGraphics * getCurrentGraphicsInset(Cursor const &);
-}
+} // namespace graphics
} // namespace lyx
return chartranslator;
}
-} // anon
+} // namespace
InsetIPADecoParams::InsetIPADecoParams()
return new InsetLabel(buf, icp);
}
-} // namespace anon
+} // namespace
InsetInclude::InsetInclude(Buffer * buf, InsetCommandParams const & p)
}
}
-} // namespace anon
+} // namespace
void InsetInclude::addPreview(DocIterator const & /*inset_pos*/,
return (comp < 0);
}
-} // anon namespace
+} // namespace
docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const
return translator;
}
-} // namespace anon
+} // namespace
/////////////////////////////////////////////////////////////////////////
//
return InsetLayout::ILT_ERROR;
}
-} // namespace anon
+} // namespace
bool InsetLayout::read(Lexer & lex, TextClass const & tclass)
return false;
}
-} // namespace anon.
+} // namespace
// define a global ParValidator
ParValidator * par_validator = 0;
<< "' in nomencl widest string!");
return latex_symb.first;
}
-} // namespace anon
+} // namespace
void InsetPrintNomencl::latex(otexstream & os, OutputParams const & runparams_in) const
}
-} // anon
+} // namespace
InsetNoteParams::InsetNoteParams()
return translator;
}
-} // anon
+} // namespace
InsetPhantomParams::InsetPhantomParams()
char const * const side_char = "lr" ;
char const * const level_char = "sd";
-} // namespace anon
+} // namespace
/////////////////////////////////////////////////////////////////////
s[0] = t;
}
-}
+} // namespace
// the ref argument is the label name we are referencing.
return translator;
}
-} // anon
+} // namespace
InsetScriptParams::InsetScriptParams()
return width;
}
-}
+} // namespace
docstring InsetSpecialChar::toolTip(BufferView const &, int, int) const
{
}
}
-}
+} // namespace
void InsetSpecialChar::draw(PainterInfo & pi, int x, int y) const
{
return "listing";
return cmd;
}
-}
+} // namespace
InsetTOC::InsetTOC(Buffer * buf, InsetCommandParams const & p)
cur.pop();
}
-}
+} // namespace
void Tabular::setColumnPWidth(Cursor & cur, idx_type cell,
int const ADD_TO_VSPACE_WIDTH = 5;
-} // namespace anon
+} // namespace
InsetVSpace::InsetVSpace(VSpace const & space)
return loader.image()->isDrawable();
}
-} // namespace anon
+} // namespace
void RenderGraphic::metrics(MetricsInfo & mi, Dimension & dim) const
return message;
}
-} // namespace anon
+} // namespace
graphics::PreviewImage const *
};
-} // namespace anon
+} // namespace
const char * stringFromUnit(int unit)
return make_pair(true, 1);
}
-} // namespace anon
+} // namespace
docstring const find2string(docstring const & search,
return selectChange(cur, forward);
}
-}
+} // namespace
bool findNextChange(BufferView * bv)
{
}
-} // anonym namespace
+} // namespace
docstring stringifyFromForSearch(FindAndReplaceOptions const & opt,
pit->changeCase(buffer.params(), pos_type(1), right, others_case);
}
-} // anon namespace
+} // namespace
///
static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, MatchStringAdv & matchAdv)
return is;
}
-} // lyx namespace
+} // namespace lyx
buildTranslationMap(t);
return t;
}
-}
+} // namespace
void InsetMathDecoration::mathmlize(MathStream & os) const
{
return in_word_set(from_ascii("slash"));
}
-} // anon namespace
-
+} // namespace
void InsetMathFrac::metrics(MetricsInfo & mi, Dimension & dim) const
}
-} // end anon namespace
+} // namespace
HullType hullType(docstring const & s)
namespace {
const char * counters_to_save[] = {"section", "chapter"};
unsigned int const numcnts = sizeof(counters_to_save)/sizeof(char *);
-}
+} // namespace
void InsetMathHull::updateBuffer(ParIterator const & it, UpdateType utype)
return tmpcur.getStatus(cmd, status) && status.enabled();
}
-}
+} // namespace
bool InsetMathHull::getStatus(Cursor & cur, FuncRequest const & cmd,
namespace {
/// x spacing between the nucleus and the scripts
int const dx = 2;
-}
+} // namespace
namespace lyx {
int const nSpace = sizeof(space_info)/sizeof(SpaceInfo);
int const defaultSpace = 4;
-} // anon namespace
+} // namespace
InsetMathSpace::InsetMathSpace()
: space_(defaultSpace)
}
-} // namespace anon
+} // namespace
bool math_autocorrect(MathAtom & at, char_type c)
return res;
}
-}
+} // namespace
-} // anon namespace
+} // namespace
void write(MathData const & dat, WriteStream & wi)
{
}
-} // namespace anon
+} // namespace
MathWordList const & mathedWordList()
{
}
}
-}
+} // namespace
MathRow::MathRow(MetricsInfo & mi, MathData const * ar)
}
-} // namespace anon
+} // namespace
int mathed_font_em(FontInfo const & font)
return false;
}
-}
+} // namespace
bool openFileWrite(ofstream & ofs, FileName const & fname)
return pend;
}
-} // end anonym namespace
+} // namespace
void docbookParagraphs(Text const & text,
}
-} // namespace anon
+} // namespace
void pushLanguageName(string const & lang_name, bool localswitch)
}
}
-} // anon namespace
+} // namespace
void latexArgInsets(Paragraph const & par, otexstream & os,
}
}
-} // namespace anon
+} // namespace
// FIXME: this should be anonymous
void TeXOnePar(Buffer const & buf,
namespace {
// an illegal tag for internal use
static html::StartTag const parsep_tag("&LyX_parsep_tag&");
-}
+} // namespace
bool XHTMLStream::closeFontTags()
typedef unique_ptr<Revertible> Changer;
-}
+} // namespace lyx
#endif //LYX_CHANGER_H
pid_t pid_;
};
-} // namespace anon
+} // namespace
/////////////////////////////////////////////////////////////////////
return running_;
}
-} // namespace ForkedCallsQueue
-
+} // namespace ForkedCallQueue
/////////////////////////////////////////////////////////////////////
/// Query whether the queue is running a forked process now.
bool running();
-}
+} // namespace ForkedCallQueue
/**
}
}
-} // lyx
+} // namespace lyx
#ifdef ENABLE_NLS
}
return string();
}
-}
+} // namespace
bool Messages::available(string const & c)
}
-} // namespace anon
+} // namespace
bool Messages::readMoFile()
{
Package package_;
bool initialised_ = false;
-} // namespace anon
+} // namespace
void init_package(string const & command_line_arg0,
string const fix_dir_name(string const & name);
-} // namespace anon
+} // namespace
Package::Package(string const & command_line_arg0,
return program_suffix.empty() ? program_suffix : with_version_suffix;
}
-} // namespace anon
+} // namespace
FileName const & Package::top_srcdir()
return result;
}
-} // namespace anon
+} // namespace
} // namespace support
} // namespace lyx
}
-}
+} // namespace lyx
#endif //LYX_REFCHANGER_H
return trim(outcmd[0]);
}
-} // namespace anon
-
+} // namespace
int Systemcall::startscript(Starttype how, string const & what,
1, 1, _("&Stop it"), _("Let it &run")) == 0;
}
-}
+} // namespace
bool SystemcallPrivate::waitWhile(State waitwhile, bool process_events, int timeout)
using std::placeholders::_2;
using std::bind;
using std::ref;
-}
+} // namespace
#endif
}
}
-}
+} // namespace
namespace lyx {
int const numErrorTags = sizeof(errorTags)/sizeof(errorTags[0]);
-} // namespace anon
+} // namespace
int Debug::levelCount()
template<typename CharT, typename Traits> class basic_streambuf;
typedef basic_streambuf<char, char_traits<char> > streambuf;
-}
+} // namespace std
#endif
string encoding_;
};
-} // namespace anon
+} // namespace
namespace lyx {
}
#endif
-}
+} // namespace lyx
#if ! defined(USE_WCHAR_T) && defined(__GNUC__)
odocstream & operator<<(odocstream & os, SetEnc e);
idocstream & operator<<(idocstream & os, SetEnc e);
-}
+} // namespace lyx
#endif
ctype<lyx::char_type>::do_narrow(const lyx::char_type, char) const { return 0; }
template<> const lyx::char_type *
ctype<lyx::char_type>::do_narrow(const lyx::char_type *, const lyx::char_type *, char, char *) const { return 0; }
-}
+} // namespace std
namespace lyx {
/// make sure that our facets get used
static locale_initializer initializer;
-}
-}
+} // namespace
+} // namespace lyx
#endif
/// Maximum valid UCS4 code point
char_type const ucs4_max = 0x10ffff;
-} // anon namespace
+} // namespace
bool isLetterChar(char_type c)
return c;
}
-}
+} // namespace
int compare_ascii_no_case(string const & s, string const & s2)
Char operator()(Char c) const { return ascii_tolower(c); }
};
-} // end of anon namespace
+} // namespace
docstring const lowercase(docstring const & a)
return lstr;
}
-}
+} // namespace
string const subst(string const & a, char oldchar, char newchar)
return tmp;
}
-} // anon
+} // namespace
string const split(string const & a, string & piece, char delim)
return retval;
}
-}
+} // namespace
docstring wrap(docstring const & str, int const ind, size_t const width)
return str;
}
-} // namespace anon
+} // namespace
vector<string> const getVectorFromString(string const & str,
// Fixed in VC11:
// http://connect.microsoft.com/VisualStudio/feedback/details/572376/msvc10-c-std-numpunct-has-a-hardcoded-dllimport-in-definition
-}
+} // namespace std
#endif
return command;
}
-}
-}
-}
+} // namespace os
+} // namespace support
+} // namespace lyx
return FALSE;
}
-} // namespace anon
+} // namespace
void init(int argc, char ** argv[])
{
int argc_ = 0;
char ** argv_ = 0;
-} // namespace anon
+} // namespace
void init(int argc, char ** argv[])
{
return FALSE;
}
-} // namespace anon
+} // namespace
void init(int argc, char ** argv[])
{
<< std::endl;
}
-}
+} // namespace
/* Helper class for gathering data. Instantiate this as a static
{
using namespace LR_NS::regex_constants;
using LR_NS::regex_constants::match_flag_type;
-}
+} // namespace regex_constants
-}
+} // namespace lyx
#undef LR_NS
typedef basic_ostream<char, char_traits<char> > ostream;
typedef basic_ostringstream<char, char_traits<char>, allocator<char> > ostringstream;
-} // namepace std
+} // namespace std
#endif
class FontMetrics {
int em() const { return 0; };
};
- }
+ } // namespace frontend
class FontInfo;
static frontend::FontMetrics dummy;
return dummy;
}
-}
+} // namespace lyx
return vector<RetType>(tmp, tmp + bytes / sizeof(RetType));
}
-} // anon namespace
+} // namespace
IconvProcessor & utf8ToUcs4()
return it->second;
}
-} //anon namespace
+} // namespace
vector<char>
return *processors.localData();
}
-}
+} // namespace
vector<char>
ucs4_to_eightbit(char_type const * ucs4str, size_t ls, string const & encoding)
typedef void _Known_bound;
};
-} //anon namespace
+} // namespace
template<class T, class... Args>
typename _Unique_if<T>::_Single_object
LYXERR0(title);
LYXERR0(message);
}
-}
-}
+} // namespace Alert
+} // namespace frontend
bool LaTeXFeatures::isAvailable(std::string const &)
{
{
return false;
}
-}
+} // namespace lyx
using namespace lyx::support;
class FontMetrics {
int em() const { return 0; };
};
- }
+ } // namespace frontend
class FontInfo;
static frontend::FontMetrics dummy;
return dummy;
}
-}
+} // namespace lyx
os << "\n\\end_deeper";
}
-}
+} // namespace
bool operator==(TeXFont const & f1, TeXFont const & f2)
return c;
}
-}
+} // namespace
//
// Token
{
cerr << to_utf8(title) << "\n" << to_utf8(message) << endl;
}
-}
-}
+} // namespace Alert
+} // namespace frontend
//
class FontMetrics {
int em() const { return 0; };
};
-}
+} // namespace frontend
class FontInfo;
void lyx_exit(int)
{}
-}
+} // namespace lyx
return false;
}
-}
+} // namespace
bool checkModule(string const & name, bool command)
return true;
}
-}
+} // namespace
string translate_len(string const & length)
template otexstream & operator<< <unsigned long long>(otexstream &, unsigned long long);
#endif
-}
+} // namespace lyx
otexstream & operator<<(otexstream & ots, Type value);
-}
+} // namespace lyx
#endif
return static_cast<flags>(int(f) & int(g));
}
-} // namespace
+} // namespace Update
} // namespace lyx
#endif
projects / lyx.git / commitdiff