X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyx_main.C;h=84378364bcb54d74483b7e37c7e24688723855fe;hb=ebfcf1c0e72288b7131607af0330500c8739cead;hp=5d1f716eb57a6aac0faa46597adb1bc91c623869;hpb=0eccdd1c3613e5170deb77b22174dd0afde833e9;p=lyx.git diff --git a/src/lyx_main.C b/src/lyx_main.C index 5d1f716eb5..84378364bc 100644 --- a/src/lyx_main.C +++ b/src/lyx_main.C @@ -1,35 +1,48 @@ /* This file is part of - * ====================================================== + * ====================================================== * * LyX, The Document Processor * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-1999 The LyX Team. + * Copyright 1995 Matthias Ettrich + * Copyright 1995-2000 The LyX Team. * - * ======================================================*/ + * ====================================================== */ #include #include #include +#ifdef __GNUG__ +#pragma implementation +#endif + #include "version.h" #include "lyx_main.h" #include "lyx_gui.h" +#include "LyXView.h" +#include "lyxfunc.h" #include "lyx_gui_misc.h" #include "lyxrc.h" -#include "pathstack.h" +#include "support/path.h" #include "support/filetools.h" #include "bufferlist.h" -#include "error.h" +#include "debug.h" #include "support/FileInfo.h" #include "lastfiles.h" #include "intl.h" #include "lyxserver.h" #include "layout.h" #include "gettext.h" +#include "kbmap.h" +#include "MenuBackend.h" +#include "ToolbarDefaults.h" +#include "lyxlex.h" + +using std::endl; extern void LoadLyXFile(string const &); +extern void QuitLyX(); string system_lyxdir; string build_lyxdir; @@ -37,27 +50,22 @@ string system_tempdir; string user_lyxdir; // Default $HOME/.lyx // Should this be kept global? Asger says Yes. -Error lyxerr; +DebugStream lyxerr; -LastFiles *lastfiles; -LyXRC *lyxrc; +LastFiles * lastfiles; // This is the global bufferlist object BufferList bufferlist; -LyXServer *lyxserver = 0; +LyXServer * lyxserver = 0; // this should be static, but I need it in buffer.C bool finished = false; // flag, that we are quitting the program // convenient to have it here. -kb_keymap *toplevel_keymap; +kb_keymap * toplevel_keymap; -// from spellchecker.C -#if 0 -extern void sigchldhandler(int sig); -#endif -LyX::LyX(int *argc, char *argv[]) +LyX::LyX(int * argc, char * argv[]) { // Prevent crash with --help lyxGUI = 0; @@ -69,35 +77,42 @@ LyX::LyX(int *argc, char *argv[]) // Global bindings (this must be done as early as possible.) (Lgb) toplevel_keymap = new kb_keymap; - - lyxerr.debug("Initializing lyxrc"); - lyxrc = new LyXRC; - + defaultKeyBindings(toplevel_keymap); + // Make the GUI object, and let it take care of the // command line arguments that concerns it. - lyxerr.debug("Initializing LyXGUI..."); + lyxerr[Debug::INIT] << "Initializing LyXGUI..." << endl; lyxGUI = new LyXGUI(this, argc, argv, gui); - lyxerr.debug("Initializing LyXGUI...done"); + lyxerr[Debug::INIT] << "Initializing LyXGUI...done" << endl; + // Now the GUI and LyX have taken care of their arguments, so + // the only thing left on the command line should be + // filenames. Let's check anyway. + for (int argi = 1; argi < *argc ; ++argi) { + if (argv[argi][0] == '-') { + lyxerr << _("Wrong command line option `") + << argv[argi] + << _("'. Exiting.") << endl; + exit(0); + } + } + // Initialization of LyX (reads lyxrc and more) - lyxerr.debug("Initializing LyX::init..."); - init(argc, argv); - lyxerr.debug("Initializing LyX::init...done"); + lyxerr[Debug::INIT] << "Initializing LyX::init..." << endl; + init(argc, argv, gui); + lyxerr[Debug::INIT] << "Initializing LyX::init...done" << endl; lyxGUI->init(); // Load the files specified in the command line. - // Now the GUI and LyX have taken care of their arguments, so - // the only thing left on the command line should be - // filenames. - if ((*argc)==2) - lyxerr.debug("Opening document..."); - else if ((*argc)>2) - lyxerr.debug("Opening documents..."); + if ((*argc) == 2) + lyxerr[Debug::INFO] << "Opening document..." << endl; + else if ((*argc) > 2) + lyxerr[Debug::INFO] << "Opening documents..." << endl; - Buffer *last_loaded = 0; + Buffer * last_loaded = 0; - for (int argi = (*argc) - 1; argi >= 1; argi--) { + for (int argi = (*argc) - 1; argi >= 1; --argi) { Buffer * loadb = bufferlist.loadLyXFile(argv[argi]); if (loadb != 0) { last_loaded = loadb; @@ -106,7 +121,8 @@ LyX::LyX(int *argc, char *argv[]) if (first_start) { string splash = i18nLibFileSearch("examples", "splash.lyx"); - lyxerr.debug("Opening splash document "+splash+"..."); + lyxerr[Debug::INIT] << "Opening splash document " + << splash << "..." << endl; Buffer * loadb = bufferlist.loadLyXFile(splash); if (loadb != 0) { last_loaded = loadb; @@ -114,8 +130,36 @@ LyX::LyX(int *argc, char *argv[]) } if (last_loaded != 0) { - lyxerr.debug("Yes we loaded some files."); + lyxerr[Debug::INIT] << "Yes we loaded some files." << endl; + if (lyxrc.use_gui) + lyxGUI->regBuf(last_loaded); + } + + // Execute batch commands if available + if (!batch_command.empty()) { + lyxerr << "About to handle -x '" + << batch_command << "'" << endl; + + // no buffer loaded, create one + if (!last_loaded) + last_loaded = bufferlist.newFile("tmpfile", string()); + + // try to dispatch to last loaded buffer first + bool dispatched = last_loaded->Dispatch(batch_command); + + // if this was successful, return. + // Maybe we could do something more clever than aborting... + if (dispatched) { + lyxerr << "We are done!" << endl; + QuitLyX(); + return; + } + + // otherwise, let the GUI handle the batch command lyxGUI->regBuf(last_loaded); + lyxGUI->getLyXView()->getLyXFunc()->Dispatch(batch_command); + + // fall through... } // Let the ball begin... @@ -126,17 +170,14 @@ LyX::LyX(int *argc, char *argv[]) // A destructor is always necessary (asierra-970604) LyX::~LyX() { - if (lastfiles) - delete lastfiles; - - if (lyxGUI) - delete lyxGUI; + delete lastfiles; + delete lyxGUI; } extern "C" void error_handler(int err_sig); -void LyX::init(int */*argc*/, char **argv) +void LyX::init(int */*argc*/, char **argv, bool gui) { // Install the signal handlers signal(SIGHUP, error_handler); @@ -145,40 +186,40 @@ void LyX::init(int */*argc*/, char **argv) signal(SIGINT, error_handler); signal(SIGTERM, error_handler); -#if 0 - // Install the SIGCHLD handler - act_.sa_handler = sigchldhandler; - //act_.sa_mask = SIGCHLD; - act_.sa_flags = 0; - //act_.sa_flags = SA_RESTART; //perhaps - sigaction(SIGCHLD, &act_, 0); -#endif // // Determine path of binary // - string fullbinpath, binpath = argv[0]; - subst(binpath, '\\', '/'); + string fullbinpath; + string binpath = subst(argv[0], '\\', '/'); string binname = OnlyFilename(argv[0]); // Sorry for system specific code. (SMiyata) - if (suffixIs(binname, ".exe")) binname.erase(binname.length()-4, string::npos); + if (suffixIs(binname, ".exe")) + binname.erase(binname.length()-4, string::npos); binpath = ExpandPath(binpath); // This expands ./ and ~/ if (!AbsolutePath(binpath)) { string binsearchpath = GetEnvPath("PATH"); - binsearchpath += ";."; // This will make "src/lyx" work always :-) + // This will make "src/lyx" work always :-) + binsearchpath += ";."; binpath = FileOpenSearch(binsearchpath, argv[0]); } fullbinpath = binpath; binpath = MakeAbsPath(OnlyPath(binpath)); + // In case we are running in place and compiled with shared libraries + if (suffixIs(binpath, "/.libs/")) + binpath.erase(binpath.length()-6, string::npos); + if (binpath.empty()) { - lyxerr.print(_("Warning: could not determine path of binary.")); - lyxerr.print(_("If you have problems, try starting LyX with an absolute path.")); + lyxerr << _("Warning: could not determine path of binary.") + << "\n" + << _("If you have problems, try starting LyX with an absolute path.") + << endl; } - lyxerr.debug("Path of binary: " + binpath); + lyxerr[Debug::INIT] << "Path of binary: " << binpath << endl; // // Determine system directory. @@ -186,7 +227,7 @@ void LyX::init(int */*argc*/, char **argv) // Directories are searched in this order: // 1) -sysdir command line parameter - // 2) LYX_DIR_10x environment variable + // 2) LYX_DIR_11x environment variable // 3) Maybe /TOP_SRCDIR/lib // 4) /../share// // 4a) repeat 4 after following the Symlink if + + // If we had a command line switch, user_lyxdir is already set + bool explicit_userdir = true; + if (user_lyxdir.empty()) { + + // LYX_USERDIR_11x environment variable + user_lyxdir = GetEnvPath("LYX_USERDIR_11x"); + + // default behaviour + if (user_lyxdir.empty()) + user_lyxdir = AddPath(GetEnvPath("HOME"), + string(".") + PACKAGE); + explicit_userdir = false; + } + + lyxerr[Debug::INIT] << "User LyX directory: '" + << user_lyxdir << '\'' << endl; // Check that user LyX directory is ok. - queryUserLyXDir(); + queryUserLyXDir(explicit_userdir); // // Load the layouts first // - lyxerr.debug("Reading layouts...", Error::INIT); + lyxerr[Debug::INIT] << "Reading layouts..." << endl; LyXSetStyle(); // @@ -315,50 +377,68 @@ void LyX::init(int */*argc*/, char **argv) // // Default template path: system_dir/templates - if (lyxrc->template_path.empty()){ - lyxrc->template_path = AddPath(system_lyxdir, "templates"); + if (lyxrc.template_path.empty()){ + lyxrc.template_path = AddPath(system_lyxdir, "templates"); } // Default lastfiles file: $HOME/.lyx/lastfiles - if (lyxrc->lastfiles.empty()){ - lyxrc->lastfiles = AddName(user_lyxdir, "lastfiles"); + if (lyxrc.lastfiles.empty()){ + lyxrc.lastfiles = AddName(user_lyxdir, "lastfiles"); } - // Calculate screen dpi as average of x-DPI and y-DPI: - Screen * scr=(DefaultScreenOfDisplay(fl_get_display())); - lyxrc->dpi = ((HeightOfScreen(scr)* 25.4 / HeightMMOfScreen(scr)) + - (WidthOfScreen(scr)* 25.4 / WidthMMOfScreen(scr))) / 2; - lyxerr.debug(string("DPI setting detected to be ") + - tostr(lyxrc->dpi+0.5)); + // Disable gui when either lyxrc or easyparse says so + if (!gui) + lyxrc.use_gui = false; + + // Calculate screen dpi as average of x-DPI and y-DPI: + if (lyxrc.use_gui) { + lyxrc.dpi = getScreenDPI(); + lyxerr[Debug::INIT] << "DPI setting detected to be " + << lyxrc.dpi + 0.5 << endl; + } else { + lyxrc.dpi = 1; // I hope this is safe + } // // Read configuration files // ReadRcFile("lyxrc.defaults"); - ReadRcFile("lyxrc"); +// system_lyxrc = lyxrc; + // If there is a preferences file we read that instead + // of the old lyxrc file. + if (!ReadRcFile("preferences")) + ReadRcFile("lyxrc"); // Ensure that we have really read a bind file, so that LyX is // usable. - if (!lyxrc->hasBindFile) - lyxrc->ReadBindFile(); + if (!lyxrc.hasBindFile) + lyxrc.ReadBindFile(); - if (lyxerr.debugging(Error::LYXRC)) { - lyxrc->Print(); + // Read menus + ReadUIFile(lyxrc.ui_file); + + // Bind the X dead keys to the corresponding LyX functions if + // necessary. + if (lyxrc.override_x_deadkeys) + deadKeyBindings(toplevel_keymap); + + if (lyxerr.debugging(Debug::LYXRC)) { + lyxrc.print(); } // Create temp directory - system_tempdir = CreateLyXTmpDir(lyxrc->tempdir_path); - if (lyxerr.debugging(Error::INIT)) { - lyxerr.print("LyX tmp dir: `" + system_tempdir + '\''); + system_tempdir = CreateLyXTmpDir(lyxrc.tempdir_path); + if (lyxerr.debugging(Debug::INIT)) { + lyxerr << "LyX tmp dir: `" << system_tempdir << '\'' << endl; } // load the lastfiles mini-database - lyxerr.debug("Reading lastfiles `" + lyxrc->lastfiles + "'...", - Error::INIT); - lastfiles = new LastFiles(lyxrc->lastfiles, - lyxrc->check_lastfiles, - lyxrc->num_lastfiles); + lyxerr[Debug::INIT] << "Reading lastfiles `" + << lyxrc.lastfiles << "'..." << endl; + lastfiles = new LastFiles(lyxrc.lastfiles, + lyxrc.check_lastfiles, + lyxrc.num_lastfiles); // start up the lyxserver. (is this a bit early?) (Lgb) // 0.12 this will be way to early, we need the GUI to be initialized @@ -366,10 +446,86 @@ void LyX::init(int */*argc*/, char **argv) // lyxserver = new LyXServer; } +// These are the default bindings known to LyX +void LyX::defaultKeyBindings(kb_keymap * kbmap) +{ + kbmap->bind("Right", LFUN_RIGHT); + kbmap->bind("Left", LFUN_LEFT); + kbmap->bind("Up", LFUN_UP); + kbmap->bind("Down", LFUN_DOWN); + + kbmap->bind("Tab", LFUN_TAB); + + kbmap->bind("Home", LFUN_HOME); + kbmap->bind("End", LFUN_END); + kbmap->bind("Prior", LFUN_PRIOR); + kbmap->bind("Next", LFUN_NEXT); + + kbmap->bind("Return", LFUN_BREAKPARAGRAPH); + kbmap->bind("~C-~S-~M-nobreakspace", LFUN_PROTECTEDSPACE); + + kbmap->bind("Delete", LFUN_DELETE); + kbmap->bind("BackSpace", LFUN_BACKSPACE); + + // kbmap->bindings to enable the use of the numeric keypad + // e.g. Num Lock set + kbmap->bind("KP_0", LFUN_SELFINSERT); + kbmap->bind("KP_Decimal", LFUN_SELFINSERT); + kbmap->bind("KP_Enter", LFUN_SELFINSERT); + kbmap->bind("KP_1", LFUN_SELFINSERT); + kbmap->bind("KP_2", LFUN_SELFINSERT); + kbmap->bind("KP_3", LFUN_SELFINSERT); + kbmap->bind("KP_4", LFUN_SELFINSERT); + kbmap->bind("KP_5", LFUN_SELFINSERT); + kbmap->bind("KP_6", LFUN_SELFINSERT); + kbmap->bind("KP_Add", LFUN_SELFINSERT); + kbmap->bind("KP_7", LFUN_SELFINSERT); + kbmap->bind("KP_8", LFUN_SELFINSERT); + kbmap->bind("KP_9", LFUN_SELFINSERT); + kbmap->bind("KP_Divide", LFUN_SELFINSERT); + kbmap->bind("KP_Multiply", LFUN_SELFINSERT); + kbmap->bind("KP_Subtract", LFUN_SELFINSERT); + + /* Most self-insert keys are handled in the 'default:' section of + * WorkAreaKeyPress - so we don't have to define them all. + * However keys explicit decleared as self-insert are + * handled seperatly (LFUN_SELFINSERT.) Lgb. */ + + kbmap->bind("C-Tab", LFUN_TABINSERT); // ale970515 + kbmap->bind("S-Tab", LFUN_SHIFT_TAB); // jug20000522 +} + +// LyX can optionally take over the handling of deadkeys +void LyX::deadKeyBindings(kb_keymap * kbmap) +{ + // bindKeyings for transparent handling of deadkeys + // The keysyms are gotten from XFree86 X11R6 + kbmap->bind("~C-~S-~M-dead_acute", LFUN_ACUTE); + kbmap->bind("~C-~S-~M-dead_breve", LFUN_BREVE); + kbmap->bind("~C-~S-~M-dead_caron", LFUN_CARON); + kbmap->bind("~C-~S-~M-dead_cedilla", LFUN_CEDILLA); + kbmap->bind("~C-~S-~M-dead_abovering", LFUN_CIRCLE); + kbmap->bind("~C-~S-~M-dead_circumflex", LFUN_CIRCUMFLEX); + kbmap->bind("~C-~S-~M-dead_abovedot", LFUN_DOT); + kbmap->bind("~C-~S-~M-dead_grave", LFUN_GRAVE); + kbmap->bind("~C-~S-~M-dead_doubleacute", LFUN_HUNG_UMLAUT); + kbmap->bind("~C-~S-~M-dead_macron", LFUN_MACRON); + // nothing with this name + // kbmap->bind("~C-~S-~M-dead_special_caron", LFUN_SPECIAL_CARON); + kbmap->bind("~C-~S-~M-dead_tilde", LFUN_TILDE); + kbmap->bind("~C-~S-~M-dead_diaeresis", LFUN_UMLAUT); + // nothing with this name either... + //kbmap->bind("~C-~S-~M-dead_underbar", LFUN_UNDERBAR); + kbmap->bind("~C-~S-~M-dead_belowdot", LFUN_UNDERDOT); + kbmap->bind("~C-~S-~M-dead_tie", LFUN_TIE); + kbmap->bind("~C-~S-~M-dead_ogonek", LFUN_OGONEK); +} + + // This one is not allowed to use anything on the main form, since that // one does not exist yet. (Asger) -void LyX::queryUserLyXDir() +void LyX::queryUserLyXDir(bool explicit_userdir) { // Does user directory exist? FileInfo fileInfo(user_lyxdir); @@ -381,175 +537,269 @@ void LyX::queryUserLyXDir() } // Nope - if (!AskQuestion(_("You don't have a personal LyX directory."), + // Different wording if the user specifically requested a directory + if (!AskQuestion( explicit_userdir + ? _("You have specified an invalid LyX directory.") + : _("You don't have a personal LyX directory.") , + _("It is needed to keep your own configuration."), _("Should I try to set it up for you (recommended)?"))) { - lyxerr.print(_("Running without personal LyX directory.")); + lyxerr << _("Running without personal LyX directory.") << endl; // No, let's use $HOME instead. user_lyxdir = GetEnvPath("HOME"); return; } // Tell the user what is going on - lyxerr.print(_("LyX: Creating directory ") + user_lyxdir + _(" and running configure...")); + lyxerr << _("LyX: Creating directory ") << user_lyxdir + << _(" and running configure...") << endl; // Create directory structure if (!createDirectory(user_lyxdir, 0755)) { // Failed, let's use $HOME instead. user_lyxdir = GetEnvPath("HOME"); - lyxerr.print(_("Failed. Will use ") + user_lyxdir + _(" instead.")); + lyxerr << _("Failed. Will use ") << user_lyxdir + << _(" instead.") << endl; return; } // Run configure in user lyx directory - PathPush(user_lyxdir); - system(AddName(system_lyxdir,"configure").c_str()); - PathPop(); - lyxerr.print(string("LyX: ") + _("Done!")); + Path p(user_lyxdir); + ::system(AddName(system_lyxdir, "configure").c_str()); + lyxerr << "LyX: " << _("Done!") << endl; } // Read the rc file `name' -void LyX::ReadRcFile(string const & name) +bool LyX::ReadRcFile(string const & name) { - lyxerr.debug("About to read "+name+"...", Error::INIT); + lyxerr[Debug::INIT] << "About to read " << name << "..." << endl; string lyxrc_path = LibFileSearch(string(), name); if (!lyxrc_path.empty()){ - lyxerr.debug("Found "+name+" in " + lyxrc_path, Error::INIT); - if (lyxrc->Read(lyxrc_path) < 0) { + lyxerr[Debug::INIT] << "Found " << name + << " in " << lyxrc_path << endl; + if (lyxrc.read(lyxrc_path) < 0) { WriteAlert(_("LyX Warning!"), _("Error while reading ")+lyxrc_path+".", _("Using built-in defaults.")); + return false; } + return true; } else - lyxerr.debug("Could not find "+name, Error::INIT); + lyxerr[Debug::INIT] << "Could not find " << name << endl; + return false; +} + + +// Read the ui file `name' +void LyX::ReadUIFile(string const & name) +{ + enum Uitags { + ui_menuset = 1, + ui_toolbar, + ui_last + }; + + struct keyword_item uitags[ui_last-1] = { + { "menuset", ui_menuset }, + { "toolbar", ui_toolbar } + }; + + lyxerr[Debug::INIT] << "About to read " << name << "..." << endl; + + string ui_path = LibFileSearch("ui", name, "ui"); + + if (ui_path.empty()) { + lyxerr[Debug::INIT] << "Could not find " << name << endl; + return; + } + + lyxerr[Debug::INIT] << "Found " << name + << " in " << ui_path << endl; + LyXLex lex(uitags, ui_last - 1); + lex.setFile(ui_path); + if (!lex.IsOK()) { + lyxerr << "Unable to set LyXLeX for ui file: " << ui_path + << endl; + } + + if (lyxerr.debugging(Debug::PARSER)) + lex.printTable(lyxerr); + + while (lex.IsOK()) { + switch(lex.lex()) { + case ui_menuset: + menubackend.read(lex); + break; + + case ui_toolbar: + toolbardefaults.read(lex); + break; + + default: + lex.printError("LyX::ReadUFile: " + "Unknown menu tag: `$$Token'"); + break; + } + } } // Set debugging level and report result to user -void setDebuggingLevel(int dbgLevel) +void setDebuggingLevel(string const & dbgLevel) { - lyxerr.print(string(_("Setting debug level to ")) + tostr(dbgLevel)); - lyxerr.setDebugLevel(dbgLevel); - lyxerr.debug(string("Debugging INFO #") + tostr(Error::INFO), - Error::INFO); - lyxerr.debug(string("Debugging INIT #") + tostr(Error::INIT), - Error::INIT); - lyxerr.debug(string("Debugging KEY #") + tostr(Error::KEY), - Error::KEY); - lyxerr.debug(string("Debugging TOOLBAR #") + tostr(Error::TOOLBAR), - Error::TOOLBAR); - lyxerr.debug(string("Debugging LEX and PARSER #") + - tostr(Error::LEX_PARSER), - Error::LEX_PARSER); - lyxerr.debug(string("Debugging LYXRC #") + tostr(Error::LYXRC), - Error::LYXRC); - lyxerr.debug(string("Debugging KBMAP #") + tostr(Error::KBMAP), - Error::KBMAP); - lyxerr.debug(string("Debugging LATEX #") + tostr(Error::LATEX), - Error::LATEX); - lyxerr.debug(string("Debugging MATHED #") + tostr(Error::MATHED), - Error::MATHED); - lyxerr.debug(string("Debugging FONT #") + tostr(Error::FONT), - Error::FONT); - lyxerr.debug(string("Debugging TCLASS #") + tostr(Error::TCLASS), - Error::TCLASS); - lyxerr.debug(string("Debugging LYXVC #") + tostr(Error::LYXVC), - Error::LYXVC); - lyxerr.debug(string("Debugging LYXSERVER #") + tostr(Error::LYXSERVER), - Error::LYXVC); + lyxerr << _("Setting debug level to ") << dbgLevel << endl; + lyxerr.level(Debug::value(dbgLevel)); + Debug::showLevel(lyxerr, lyxerr.level()); } // Give command line help void commandLineHelp() { - lyxerr.print(_("LyX " LYX_VERSION " of " LYX_RELEASE ".\n")); - lyxerr.print(_("Usage: lyx [ command line switches ] [ name.lyx ... ]\n")); - lyxerr.print(_("Command line switches (case sensitive):")); - lyxerr.print(_(" -help summarize LyX usage")); - lyxerr.print(_(" -sysdir x try to set system directory to x")); - lyxerr.print(_(" -width x set the width of the main window")); - lyxerr.print(_(" -height y set the height of the main window")); - lyxerr.print(_(" -xpos x set the x position of the main window")); - lyxerr.print(_(" -ypos y set the y position of the main window")); - lyxerr.print(_(" -dbg n where n is a sum of debugging options. Try -dbg 65535 -help")); - lyxerr.print(_(" -Reverse swaps foreground & background colors")); - lyxerr.print(_(" -Mono runs LyX in black and white mode")); - lyxerr.print(_(" -FastSelection use a fast routine for drawing selections\n")); - lyxerr.print(_("Check the LyX man page for more options.")); + lyxerr << "LyX " LYX_VERSION << " of " LYX_RELEASE << endl; + lyxerr << + _("Usage: lyx [ command line switches ] [ name.lyx ... ]\n" + "Command line switches (case sensitive):\n" + "\t-help summarize LyX usage\n" + "\t-userdir dir try to set user directory to dir\n" + "\t-sysdir dir try to set system directory to dir\n" + "\t-geometry WxH+X+Y set geometry of the main window\n" + "\t-dbg feature[,feature]...\n" + " select the features to debug.\n" + " Type `lyx -dbg' to see the list of features\n" + "Check the LyX man page for more options.") << endl; } - -bool LyX::easyParse(int *argc, char *argv[]) +bool LyX::easyParse(int * argc, char * argv[]) { bool gui = true; - for(int i=1; i < *argc; i++) { + int removeargs = 0; // used when options are read + for(int i = 1; i < *argc; ++i) { string arg = argv[i]; + // Check for -dbg int if (arg == "-dbg") { - if (i+1 < *argc) { - int erri = 0; - sscanf(argv[i+1],"%d", &erri); - - setDebuggingLevel(erri); - - // Now, remove these two arguments by shifting - // the following two places down. - (*argc) -= 2; - for (int j=i; j < (*argc); j++) - argv[j] = argv[j+2]; - i--; // After shift, check this number again. - } else - lyxerr.print(_("Missing number for -dbg switch!")); + if (i + 1 < *argc) { + setDebuggingLevel(argv[i + 1]); + removeargs = 2; + } else { + lyxerr << _("List of supported debug flags:") + << endl; + Debug::showTags(lyxerr); + exit(0); + } } // Check for "-sysdir" else if (arg == "-sysdir") { - if (i+1 < *argc) { - system_lyxdir = argv[i+1]; - - // Now, remove these two arguments by shifting - // the following two places down. - (*argc) -= 2; - for (int j=i; j < (*argc); j++) - argv[j] = argv[j+2]; - i--; // After shift, check this number again. - } else - lyxerr.print(_("Missing directory for -sysdir switch!")); + if (i + 1 < *argc) { + system_lyxdir = argv[i + 1]; + removeargs = 2; + } else { + lyxerr << _("Missing directory for -sysdir switch!") + << endl; + exit(0); + } + } + // Check for "-userdir" + else if (arg == "-userdir") { + if (i + 1 < *argc) { + user_lyxdir = argv[i + 1]; + removeargs = 2; + } else { + lyxerr << _("Missing directory for -userdir switch!") + << endl; + exit(0); + } + } // Check for --help or -help - } else if (arg == "--help" || arg == "-help") { + else if (arg == "--help" || arg == "-help") { commandLineHelp(); exit(0); } - // Check for "-nw": No window - else if (arg == "-nw") { - gui = false; + // Check for "-nw": No XWindows as for emacs this should + // give a LyX that could be used in a terminal window. + //else if (arg == "-nw") { + // gui = false; + //} + + // Check for "-x": Execute commands + else if (arg == "-x" || arg == "--execute") { + if (i + 1 < *argc) { + batch_command = string(argv[i + 1]); + removeargs = 2; + } + else + lyxerr << _("Missing command string after -x switch!") << endl; + + // Argh. Setting gui to false segfaults.. + //gui = false; } + + else if (arg == "-e" || arg == "--export") { + if (i + 1 < *argc) { + string type(argv[i+1]); + removeargs = 2; + batch_command = "buffer-export " + type; + gui = false; + } else + lyxerr << _("Missing file type [eg latex, " + "ps...] after ") + << arg << _(" switch!") << endl; + } + else if (arg == "--import") { + if (i + 1 < *argc) { + string type(argv[i+1]); + string file(argv[i+2]); + removeargs = 3; + + batch_command = "buffer-import " + type + " " + file; + lyxerr << "batch_command: " + << batch_command << endl; + + } else + lyxerr << _("Missing type [eg latex, " + "ps...] after ") + << arg << _(" switch!") << endl; + } + + if (removeargs > 0) { + // Now, remove used arguments by shifting + // the following ones removeargs places down. + (*argc) -= removeargs; + for (int j = i; j < (*argc); ++j) + argv[j] = argv[j + removeargs]; + --i; // After shift, check this number again. + removeargs = 0; + } + } + return gui; } +extern "C" void error_handler(int err_sig) { switch (err_sig) { case SIGHUP: - fprintf(stderr, "\nlyx: SIGHUP signal caught\n"); + lyxerr << "\nlyx: SIGHUP signal caught" << endl; break; case SIGINT: // no comments break; case SIGFPE: - fprintf(stderr, "\nlyx: SIGFPE signal caught\n"); + lyxerr << "\nlyx: SIGFPE signal caught" << endl; break; case SIGSEGV: - fprintf(stderr, "\nlyx: SIGSEGV signal caught\n"); - fprintf(stderr, + lyxerr << "\nlyx: SIGSEGV signal caught" << endl; + lyxerr << "Sorry, you have found a bug in LyX." " If possible, please read 'Known bugs'\n" "under the Help menu and then send us " - "a full bug report. Thanks!\n"); + "a full bug report. Thanks!" << endl; break; case SIGTERM: // no comments @@ -565,8 +815,9 @@ void error_handler(int err_sig) bufferlist.emergencyWriteAll(); - lyxerr.print("Bye."); - if(err_sig!=SIGHUP && (!GetEnv("LYXDEBUG").empty() || err_sig == SIGSEGV)) - abort(); + lyxerr << "Bye." << endl; + if(err_sig!= SIGHUP && + (!GetEnv("LYXDEBUG").empty() || err_sig == SIGSEGV)) + lyx::abort(); exit(0); }