home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / lyx_cb.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  98KB  |  3,675 lines
  1. /* This file is part of
  2. * ======================================================
  3. * 
  4. *           LyX, The Document Processor
  5. *      
  6. *        Copyright (C) 1995 Matthias Ettrich,
  7. *           Copyright (C) 1995-1998 The LyX Team.
  8. *
  9. *======================================================*/
  10.  
  11. #include <config.h>
  12.  
  13. #include <ctype.h>
  14. #include <unistd.h>
  15. #include <signal.h>
  16. #include <stdlib.h>
  17.  
  18. #include "LString.h"
  19. #include "lyx_main.h"
  20. #include FORMS_H_LOCATION
  21. #include "lyx.h"
  22. #include "layout_forms.h"
  23. #include "bullet_forms.h"
  24. #include "print_form.h"
  25. #include "form1.h"
  26. #include "spellchecker.h"
  27. #include "version.h"
  28. #include "lyx_cb.h"
  29. #include "credits.h"
  30. #include "insetref.h"
  31. #include "insetquotes.h"
  32. #include "insetlabel.h"
  33. #include "insetinfo.h"
  34. #include "insetspecialchar.h"
  35. #include "figinset.h"
  36. #include "lyxfunc.h"
  37. #include "latexoptions.h"
  38. #include "lyxfont.h"
  39. #include "minibuffer.h"
  40. #include "combox.h"
  41. #include "bufferlist.h"
  42. #include "filetools.h"
  43. #include "path.h"
  44. #include "filedlg.h"
  45. #include "lyx_gui_misc.h"
  46. #include "LyXView.h" // only because of form_main
  47. #include "lastfiles.h"
  48. #include "FileInfo.h"
  49. #include "lyxscreen.h"
  50. #include "error.h"
  51. #include "syscall.h"
  52. #include "lyxlib.h"
  53. #include "lyxserver.h"
  54. #include "FontLoader.h"
  55. #include "lyxrc.h"
  56. #include "lyxtext.h"
  57. #include "gettext.h"
  58. #include "insetfig.h"
  59.  
  60. //     $Id: lyx_cb.C,v 1.1.1.1 1998/04/23 16:02:52 larsbj Exp $    
  61.  
  62. #if !defined(lint) && !defined(WITH_WARNINGS)
  63. static char vcid[] = "$Id: lyx_cb.C,v 1.1.1.1 1998/04/23 16:02:52 larsbj Exp $";
  64. #endif /* lint */
  65.  
  66. extern MiniBuffer *minibuffer;
  67. extern Combox *combo_language;
  68. extern BufferList bufferlist;
  69. extern void show_symbols_form();
  70. extern FD_form_main *fd_form_main;
  71. extern FD_form_title *fd_form_title;
  72. extern FD_form_paragraph *fd_form_paragraph;
  73. extern FD_form_character *fd_form_character;
  74. extern FD_form_document *fd_form_document;
  75. extern FD_form_quotes *fd_form_quotes;
  76. extern FD_form_preamble *fd_form_preamble;
  77. extern FD_form_table *fd_form_table;
  78. extern FD_form_print *fd_form_print;
  79. extern FD_form_figure *fd_form_figure;
  80. extern FD_form_screen *fd_form_screen;
  81. extern FD_form_toc *fd_form_toc;
  82. extern FD_form_ref *fd_form_ref;
  83. extern FD_LaTeXOptions *fd_latex_options;
  84. extern FD_form_bullet *fd_form_bullet;
  85.  
  86. extern BufferView *current_view; // called too many times in this file...
  87.  
  88. extern void DeleteSimpleCutBuffer(); /* for the cleanup when exiting */
  89.  
  90. extern void sigchldhandler(int sig);
  91. extern int send_fax(LString const &fname, LString const &sendcmd);
  92.  
  93. extern LyXServer *lyxserver;
  94. extern FontLoader fontloader;
  95.  
  96. // this should be static, but I need it in buffer.C
  97. bool quitting;    // flag, that we are quitting the program
  98. extern bool finished; // all cleanup done just let it run through now.
  99.  
  100. char ascii_type; /* for selection notify callbacks */
  101.  
  102. bool scrolling = false;
  103.  
  104. char updatetimer = 0;
  105.  
  106. /* whether the work area should get callbacks */ 
  107. bool input_prohibited = false;
  108.  
  109. /* the selection possible is needed, that only motion events are 
  110. * used, where the bottom press event was on the drawing area too */
  111. bool selection_possible = false;
  112.  
  113. void InsertCorrectQuote();
  114.  
  115.  
  116. /* 
  117.    This is the inset locking stuff needed for mathed --------------------
  118.  
  119.    an inset can simple call LockInset in it's edit call and *ONLY* in it's
  120.    edit call.
  121.    Inset::Edit() can only be called by the main lyx module.
  122.  
  123.    Then the inset may modify the menu's and/or iconbars. 
  124.  
  125.    Unlocking is either done by LyX or the inset itself with a UnlockInset-call
  126.  
  127.    During the lock, all button and keyboard events will be modified
  128.    and send to the inset through the following inset-features. Note that
  129.    Inset::InsetUnlock will be called from inside UnlockInset. It is meant
  130.    to contain the code for restoring the menus and things like this.
  131.  
  132.    
  133.    virtual void InsetButtonPress(int x, int y, int button);
  134.    virtual void InsetButtonRelease(int x, int y, int button);
  135.    virtual void InsetKeyPress(XKeyEvent *ev);
  136.    virtual void InsetMotionNotify(int x, int y, int state);
  137.    virtual void InsetUnlock();
  138.  
  139.    If a inset wishes any redraw and/or update it just has to call
  140.    UpdateInset(this).
  141.    It's is completly irrelevant, where the inset is. UpdateInset will
  142.    find it in any paragraph in any buffer. 
  143.    Of course the_locking_inset and the insets in the current paragraph/buffer
  144.    are checked first, so no performance problem should occur.
  145.    
  146.    Hope that's ok for the beginning, Alejandro,
  147.    sorry that I needed so much time,
  148.  
  149.                   Matthias
  150.    */
  151.  
  152. void UpdateInset(Inset* inset, bool mark_dirty = true);
  153. /* these functions return 1 if an error occured, 
  154.    otherwise 0 */
  155. // Now they work only for updatable insets. [Alejandro 080596]
  156. bool LockInset(UpdatableInset* inset);
  157. void ToggleLockedInsetCursor(long x, long y, int asc, int desc);
  158. void FitLockedInsetCursor(long x, long y, int asc, int desc);
  159. int UnlockInset(UpdatableInset* inset);
  160. void LockedInsetStoreUndo(Undo::undo_kind kind);
  161.  
  162. /* this is for asyncron updating. UpdateInsetUpdateList will be called
  163.    automatically from LyX. Just insert the Inset into the Updatelist */
  164. void UpdateInsetUpdateList();
  165. void PutInsetIntoInsetUpdateList(Inset* inset);
  166.  
  167. InsetUpdateStruct *InsetUpdateList = NULL;
  168.  
  169.  
  170. /*
  171.   -----------------------------------------------------------------------
  172.  */
  173.  
  174. /* some function prototypes */
  175.  
  176. void GotoNote();
  177. void OpenStuff();
  178. void ToggleFloat();
  179. void MenuUndo();
  180. void MenuRedo();
  181. void HyphenationPoint();
  182. void HFill();
  183. void Newline();
  184. void ProtectedBlank();
  185. void CopyCB();
  186. int RunLinuxDoc(int, LString const &);
  187. void MenuWrite(Buffer* buf);
  188. void MenuWriteAs(Buffer *buffer);
  189. void MenuReload(Buffer *buf);
  190. void MenuLayoutSave();
  191.  
  192. unsigned char GetCurrentTextClass()
  193. {
  194.     return current_view->currentBuffer()->params.textclass;
  195. }
  196.  
  197.  
  198. // How should this actually work? Should it prohibit input in all BufferViews,
  199. // or just in the current one? If "just the current one", then it should be
  200. // placed in BufferView. If "all BufferViews" then LyXGUI (I think) should
  201. // run "ProhibitInput" on all LyXViews which will run prohibitInput on all
  202. // BufferViews. Or is it perhaps just the (input in) BufferViews in the
  203. // current LyxView that should be prohibited (Lgb) (This applies to
  204. // "AllowInput" as well.)
  205. void ProhibitInput()
  206. {
  207.     input_prohibited = true;
  208.     if (current_view->getScreen())
  209.         current_view->getScreen()->HideCursor();
  210.  
  211.     static Cursor cursor;
  212.     static bool cursor_undefined = true;
  213.    
  214.     if (cursor_undefined){
  215.         cursor = XCreateFontCursor(fl_display, XC_watch);
  216.         XFlush(fl_display);
  217.         cursor_undefined = false;
  218.     }
  219.    
  220.     /* set the cursor to the watch for all forms and the canvas */ 
  221.     XDefineCursor(fl_display, fd_form_main->form_main->window, cursor);
  222.     if (fd_form_paragraph->form_paragraph->visible)
  223.         XDefineCursor(fl_display,
  224.                   fd_form_paragraph->form_paragraph->window,
  225.                   cursor);
  226.     if (fd_form_character->form_character->visible)
  227.         XDefineCursor(fl_display,
  228.                   fd_form_character->form_character->window,
  229.                   cursor);
  230.  
  231.     XFlush(fl_display);
  232.     fl_deactivate_all_forms();
  233. }
  234.  
  235.  
  236. // Should find a way to move this into BufferView.C
  237. void SetXtermCursor(Window win)
  238. {
  239.     static Cursor cursor;
  240.     static char cursor_undefined = 1;
  241.     if (cursor_undefined){
  242.         cursor = XCreateFontCursor(fl_display, XC_xterm);
  243.         XFlush(fl_display);
  244.         cursor_undefined = 0;
  245.     }
  246.     XDefineCursor(fl_display, win, cursor);
  247.     XFlush(fl_display);
  248. }
  249.  
  250.  
  251. void AllowInput()
  252. {
  253.     input_prohibited = false;
  254.  
  255.     /* reset the cursor from the watch for all forms and the canvas */
  256.    
  257.     XUndefineCursor(fl_display, fd_form_main->form_main->window);
  258.     if (fd_form_paragraph->form_paragraph->visible)
  259.         XUndefineCursor(fl_display,
  260.                 fd_form_paragraph->form_paragraph->window);
  261.     if (fd_form_character->form_character->visible)
  262.         XUndefineCursor(fl_display,
  263.                 fd_form_character->form_character->window);
  264.     if (current_view->getWorkArea()->belowmouse)
  265.         SetXtermCursor(fd_form_main->form_main->window);
  266.  
  267.     XFlush(fl_display);
  268.     fl_activate_all_forms();
  269. }
  270.  
  271.  
  272. void FreeUpdateTimer()
  273. {
  274.     /* a real free timer would be better but I don't know 
  275.      * how to do this with xforms */
  276.     updatetimer = 0;
  277. }
  278.  
  279.  
  280. void SetUpdateTimer(float time)
  281. {
  282.     fl_set_timer(fd_form_main->timer_update, time);
  283.     updatetimer = 1;
  284. }
  285.  
  286.  
  287. void BeforeChange()
  288. {
  289.     current_view->getScreen()->ToggleSelection();
  290.     current_view->currentBuffer()->text->ClearSelection();
  291.     FreeUpdateTimer();
  292. }
  293.  
  294.  
  295. void SmallUpdate(signed char f)
  296. {
  297.     current_view->getScreen()->SmallUpdate();
  298.     if (current_view->getScreen()->TopCursorVisible()
  299.         != current_view->getScreen()->first){
  300.         current_view->currentBuffer()->update(f);
  301.         return;
  302.     }
  303.  
  304.     current_view->fitCursor();
  305.     current_view->updateScrollbar();
  306.    
  307.     if (!current_view->currentBuffer()->text->selection)
  308.         current_view->currentBuffer()->text->sel_cursor = 
  309.             current_view->currentBuffer()->text->cursor;
  310.  
  311.     if (f==1 || f==-1) {
  312.         if (current_view->currentBuffer()->isLyxClean()) {
  313.             current_view->currentBuffer()->markDirty();
  314.             minibuffer->setTimer(4);
  315.         }
  316.         else {
  317.             current_view->currentBuffer()->markDirty();
  318.         }
  319.     }
  320. }
  321.  
  322.  
  323. //
  324. // Menu callbacks
  325. //
  326.  
  327. //
  328. // File menu
  329. //
  330.  
  331. // should be moved to lyxfunc.C
  332. void MenuWrite(Buffer* buf)
  333. {
  334.     XFlush(fl_display);
  335.     if (!bufferlist.write(buf)) {
  336.         LString fname = buf->getFileName();
  337.         LString s = MakeAbsPath(fname);
  338.         if (AskQuestion(_("Save failed. Rename and try again?"),
  339.                  MakeDisplayPath(s,50),
  340.                  _("(If not, document is not saved.)"))) {
  341.             MenuWriteAs(buf);
  342.         }
  343.     } else {
  344.         lastfiles->newFile(buf->getFileName());
  345.     }
  346. }
  347.  
  348.  
  349. // should be moved to BufferView.C
  350. void MenuWriteAs(Buffer *buffer)
  351. {
  352.     if (!buffer->text) return;
  353.  
  354.     LString fname = buffer->getFileName();
  355.     LString oldname = fname;
  356.     LyXFileDlg fileDlg;
  357.  
  358.     ProhibitInput();
  359.     fileDlg.SetButton(0, _("Documents"), lyxrc->document_path);
  360.     fileDlg.SetButton(1, _("Templates"), lyxrc->template_path);
  361.  
  362.     if (!IsLyXFilename(fname))
  363.         fname += ".lyx";
  364.  
  365.     fname = fileDlg.Select(_("Enter Filename to Save Document as"), 
  366.                    OnlyPath(fname),
  367.                    "*.lyx", 
  368.                    OnlyFilename(fname));
  369.     AllowInput();
  370.  
  371.     if (fname.empty()) {
  372.         minibuffer->Set(_("Canceled."));
  373.         return;
  374.     }
  375.  
  376.     // Make sure the absolute filename ends with appropriate suffix
  377.     LString s= MakeAbsPath(fname);
  378.     if (!IsLyXFilename(s))
  379.         s += ".lyx";
  380.  
  381.     // Same name as we have already?
  382.     if (s == oldname) {
  383.         if (!AskQuestion(_("Same name as document already has:"),
  384.                  MakeDisplayPath(s,50),
  385.                  _("Save anyway?")))
  386.             return;
  387.         // Falls through to name change and save
  388.     } 
  389.     // No, but do we have another file with this name open?
  390.     else if (bufferlist.exists(s)) {
  391.         if (AskQuestion(_("Another document with same name open!"),
  392.                 MakeDisplayPath(s,50),
  393.                 _("Replace with current document?")))
  394.             {
  395.                 bufferlist.close(bufferlist.getBuffer(s));
  396.  
  397.                 // Ok, change the name of the buffer, but don't save!
  398.                 buffer->setFileName(s);
  399.                 buffer->markDirty();
  400.  
  401.                 minibuffer->Set(_("Document renamed to '"),
  402.                         MakeDisplayPath(s),
  403.                         _("', but not saved..."));
  404.             }
  405.         return;
  406.     } // Check whether the file exists
  407.     else {
  408.         FileInfo myfile(s);
  409.         if (myfile.isOK() && !AskQuestion(_("Document already exists:"), 
  410.                           MakeDisplayPath(s,50),
  411.                           _("Replace file?")))
  412.             return;
  413.     }
  414.  
  415.     // Ok, change the name of the buffer
  416.     buffer->setFileName(s);
  417.     buffer->markDirty();
  418.     // And save
  419.     // Small bug: If the save fails, we have irreversible changed the name
  420.     // of the document.
  421.     MenuWrite(buffer);
  422. }    
  423.  
  424.  
  425. int MenuRunLaTeX(Buffer *buffer)
  426. {
  427.     int ret;
  428.  
  429.     if (buffer->isLinuxDoc())
  430.         ret = RunLinuxDoc(1, buffer->getFileName());
  431.     else 
  432.         ret = buffer->runLaTeX();
  433.    
  434.     if (ret > 0) {
  435.         LString s;
  436.         LString t;
  437.         if (ret == 1) {
  438.             s = _("One error detected");
  439.             t = _("You should try to fix it.");
  440.         } else {
  441.             s += ret;
  442.             s += _(" errors detected.");
  443.             t = _("You should try to fix them.");
  444.         }
  445.         WriteAlert(_("There where errors during the LaTeX run."),
  446.                s, t);
  447.     }
  448.     return ret;
  449. }
  450.  
  451.  
  452. int MenuRunChktex(Buffer *buffer)
  453. {
  454.     int ret;
  455.  
  456.     if (buffer->isLinuxDoc()) {
  457.         WriteAlert(_("Chktex is no fun for LinuxDoc."));
  458.         return 0;
  459.     } else 
  460.         ret = buffer->runChktex();
  461.    
  462.     if (ret >= 0) {
  463.         LString s;
  464.         LString t;
  465.         if (ret == 0) {
  466.             s = _("No warnings found.");
  467.         } else if (ret == 1) {
  468.             s = _("One warning found.");
  469.             t = _("Use 'Edit->Go to Error' to find it.");
  470.         } else {
  471.             s += ret;
  472.             s += _(" warnings found.");
  473.             t = _("Use 'Edit->Go to Error' to find them.");
  474.         }
  475.         WriteAlert(_("Chktex run successfully"), s, t);
  476.     } else {
  477.         WriteAlert(_("Error!"),_("It seems chktex does not work."));
  478.     }
  479.     return ret;
  480. }
  481.  
  482.  
  483. int MakeDVIOutput(Buffer *buffer)
  484. {
  485.     if (!(buffer->text))
  486.         return 1;
  487.  
  488.     int ret = 0;
  489.  
  490.     LString path = OnlyPath(buffer->getFileName());
  491.     if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) {
  492.         path = buffer->tmppath;
  493.     }
  494.     if (!buffer->isDviClean()) {
  495.         //PathPush(path);
  496.         Path p(path);
  497.         ret = MenuRunLaTeX(buffer);
  498.         //PathPop();
  499.     }
  500.     return ret;
  501. }
  502.  
  503.  
  504. /* wait == false means don't wait for termination */
  505. /* wait == true means wait for termination       */
  506. // The bool should be placed last on the argument line. (Lgb)
  507. // Returns false if we fail.
  508. bool RunScript(Buffer *buffer, bool wait,
  509.            LString const & command, LString const & orgname = LString(),
  510.            bool need_shell=true)
  511. {
  512.     LString path;
  513.     LString cmd;
  514.     LString name= orgname;
  515.     
  516.     if (MakeDVIOutput(buffer) > 0)
  517.         return false;
  518.     /* get DVI-Filename */
  519.     if (name.empty())
  520.         name = ChangeExtension(buffer->getFileName(),
  521.                        ".dvi", true);
  522.  
  523.     path = OnlyPath(name);
  524.     if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) {
  525.         path = buffer->tmppath;
  526.     }
  527.     //PathPush(path);
  528.     Path p(path);
  529.  
  530.     cmd = command + ' ' + SpaceLess(name);
  531.     if (need_shell) {
  532.         if (!wait)
  533.             cmd += " &";
  534.         
  535.         minibuffer->Set(_("Executing command:"), cmd);
  536.         Systemcalls one(Systemcalls::System, cmd);
  537.     } else {
  538.         minibuffer->Set(_("Executing command:"), cmd);
  539.         Systemcalls one(wait ? Systemcalls::Wait
  540.                                      : Systemcalls::DontWait, cmd);
  541.     }
  542.     //PathPop();
  543.     return true;
  544. }
  545.  
  546.  
  547. // Returns false if we fail
  548. bool MenuRunDvips(Buffer *buffer, bool wait=false)
  549. {
  550.     if (!buffer->text)
  551.         return false;
  552.  
  553.     ProhibitInput();
  554.  
  555.     // Generate dvi file
  556.         if (MakeDVIOutput(buffer) > 0) {
  557.                 AllowInput();
  558.         return false;
  559.         }
  560.     // Generate postscript file
  561.     LString ps = ChangeExtension (buffer->getFileName(),
  562.                       ".ps_tmp", true);
  563.  
  564.     LString paper;
  565.     
  566.     char real_papersize = buffer->params.papersize;
  567.     if (real_papersize == PAPER_DEFAULT)
  568.         real_papersize = lyxrc->default_papersize;
  569.  
  570.     switch (real_papersize) {
  571.     case PAPER_USLETTER:
  572.         paper = "letter";
  573.         break;
  574.     case PAPER_A3PAPER:
  575.         paper = "a3";
  576.         break;
  577.     case PAPER_A4PAPER:
  578.         paper = "a4";
  579.         break;
  580.     case PAPER_A5PAPER:
  581.         paper = "a5";
  582.         break;
  583.     case PAPER_B5PAPER:
  584.         paper = "b5";
  585.         break;
  586.     case PAPER_EXECUTIVEPAPER:
  587.         paper = "foolscap";
  588.         break;
  589.     case PAPER_LEGALPAPER:
  590.         paper = "legal";
  591.         break;
  592.     default: /* If nothing else fits, keep an empty value... */
  593.         break;
  594.     }
  595.  
  596.     // Make postscript file.
  597.     LString command = "dvips -o " + SpaceLess(ps);
  598.     // dvips won't accept -t letter -t landscape.  In all other
  599.     // cases, include the paper size explicitly.
  600.     if (!paper.empty() 
  601.         && (real_papersize != PAPER_USLETTER ||
  602.         buffer->params.orientation == ORIENTATION_PORTRAIT))
  603.       command += " -t " + paper;
  604.     if (buffer->params.orientation == ORIENTATION_LANDSCAPE)
  605.         command += " -t landscape";
  606.     // push directorypath, if necessary 
  607.         LString path = OnlyPath(buffer->getFileName());
  608.         if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)){
  609.         path = buffer->tmppath;
  610.         }
  611.         //PathPush(path);
  612.     Path p(path);
  613.     bool ret = RunScript(buffer, wait, command);
  614.     AllowInput();
  615.         //PathPop();
  616.     return ret;
  617. }
  618.  
  619.  
  620. // Returns false if we fail
  621. bool MenuPreviewPS(Buffer *buffer)
  622. {
  623.     if (!buffer->text)
  624.         return false;
  625.  
  626.     // Generate postscript file
  627.     if (!MenuRunDvips(buffer, true)) {
  628.         return false;
  629.     }
  630.  
  631.     // Start postscript viewer
  632.     ProhibitInput();
  633.     LString ps = ChangeExtension (buffer->getFileName(),
  634.                       ".ps_tmp", true);
  635.     // push directorypath, if necessary 
  636.         LString path = OnlyPath(buffer->getFileName());
  637.         if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)){
  638.         path = buffer->tmppath;
  639.         }
  640.         //PathPush(path);
  641.     Path p(path);
  642.     bool ret = RunScript(buffer, false, lyxrc->view_ps_command, ps);
  643.         //PathPop();
  644.     AllowInput();
  645.     return ret;
  646. }
  647.  
  648.  
  649. void MenuFax(Buffer *buffer)
  650. {
  651.     if (!buffer->text)
  652.         return;
  653.  
  654.     // Generate postscript file
  655.     if (!MenuRunDvips(buffer, true)) {
  656.         return;
  657.     }
  658.  
  659.     // Send fax
  660.     LString ps = ChangeExtension (buffer->getFileName(), ".ps_tmp", true);
  661.     LString path = OnlyPath (buffer->getFileName());
  662.     if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) {
  663.         path = buffer->tmppath;
  664.     }
  665.     //PathPush(path);
  666.     Path p(path);
  667.     if (!lyxrc->fax_program.empty()) {
  668.         LString help2;
  669.         char *ptr1, *ptr2;
  670.         char *help = new char[lyxrc->fax_program.length()+1]; // note +1
  671.         lyxrc->fax_program.copy(help, LString::npos);
  672.         help[lyxrc->fax_program.length()] = 0; // add terminator
  673.         if ((ptr1=strstr(help,"$$FName"))) {
  674.             ptr2=strchr(ptr1+1,'\'');
  675.             *ptr1 = 0;
  676.             help2 = help + ' ' + ps +' ' + (ptr2) + " &";
  677.             Systemcalls one(Systemcalls::System, help2);
  678.         } else {
  679.             help2 = lyxrc->fax_program +" &";
  680.             Systemcalls one(Systemcalls::System, help2);
  681.         }
  682.         delete [] help;
  683.     } else
  684.         send_fax(ps,lyxrc->fax_command);
  685.     //PathPop();
  686. }
  687.  
  688.  
  689. // Returns false if we fail
  690. bool MenuPreview(Buffer *buffer)
  691. {
  692.     if (!buffer->text)
  693.         return false;
  694.    
  695.     LString paper;
  696.     
  697.     char real_papersize = buffer->params.papersize;
  698.     if (real_papersize == PAPER_DEFAULT)
  699.         real_papersize = lyxrc->default_papersize;
  700.    
  701.     switch (real_papersize) {
  702.     case PAPER_USLETTER:
  703.         paper = "us";
  704.         break;
  705.     case PAPER_A3PAPER:
  706.         paper = "a3";
  707.         break;
  708.     case PAPER_A4PAPER:
  709.         paper = "a4";
  710.         break;
  711.     case PAPER_A5PAPER:
  712.         paper = "a5";
  713.         break;
  714.     case PAPER_B5PAPER:
  715.         paper = "b5";
  716.         break;
  717.     case PAPER_EXECUTIVEPAPER:
  718.         paper = "foolscap";
  719.         break;
  720.     case PAPER_LEGALPAPER:
  721.         paper = "legal";
  722.         break;
  723.     default: /* If nothing else fits, keep the empty value */
  724.         break;
  725.     }
  726.    
  727.     if (paper.empty()) {
  728.         if (buffer->params.orientation == ORIENTATION_LANDSCAPE)
  729.             // we HAVE to give a size when the page is in
  730.             // landscape, so use USletter.        
  731.             paper = " -paper usr";
  732.     } else {
  733.         paper = " -paper " + paper;
  734.         if (buffer->params.orientation == ORIENTATION_LANDSCAPE)
  735.             paper+='r';
  736.     }
  737.  
  738.     // push directorypath, if necessary 
  739.         LString path = OnlyPath(buffer->getFileName());
  740.         if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)){
  741.         path = buffer->tmppath;
  742.         }
  743.         //PathPush(path);
  744.     Path p(path);
  745.     // Run dvi-viewer
  746.     LString command = lyxrc->view_dvi_command + paper ;
  747. #ifndef __EMX__
  748.     bool ret = RunScript(buffer, false, command);
  749. #else
  750.     bool ret = RunScript(buffer, false, command, LString(), false);
  751. #endif
  752.         //PathPop();
  753.     return ret;
  754. }
  755.  
  756.  
  757. void MenuMakeLaTeX(Buffer *buffer)
  758. {
  759.     if (buffer->text) {
  760.         // Get LaTeX-Filename
  761.         LString s = SpaceLess(ChangeExtension(
  762.                         buffer->getFileName(),
  763.                         ".tex", false));
  764.  
  765.         if (buffer->isLinuxDoc())
  766.             RunLinuxDoc(0, buffer->getFileName());
  767.         else
  768.             buffer->makeLaTeXFile(s, LString(), true);
  769.         minibuffer->Set(_("Nice LaTeX file saved as"),
  770.                 MakeDisplayPath(s));
  771.         buffer->markDviDirty();
  772.     }
  773. }
  774.  
  775.  
  776. void MenuMakeLinuxDoc(Buffer *buffer)
  777. {
  778.     if (buffer->text) {
  779.  
  780.         if (!buffer->isLinuxDoc()) {
  781.             WriteAlert(_("Error!"), _("Document class must be linuxdoc."));
  782.             return;
  783.         }
  784.  
  785.         // Get LinuxDoc-Filename
  786.         LString s = ChangeExtension (buffer->getFileName(), 
  787.                          ".sgml", false);
  788.         minibuffer->Set(_("Building LinuxDoc SGML file `"),
  789.                 MakeDisplayPath(s), "'..."); 
  790.  
  791.         buffer->makeLinuxDocFile(s, 65);
  792.                 buffer->redraw();
  793.         minibuffer->Set(_("LinuxDoc SGML file"),
  794.                 MakeDisplayPath(s), _("built")); 
  795.     }
  796. }
  797.  
  798.  
  799. void MenuMakeAscii(Buffer *buffer)
  800. {
  801.     if (!buffer->text) return;
  802.     
  803.     /* get LaTeX-Filename */
  804.     LString s = ChangeExtension (buffer->getFileName(),
  805.                      ".txt", false);
  806.     buffer->writeFileAscii(s, lyxrc->ascii_linelen);
  807.     
  808.     minibuffer->Set(_("Ascii file saved as"), MakeDisplayPath(s));
  809. }
  810.  
  811.  
  812. void MenuPrint(Buffer *buffer)
  813. {
  814.     LString input_file;
  815.  
  816.     if (!buffer->text) 
  817.         return;
  818.     
  819.     input_file = ChangeExtension(buffer->getFileName(),
  820.                      lyxrc->print_file_extension,
  821.                      true);
  822.     fl_set_input(fd_form_print->input_file, input_file.c_str());
  823.     
  824.     if (fd_form_print->form_print->visible) {
  825.         fl_raise_form(fd_form_print->form_print);
  826.     } else {
  827.         fl_show_form(fd_form_print->form_print,
  828.                  FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
  829.                  _("Print"));
  830.     }
  831. }
  832.  
  833.  
  834. void QuitLyX()
  835. {
  836.     lyxerr.debug("Running QuitLyX.");
  837.  
  838.     if (!bufferlist.QwriteAll()) return;
  839.     
  840.     lastfiles->writeFile(lyxrc->lastfiles);
  841.  
  842.     // Set a flag that we do quitting from the program,
  843.     // so no refreshes are necessary.
  844.     quitting = true;
  845.  
  846.     // close buffers first
  847.     bufferlist.closeAll();
  848.  
  849.     // do any other cleanup procedures now
  850.     lyxerr.debug("Deleting tmp dir " + system_tempdir);
  851.  
  852.     DestroyLyXTmpDir(system_tempdir);
  853.  
  854.     finished = true;
  855. }
  856.  
  857.  
  858. void AutoSave()
  859.     // should probably be moved into BufferList (Lgb)
  860.     // Perfect target for a thread...
  861. {
  862.     if (!current_view->getScreen() || !current_view->available())
  863.         return;
  864.     
  865.     if (current_view->currentBuffer()->isBakClean()
  866.         || current_view->currentBuffer()->isReadonly())
  867.         return;
  868.     
  869.     LString fname;
  870.     
  871.     minibuffer->Set(_("Autosaving current document..."));
  872.     
  873.     // create autosave filename
  874.     fname =    OnlyPath(current_view->currentBuffer()->getFileName());
  875.     fname += "#";
  876.     fname += OnlyFilename(current_view->currentBuffer()->getFileName());
  877.     fname += "#";
  878.     
  879.     // tmp_ret will be located (usually) in /tmp
  880.     // will that we a problem?
  881.     LString tmp_ret = tmpnam(NULL);
  882.  
  883.     pid_t pid = fork(); // If you want to debug the autosave
  884.     // you should set pid to -1, and comment out the
  885.     // fork.
  886.     if (pid == 0 || pid == -1) {
  887.         // pid = -1 signifies that lyx was unable
  888.         // to fork. But we will do the save
  889.         // anyway.
  890.         bool failed = false;
  891.         if (!tmp_ret.empty()) {
  892.             current_view->currentBuffer()->writeFile(tmp_ret, 1);
  893.             // assume successful write of tmp_ret
  894.             if (rename(tmp_ret.c_str(), fname.c_str()) == -1) {
  895.                 failed = true;
  896.                 // most likely couldn't move between filesystems
  897.                 // unless write of tmp_ret failed
  898.                 // so remove tmp file (if it exists)
  899.                 remove(tmp_ret.c_str());
  900.             }
  901.         } else {
  902.             failed = true;
  903.         }
  904.         
  905.         if (failed) {
  906.             // failed to write/rename tmp_ret so try writing direct
  907.             if (!current_view->currentBuffer()->writeFile(fname,
  908.                                       1)) {
  909.                 minibuffer->Set(_("Autosave Failed!"));
  910.             }
  911.         }
  912.         if (pid == 0){
  913.             _exit(0);
  914.         }
  915.     }
  916.     
  917.     current_view->currentBuffer()->markBakClean();
  918.     current_view->getOwner()->resetAutosaveTimer();
  919. }
  920.  
  921.  
  922. //
  923. // (c) CHT Software Service GmbH
  924. // Uwe C. Schroeder
  925. //
  926. // create new file with template
  927. // SERVERCMD !
  928. //
  929. Buffer * NewLyxFile(LString const & filename)
  930. {
  931.     // Split argument by :
  932.     LString tmpname = filename;
  933.     LString name;
  934.     tmpname.split(name, ':');
  935. #warning __EMX__ FIX ME!
  936. #ifdef __EMX__ // Fix me! lyx_cb.C may not be low level enough to allow this.
  937.     if (name.length() == 1 && isalpha((unsigned char) name[0]) &&
  938.         (tmpname.prefixIs("/") || tmpname.prefixIs("\\"))) {
  939.         name += ':';
  940.         name += tmpname.token(':');
  941.         tmpname.split(':');
  942.     }
  943. #endif
  944.     lyxerr.print("Arg is " + filename);
  945.     lyxerr.print("Name is " + name);
  946.     lyxerr.print("Template is " + tmpname);
  947.  
  948.     // find a free buffer 
  949.     Buffer *tmpbuf = bufferlist.newFile(name,tmpname);
  950.     if (tmpbuf)
  951.         lastfiles->newFile(tmpbuf->getFileName());
  952.     return tmpbuf;
  953. }
  954.  
  955.  
  956. // Insert ascii file
  957. void InsertAsciiFile(bool asParagraph)
  958. {
  959.     LString fname;
  960.     LyXParagraph *tmppar;
  961.     LyXFileDlg fileDlg;
  962.  
  963.     if (!current_view->getScreen()) return;
  964.      
  965.     ProhibitInput();
  966.   
  967.     fname =    fileDlg.Select(_("File to Insert"), 
  968.                    current_view->getOwner()->currentBuffer()->filepath,
  969.                    "*");
  970.   
  971.     AllowInput();
  972.  
  973.     if (fname.empty()) return;
  974.  
  975.     FileInfo fi(fname);
  976.     FilePtr myfile(fname, FilePtr::read);
  977.  
  978.     if (!fi.exist() || !fi.readable() || !myfile()) {
  979.         WriteFSAlert(_("Error! Cannot open specified file:"),
  980.                  MakeDisplayPath(fname,50));
  981.         return;
  982.     }
  983.     
  984.     tmppar = new LyXParagraph();
  985.     tmppar->readSimpleWholeFile(myfile);
  986.     
  987.     // set the end of the string
  988.     tmppar->InsertChar(tmppar->last-1,'\0');
  989.       
  990.     // insert the string
  991.     current_view->getScreen()->HideCursor();
  992.       
  993.     // clear the selection
  994.     BeforeChange();
  995.     if (!asParagraph)
  996.         current_view->currentBuffer()->text->InsertStringA(tmppar->text);
  997.     else
  998.         current_view->currentBuffer()->text->InsertStringB(tmppar->text);
  999.     delete tmppar;
  1000.     current_view->currentBuffer()->update(1);
  1001. }
  1002.  
  1003.  
  1004. void MenuShowTableOfContents()
  1005. {
  1006.     TocUpdateCB(NULL, 0);
  1007.     if (fd_form_toc->form_toc->visible) {
  1008.         fl_raise_form(fd_form_toc->form_toc);
  1009.     } else {
  1010.         fl_show_form(fd_form_toc->form_toc,
  1011.                  FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
  1012.                  _("Table Of Contents"));
  1013.     }
  1014. }
  1015.  
  1016.  
  1017. void MenuInsertLabel()
  1018. {
  1019.     ProhibitInput();
  1020.     LString label = fl_show_input(_("Enter new label to insert:"),"");
  1021.     label.strip();
  1022.     label.frontStrip();
  1023.     if (!label.empty()) {
  1024.         InsetLabel *new_inset = new InsetLabel;
  1025.         new_inset->setContents(label);
  1026.         current_view->currentBuffer()->insertInset(new_inset);
  1027.     }
  1028.     AllowInput();
  1029. }
  1030.  
  1031.  
  1032. void MenuInsertRef()
  1033. {
  1034.     RefUpdateCB(NULL, 0);
  1035.     if (fd_form_ref->form_ref->visible) {
  1036.         fl_raise_form(fd_form_ref->form_ref);
  1037.     } else {
  1038.         fl_show_form(fd_form_ref->form_ref,
  1039.                  FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
  1040.                  _("Insert Reference"));
  1041.     }
  1042. }
  1043.  
  1044.  
  1045. void MenuPasteSelection(char at)
  1046. {
  1047.     if (!current_view->getScreen())
  1048.         return;
  1049.  
  1050.     ascii_type = at;
  1051.   
  1052.     Atom data_prop = XInternAtom(fl_display, 
  1053.                      "LyX_Primary",
  1054.                      false);
  1055.     if (data_prop == None) 
  1056.         return;
  1057.     XConvertSelection(fl_display,
  1058.               XA_PRIMARY, XA_STRING, data_prop, 
  1059.               fd_form_main->form_main->window, 0);
  1060.     XFlush(fl_display);
  1061. }
  1062.  
  1063.  
  1064. void FootCB(FL_OBJECT*, long)
  1065. {
  1066.     if (!current_view->available()) return;
  1067.     
  1068.     minibuffer->Set(_("Inserting Footnote..."));
  1069.     current_view->getScreen()->HideCursor();
  1070.     current_view->currentBuffer()->update(-2);
  1071.     current_view->currentBuffer()->text
  1072.         ->InsertFootnoteEnvironment(LyXParagraph::FOOTNOTE);
  1073.     current_view->currentBuffer()->update(1);
  1074. }
  1075.  
  1076.  
  1077. void LayoutsCB(int sel, void *)
  1078. {
  1079.     LString tmp;
  1080.     tmp += sel;
  1081.     current_view->getOwner()->getLyXFunc()->Dispatch(LFUN_LAYOUTNO,
  1082.                              tmp.c_str());
  1083. }
  1084.  
  1085.  
  1086. /*
  1087.  * SGML support:
  1088.  * (flag == -1) import SGML file
  1089.  * (flag == 0) make TeX output
  1090.  * (flag == 1) make dvi output
  1091.  */
  1092. int RunLinuxDoc(int flag, LString const & filename)
  1093. {
  1094.     LString name;
  1095.     LString s2;
  1096.     LString path;
  1097.     LString add_flags;
  1098.  
  1099.     int errorcode = 0;
  1100.  
  1101.     /* generate a path-less extension name */
  1102.     name = ChangeExtension (filename, ".sgml", true);
  1103.     path = OnlyPath (filename);
  1104.     if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) {
  1105.         path = current_view->currentBuffer()->tmppath;
  1106.     }
  1107.     //PathPush (path);
  1108.     Path p(path);
  1109.     
  1110.     if (flag != -1) {
  1111.         if (!current_view->available())
  1112.             return 0;
  1113.         current_view->currentBuffer()->makeLinuxDocFile(name,0);
  1114.         LYX_PAPER_SIZE ps = (LYX_PAPER_SIZE) current_view->currentBuffer()->params.papersize;
  1115.         switch (ps) {
  1116.         case PAPER_A4PAPER:  add_flags = "-p a4";     break;
  1117.         case PAPER_USLETTER: add_flags = "-p letter"; break;
  1118.         default: /* nothing to be done yet ;-) */     break; 
  1119.         }
  1120.     }
  1121.     
  1122.     ProhibitInput();
  1123.     
  1124.     Systemcalls one;
  1125.     switch (flag) {
  1126.     case -1: /* Import file */
  1127.         minibuffer->Set(_("Importing LinuxDoc SGML file `"), 
  1128.                 MakeDisplayPath(filename), "'...");
  1129.         s2 = "sgml2lyx " + lyxrc->sgml_extra_options + ' ' 
  1130.             + name;
  1131.         if (one.Startscript(Systemcalls::System, s2)) 
  1132.             errorcode = 1;
  1133.         break;
  1134.     case 0: /* TeX output asked */
  1135.         minibuffer->Set(_("Converting LinuxDoc SGML to TeX file..."));
  1136.         s2 = "sgml2latex " + add_flags + " -o tex "
  1137.             + lyxrc->sgml_extra_options + ' ' + name;
  1138.         if (one.Startscript(Systemcalls::System, s2)) 
  1139.             errorcode = 1;
  1140.         break;
  1141.     case 1: /* dvi output asked */
  1142.         minibuffer->Set(_("Converting LinuxDoc SGML to dvi file..."));
  1143.         s2 = "sgml2latex " + add_flags + " -o dvi "
  1144.             + lyxrc->sgml_extra_options + ' ' + name;
  1145.         if (one.Startscript(Systemcalls::System, s2)) {
  1146.             errorcode = 1;
  1147.         } else
  1148.             current_view->currentBuffer()->markDviClean();
  1149.         break;
  1150.     default: /* unknown output */
  1151.         break;
  1152.     }
  1153.     
  1154.     //PathPop();
  1155.     AllowInput();
  1156.     return errorcode;
  1157. }
  1158.  
  1159.  
  1160. void AllFloats(char flag, char figmar)
  1161. {
  1162.     if (!current_view->available())    return;
  1163.    
  1164.     LyXCursor cursor = current_view->currentBuffer()->text->cursor;
  1165.  
  1166.     if (!flag && cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE
  1167.         && ((figmar 
  1168.          && cursor.par->footnotekind != LyXParagraph::FOOTNOTE 
  1169.          && cursor.par->footnotekind != LyXParagraph::MARGIN)
  1170.         || (!figmar
  1171.             && cursor.par->footnotekind != LyXParagraph::FIG 
  1172.             && cursor.par->footnotekind != LyXParagraph::TAB
  1173.              && cursor.par->footnotekind != LyXParagraph::WIDE_FIG 
  1174.              && cursor.par->footnotekind != LyXParagraph::WIDE_TAB
  1175.             && cursor.par->footnotekind != LyXParagraph::ALGORITHM)))
  1176.         ToggleFloat();
  1177.     else
  1178.         BeforeChange();
  1179.  
  1180.     LyXCursor tmpcursor = cursor;
  1181.     cursor.par = tmpcursor.par->ParFromPos(tmpcursor.pos);
  1182.     cursor.pos = tmpcursor.par->PositionInParFromPos(tmpcursor.pos);
  1183.  
  1184.     LyXParagraph *par = current_view->currentBuffer()->paragraph;
  1185.     while (par) {
  1186.         if (flag) {
  1187.             if (par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE
  1188.                 && ((figmar &&
  1189.                  par->footnotekind != LyXParagraph::FOOTNOTE 
  1190.                  &&
  1191.                  par->footnotekind !=  LyXParagraph::MARGIN)
  1192.                 || (!figmar &&
  1193.                     par->footnotekind != LyXParagraph::FIG 
  1194.                     &&
  1195.                     par->footnotekind != LyXParagraph::TAB
  1196.                     &&
  1197.                     par->footnotekind != LyXParagraph::WIDE_FIG 
  1198.                     &&
  1199.                     par->footnotekind != LyXParagraph::WIDE_TAB
  1200.                     &&
  1201.                     par->footnotekind != LyXParagraph::ALGORITHM
  1202.                     ))) {
  1203.                 if (par->previous
  1204.                     && par->previous->footnoteflag !=
  1205.                     LyXParagraph::CLOSED_FOOTNOTE){ /* should be */ 
  1206.                     current_view->currentBuffer()->text->SetCursorIntern(par->previous,
  1207.                                                  0);
  1208.                     current_view->currentBuffer()->text->OpenFootnote();
  1209.                 }
  1210.             }
  1211.         } else  {
  1212.             if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
  1213.                 && ((figmar 
  1214.                  &&
  1215.                  par->footnotekind != LyXParagraph::FOOTNOTE 
  1216.                  &&
  1217.                  par->footnotekind !=  LyXParagraph::MARGIN
  1218.                     )
  1219.                 ||
  1220.                 (!figmar
  1221.                  &&
  1222.                  par->footnotekind != LyXParagraph::FIG 
  1223.                  &&
  1224.                  par->footnotekind != LyXParagraph::TAB
  1225.                  &&
  1226.                  par->footnotekind != LyXParagraph::WIDE_FIG 
  1227.                  &&
  1228.                  par->footnotekind != LyXParagraph::WIDE_TAB
  1229.                  &&
  1230.                  par->footnotekind != LyXParagraph::ALGORITHM
  1231.                     )
  1232.                     )
  1233.                 ){
  1234.                 current_view->currentBuffer()->text->SetCursorIntern(par, 0);
  1235.                 current_view->currentBuffer()->text->CloseFootnote();
  1236.             }
  1237.         }
  1238.         par = par->next;
  1239.     }
  1240.     
  1241.     current_view->currentBuffer()->text->SetCursorIntern(cursor.par, cursor.pos);
  1242.     current_view->redraw();
  1243.     current_view->fitCursor();
  1244.     current_view->updateScrollbar();
  1245. }
  1246.  
  1247.  
  1248. void MenuLayoutCharacter()
  1249. {
  1250.     if (fd_form_character->form_character->visible) {
  1251.         fl_raise_form(fd_form_character->form_character);
  1252.     } else {
  1253.         fl_show_form(fd_form_character->form_character,
  1254.                  FL_PLACE_MOUSE | FL_FREE_SIZE,FL_FULLBORDER,
  1255.                  _("Character Style"));
  1256.     }
  1257. }
  1258.  
  1259.  
  1260. inline void DeactivateParagraphButtons ()
  1261. {
  1262.     fl_deactivate_object (fd_form_paragraph->button_ok);
  1263.     fl_deactivate_object (fd_form_paragraph->button_apply);
  1264.     fl_set_object_lcol (fd_form_paragraph->button_ok, FL_INACTIVE);
  1265.     fl_set_object_lcol (fd_form_paragraph->button_apply, FL_INACTIVE);
  1266. }
  1267.  
  1268. inline void ActivateParagraphButtons ()
  1269. {
  1270.     fl_activate_object (fd_form_paragraph->button_ok);
  1271.     fl_activate_object (fd_form_paragraph->button_apply);
  1272.     fl_set_object_lcol (fd_form_paragraph->button_ok, FL_BLACK);
  1273.     fl_set_object_lcol (fd_form_paragraph->button_apply, FL_BLACK);
  1274. }
  1275.  
  1276. inline void DisableParagraphLayout ()
  1277. {
  1278.         DeactivateParagraphButtons();
  1279.     fl_deactivate_object (fd_form_paragraph->input_labelwidth);
  1280.     fl_deactivate_object (fd_form_paragraph->check_lines_top);
  1281.     fl_deactivate_object (fd_form_paragraph->check_lines_bottom);
  1282.     fl_deactivate_object (fd_form_paragraph->check_pagebreaks_top);
  1283.     fl_deactivate_object (fd_form_paragraph->check_pagebreaks_bottom);
  1284.     fl_deactivate_object (fd_form_paragraph->check_noindent);
  1285.     fl_deactivate_object (fd_form_paragraph->group_radio_alignment);
  1286.     fl_deactivate_object (fd_form_paragraph->radio_align_right);
  1287.     fl_deactivate_object (fd_form_paragraph->radio_align_left);
  1288.     fl_deactivate_object (fd_form_paragraph->radio_align_block);
  1289.     fl_deactivate_object (fd_form_paragraph->radio_align_center);
  1290.     fl_deactivate_object (fd_form_paragraph->input_space_above);
  1291.     fl_deactivate_object (fd_form_paragraph->input_space_below);
  1292.     fl_deactivate_object (fd_form_paragraph->choice_space_above);
  1293.     fl_deactivate_object (fd_form_paragraph->choice_space_below);
  1294.     fl_deactivate_object (fd_form_paragraph->check_space_above);
  1295.     fl_deactivate_object (fd_form_paragraph->check_space_below);
  1296. }
  1297.  
  1298. inline void EnableParagraphLayout ()
  1299. {
  1300.         ActivateParagraphButtons();
  1301.     fl_activate_object (fd_form_paragraph->input_labelwidth);
  1302.     fl_activate_object (fd_form_paragraph->check_lines_top);
  1303.     fl_activate_object (fd_form_paragraph->check_lines_bottom);
  1304.     fl_activate_object (fd_form_paragraph->check_pagebreaks_top);
  1305.     fl_activate_object (fd_form_paragraph->check_pagebreaks_bottom);
  1306.     fl_activate_object (fd_form_paragraph->check_noindent);
  1307.     fl_activate_object (fd_form_paragraph->group_radio_alignment);
  1308.     fl_activate_object (fd_form_paragraph->radio_align_right);
  1309.     fl_activate_object (fd_form_paragraph->radio_align_left);
  1310.     fl_activate_object (fd_form_paragraph->radio_align_block);
  1311.     fl_activate_object (fd_form_paragraph->radio_align_center);
  1312.     fl_activate_object (fd_form_paragraph->input_space_above);
  1313.     fl_activate_object (fd_form_paragraph->input_space_below);
  1314.     fl_activate_object (fd_form_paragraph->choice_space_above);
  1315.     fl_activate_object (fd_form_paragraph->choice_space_below);
  1316.     fl_activate_object (fd_form_paragraph->check_space_above);
  1317.     fl_activate_object (fd_form_paragraph->check_space_below);
  1318. }
  1319.  
  1320. bool UpdateLayoutParagraph()
  1321. {
  1322.     if (!current_view->getScreen() || !current_view->available()) {
  1323.         if (fd_form_paragraph->form_paragraph->visible) 
  1324.             fl_hide_form(fd_form_paragraph->form_paragraph);
  1325.         return false;
  1326.     }
  1327.  
  1328.     Buffer * buf = current_view->currentBuffer();
  1329.  
  1330.     fl_set_input(fd_form_paragraph->input_labelwidth,
  1331.              buf->text->cursor.par->GetLabelWidthString().c_str());
  1332.     fl_set_button(fd_form_paragraph->radio_align_right, 0);
  1333.     fl_set_button(fd_form_paragraph->radio_align_left, 0);
  1334.     fl_set_button(fd_form_paragraph->radio_align_center, 0);
  1335.     fl_set_button(fd_form_paragraph->radio_align_block, 0);
  1336.  
  1337.     int align = buf->text->cursor.par->GetAlign();
  1338.     if (align == LYX_ALIGN_LAYOUT)
  1339.         align =    lyxstyle.Style(buf->params.textclass,
  1340.                        buf->text->cursor.par->GetLayout())->align;
  1341.      
  1342.     switch (align) {
  1343.     case LYX_ALIGN_RIGHT:
  1344.         fl_set_button(fd_form_paragraph->radio_align_right, 1);
  1345.         break;
  1346.     case LYX_ALIGN_LEFT:
  1347.         fl_set_button(fd_form_paragraph->radio_align_left, 1);
  1348.         break;
  1349.     case LYX_ALIGN_CENTER:
  1350.         fl_set_button(fd_form_paragraph->radio_align_center, 1);
  1351.         break;
  1352.     default:
  1353.         fl_set_button(fd_form_paragraph->radio_align_block, 1);
  1354.         break;
  1355.     }
  1356.      
  1357.     fl_set_button(fd_form_paragraph->check_lines_top,
  1358.               buf->text->cursor.par->FirstPhysicalPar()->line_top);
  1359.     fl_set_button(fd_form_paragraph->check_lines_bottom,
  1360.               buf->text->cursor.par->FirstPhysicalPar()->line_bottom);
  1361.     fl_set_button(fd_form_paragraph->check_pagebreaks_top,
  1362.               buf->text->cursor.par->FirstPhysicalPar()->pagebreak_top);
  1363.     fl_set_button(fd_form_paragraph->check_pagebreaks_bottom,
  1364.               buf->text->cursor.par->FirstPhysicalPar()->pagebreak_bottom);
  1365.     fl_set_button(fd_form_paragraph->check_noindent,
  1366.               buf->text->cursor.par->FirstPhysicalPar()->noindent);
  1367.     fl_set_input (fd_form_paragraph->input_space_above, "");
  1368.     
  1369.     switch (buf->text->cursor.par->FirstPhysicalPar()->added_space_top.kind()) {
  1370.     case VSpace::NONE:
  1371.         fl_set_choice (fd_form_paragraph->choice_space_above,
  1372.                    1);
  1373.         break;
  1374.     case VSpace::DEFSKIP:
  1375.         fl_set_choice (fd_form_paragraph->choice_space_above,
  1376.                    2);
  1377.         break;
  1378.     case VSpace::SMALLSKIP:
  1379.         fl_set_choice (fd_form_paragraph->choice_space_above,
  1380.                    3);
  1381.         break;
  1382.     case VSpace::MEDSKIP:
  1383.         fl_set_choice (fd_form_paragraph->choice_space_above,
  1384.                    4);
  1385.         break;
  1386.     case VSpace::BIGSKIP:
  1387.         fl_set_choice (fd_form_paragraph->choice_space_above,
  1388.                    5);
  1389.         break;
  1390.     case VSpace::VFILL:
  1391.         fl_set_choice (fd_form_paragraph->choice_space_above,
  1392.                    6);
  1393.         break;
  1394.     case VSpace::LENGTH:
  1395.         fl_set_choice (fd_form_paragraph->choice_space_above,
  1396.                    7); 
  1397.         fl_set_input  (fd_form_paragraph->input_space_above, 
  1398.                    buf->text->cursor.par->FirstPhysicalPar()->added_space_top.length().asString().c_str());
  1399.         break;
  1400.     }
  1401.     fl_set_button (fd_form_paragraph->check_space_above,
  1402.                buf->text->cursor.par->FirstPhysicalPar()->added_space_top.keep());
  1403.     fl_set_input (fd_form_paragraph->input_space_below, "");
  1404.     switch (buf->text->cursor.par->FirstPhysicalPar()->added_space_bottom.kind()) {
  1405.     case VSpace::NONE:
  1406.         fl_set_choice (fd_form_paragraph->choice_space_below,
  1407.                    1);
  1408.         break;
  1409.     case VSpace::DEFSKIP:
  1410.         fl_set_choice (fd_form_paragraph->choice_space_below,
  1411.                    2);
  1412.         break;
  1413.     case VSpace::SMALLSKIP:
  1414.         fl_set_choice (fd_form_paragraph->choice_space_below,
  1415.                    3);
  1416.         break;
  1417.     case VSpace::MEDSKIP:
  1418.         fl_set_choice (fd_form_paragraph->choice_space_below,
  1419.                    4);
  1420.         break;
  1421.     case VSpace::BIGSKIP:
  1422.         fl_set_choice (fd_form_paragraph->choice_space_below,
  1423.                    5);
  1424.         break;
  1425.     case VSpace::VFILL:
  1426.         fl_set_choice (fd_form_paragraph->choice_space_below,
  1427.                    6);
  1428.         break;
  1429.     case VSpace::LENGTH:
  1430.         fl_set_choice (fd_form_paragraph->choice_space_below,
  1431.                    7); 
  1432.         fl_set_input  (fd_form_paragraph->input_space_below, 
  1433.                    buf->text->cursor.par->FirstPhysicalPar()->added_space_bottom.length().asString().c_str());
  1434.         break;
  1435.     }
  1436.     fl_set_button (fd_form_paragraph->check_space_below,
  1437.                buf->text->cursor.par->FirstPhysicalPar()->added_space_bottom.keep());
  1438.  
  1439.     fl_set_button(fd_form_paragraph->check_noindent,
  1440.               buf->text->cursor.par->FirstPhysicalPar()->noindent);
  1441.     return true;
  1442. }
  1443.  
  1444.  
  1445. void MenuLayoutParagraph()
  1446. {
  1447.     if (UpdateLayoutParagraph()) {
  1448.         if (current_view->currentBuffer()->isReadonly()) {
  1449.           DisableParagraphLayout();
  1450.           WriteAlert(_("Any changes will be ignored"),
  1451.                  _("The document is read-only:"),
  1452.                  current_view->currentBuffer()->getFileName());
  1453.         } else
  1454.             EnableParagraphLayout();
  1455.       
  1456.         if (fd_form_paragraph->form_paragraph->visible) {
  1457.             fl_raise_form(fd_form_paragraph->form_paragraph);
  1458.         } else {
  1459.             fl_show_form(fd_form_paragraph->form_paragraph,
  1460.                      FL_PLACE_MOUSE | FL_FREE_SIZE,FL_FULLBORDER,
  1461.                      _("Paragraph Environment"));
  1462.         }
  1463.     }
  1464. }
  1465.  
  1466.  
  1467. inline
  1468. void DeactivateDocumentButtons ()
  1469. {
  1470.     fl_deactivate_object (fd_form_document->button_ok);
  1471.     fl_deactivate_object (fd_form_document->button_apply);
  1472.     fl_set_object_lcol (fd_form_document->button_ok, FL_INACTIVE);
  1473.     fl_set_object_lcol (fd_form_document->button_apply, FL_INACTIVE);
  1474. }
  1475.  
  1476.  
  1477. inline
  1478. void ActivateDocumentButtons ()
  1479. {
  1480.     fl_activate_object (fd_form_document->button_ok);
  1481.     fl_activate_object (fd_form_document->button_apply);
  1482.     fl_set_object_lcol (fd_form_document->button_ok, FL_BLACK);
  1483.     fl_set_object_lcol (fd_form_document->button_apply, FL_BLACK);
  1484. }
  1485.  
  1486.  
  1487. inline
  1488. void DisableDocumentLayout ()
  1489. {
  1490.         DeactivateDocumentButtons ();
  1491.     fl_deactivate_object (fd_form_document->group_radio_separation);
  1492.     fl_deactivate_object (fd_form_document->radio_indent);
  1493.     fl_deactivate_object (fd_form_document->radio_skip);
  1494.     fl_deactivate_object (fd_form_document->choice_class);
  1495.     fl_deactivate_object (fd_form_document->choice_pagestyle);
  1496.     fl_deactivate_object (fd_form_document->choice_fonts);
  1497.     fl_deactivate_object (fd_form_document->choice_fontsize);
  1498.     fl_deactivate_object (fd_form_document->input_float_placement);
  1499.     fl_deactivate_object (fd_form_document->choice_postscript_driver);
  1500.     fl_deactivate_object (fd_form_document->choice_inputenc);
  1501.     fl_deactivate_object (fd_form_document->group_radio_sides);
  1502.     fl_deactivate_object (fd_form_document->radio_sides_one);
  1503.     fl_deactivate_object (fd_form_document->radio_sides_two);
  1504.     fl_deactivate_object (fd_form_document->group_radio_columns);
  1505.     fl_deactivate_object (fd_form_document->radio_columns_one);
  1506.     fl_deactivate_object (fd_form_document->radio_columns_two);
  1507.     fl_deactivate_object (fd_form_document->input_extra);
  1508.     fl_deactivate_object (fd_form_document->choice_language);
  1509.     combo_language->deactivate();
  1510.     fl_deactivate_object (fd_form_document->input_default_skip);
  1511.     fl_deactivate_object (fd_form_document->choice_default_skip);
  1512.     fl_deactivate_object (fd_form_document->slider_secnumdepth);
  1513.     fl_deactivate_object (fd_form_document->slider_tocdepth);
  1514.     fl_deactivate_object (fd_form_document->choice_spacing);
  1515.     fl_deactivate_object (fd_form_document->check_use_amsmath);
  1516. }
  1517.  
  1518.  
  1519. inline
  1520. void EnableDocumentLayout ()
  1521. {
  1522.         ActivateDocumentButtons ();
  1523.     fl_activate_object (fd_form_document->group_radio_separation);
  1524.     fl_activate_object (fd_form_document->radio_indent);
  1525.     fl_activate_object (fd_form_document->radio_skip);
  1526.     fl_activate_object (fd_form_document->choice_class);
  1527.     fl_activate_object (fd_form_document->choice_pagestyle);
  1528.     fl_activate_object (fd_form_document->choice_fonts);
  1529.     fl_activate_object (fd_form_document->choice_fontsize);
  1530.     fl_activate_object (fd_form_document->input_float_placement);
  1531.     fl_activate_object (fd_form_document->choice_postscript_driver);
  1532.     fl_activate_object (fd_form_document->choice_inputenc);
  1533.     fl_activate_object (fd_form_document->group_radio_sides);
  1534.     fl_activate_object (fd_form_document->radio_sides_one);
  1535.     fl_activate_object (fd_form_document->radio_sides_two);
  1536.     fl_activate_object (fd_form_document->group_radio_columns);
  1537.     fl_activate_object (fd_form_document->radio_columns_one);
  1538.     fl_activate_object (fd_form_document->radio_columns_two);
  1539.     fl_activate_object (fd_form_document->input_extra);
  1540.     fl_activate_object (fd_form_document->choice_language);
  1541.     combo_language->activate();
  1542.     fl_activate_object (fd_form_document->input_default_skip);
  1543.     fl_activate_object (fd_form_document->choice_default_skip);
  1544.     fl_activate_object (fd_form_document->slider_secnumdepth);
  1545.     fl_activate_object (fd_form_document->slider_tocdepth);
  1546.     fl_activate_object (fd_form_document->choice_spacing);
  1547.     fl_activate_object (fd_form_document->check_use_amsmath);
  1548. }
  1549.  
  1550.  
  1551. bool UpdateLayoutDocument(BufferParams *params)
  1552. {
  1553.     if (!current_view->getScreen() || !current_view->available()) {
  1554.         if (fd_form_document->form_document->visible) 
  1555.             fl_hide_form(fd_form_document->form_document);
  1556.         return false;
  1557.     }               
  1558.     
  1559.     if (params == NULL)
  1560.         params = ¤t_view->currentBuffer()->params;
  1561.     LyXTextClass *tclass = lyxstyle.TextClass(params->textclass);
  1562.     
  1563.     EnableDocumentLayout();
  1564.     
  1565.     fl_set_choice_text(fd_form_document->choice_class, 
  1566.                lyxstyle.DescOfClass(params->textclass).c_str());
  1567.     
  1568.     combo_language->select_text(params->language.c_str());
  1569.     
  1570.     fl_set_choice_text(fd_form_document->choice_fonts, 
  1571.                params->fonts.c_str());
  1572.     fl_set_choice_text(fd_form_document->choice_inputenc, 
  1573.                params->inputenc.c_str());
  1574.     fl_set_choice_text(fd_form_document->choice_postscript_driver, 
  1575.                params->graphicsDriver.c_str());
  1576.     
  1577.     // ale970405+lasgoutt970513
  1578.     fl_clear_choice(fd_form_document->choice_fontsize);
  1579.     fl_addto_choice(fd_form_document->choice_fontsize, "default");
  1580.     fl_addto_choice(fd_form_document->choice_fontsize, 
  1581.             tclass->opt_fontsize.c_str());
  1582.     fl_set_choice(fd_form_document->choice_fontsize, 
  1583.               tclass->opt_fontsize.tokenPos('|',
  1584.                             params->fontsize) + 2);
  1585.     
  1586.     // ale970405+lasgoutt970513
  1587.     fl_clear_choice(fd_form_document->choice_pagestyle);
  1588.     fl_addto_choice(fd_form_document->choice_pagestyle, "default");
  1589.     fl_addto_choice(fd_form_document->choice_pagestyle, 
  1590.             tclass->opt_pagestyle.c_str());
  1591.     
  1592.     fl_set_choice(fd_form_document->choice_pagestyle,
  1593.               tclass->opt_pagestyle.tokenPos('|',
  1594.                              params->pagestyle) + 2);
  1595.     
  1596.     fl_set_button(fd_form_document->radio_indent, 0);
  1597.     fl_set_button(fd_form_document->radio_skip, 0);
  1598.     
  1599.     
  1600.     fl_set_button(fd_form_document->check_use_amsmath,
  1601.               params->use_amsmath);
  1602.     
  1603.     if (params->paragraph_separation == LYX_PARSEP_INDENT)
  1604.         fl_set_button(fd_form_document->radio_indent, 1);
  1605.     else
  1606.         fl_set_button(fd_form_document->radio_skip, 1);
  1607.     
  1608.     switch (params->getDefSkip().kind()) {
  1609.     case VSpace::SMALLSKIP: 
  1610.         fl_set_choice (fd_form_document->choice_default_skip, 1);
  1611.         break;
  1612.     case VSpace::MEDSKIP: 
  1613.         fl_set_choice (fd_form_document->choice_default_skip, 2);
  1614.         break;
  1615.     case VSpace::BIGSKIP: 
  1616.         fl_set_choice (fd_form_document->choice_default_skip, 3);
  1617.         break;
  1618.     case VSpace::LENGTH: 
  1619.         fl_set_choice (fd_form_document->choice_default_skip, 4);
  1620.         fl_set_input (fd_form_document->input_default_skip,
  1621.                   params->getDefSkip().asLyXCommand().c_str());
  1622.         break;
  1623.     default:
  1624.         fl_set_choice (fd_form_document->choice_default_skip, 2);
  1625.         break;
  1626.     }
  1627.     
  1628.     fl_set_button(fd_form_document->radio_sides_one, 0);
  1629.     fl_set_button(fd_form_document->radio_sides_two, 0);
  1630.      
  1631.     if (params->sides == 2)
  1632.         fl_set_button(fd_form_document->radio_sides_two, 1);
  1633.     else
  1634.         fl_set_button(fd_form_document->radio_sides_one, 1);
  1635.     
  1636.     fl_set_button(fd_form_document->radio_columns_one, 0);
  1637.     fl_set_button(fd_form_document->radio_columns_two, 0);
  1638.     
  1639.     if (params->columns == 2)
  1640.         fl_set_button(fd_form_document->radio_columns_two, 1);
  1641.     else
  1642.         fl_set_button(fd_form_document->radio_columns_one, 1);
  1643.     
  1644.     switch (params->spacing.getSpace()) {
  1645.     case Spacing::Single:
  1646.     {
  1647.         // \singlespacing
  1648.         fl_set_choice(fd_form_document->choice_spacing, 1);
  1649.         break;
  1650.     }
  1651.     case Spacing::Onehalf:
  1652.     {
  1653.         // \onehalfspacing
  1654.         fl_set_choice(fd_form_document->choice_spacing, 2);
  1655.         break;
  1656.     }
  1657.     case Spacing::Double:
  1658.     {
  1659.         // \doublespacing
  1660.         fl_set_choice(fd_form_document->choice_spacing, 3);
  1661.         break;
  1662.     }
  1663.     case Spacing::Other:
  1664.     {
  1665.         // This might be used some day. However so far there
  1666.         // is only partially support for this. However it is
  1667.         // easy to make it work:ájust add a stretch object in
  1668.         // the document form for the user to set to a value
  1669.         // if LYX_SPACING_OTHER is in use.
  1670.         fl_set_choice(fd_form_document->choice_spacing, 4);
  1671.         break;
  1672.     }
  1673.     }
  1674.         
  1675.     fl_set_counter_value(fd_form_document->slider_secnumdepth, 
  1676.                  params->secnumdepth);
  1677.     fl_set_counter_value(fd_form_document->slider_tocdepth, 
  1678.                  params->tocdepth);
  1679.     if (!params->float_placement.empty()) { // buffer local (Lgb)
  1680.         fl_set_input(fd_form_document->input_float_placement,
  1681.                  params->float_placement.c_str());
  1682.     } else {
  1683.         fl_set_input(fd_form_document->input_float_placement,
  1684.                  LString("").c_str());
  1685.     }
  1686.     if (!params->options.empty())
  1687.         fl_set_input(fd_form_document->input_extra,
  1688.                  params->options.c_str());
  1689.     else
  1690.         fl_set_input(fd_form_document->input_extra,
  1691.                  LString("").c_str());
  1692.     
  1693.     if (current_view->currentBuffer()->isLinuxDoc()) {
  1694.         // bullets not used in LinuxDoc
  1695.         fl_deactivate_object(fd_form_document->button_bullets);
  1696.         fl_set_object_lcol(fd_form_document->button_bullets,
  1697.                    FL_INACTIVE);
  1698.     } else {
  1699.         fl_activate_object(fd_form_document->button_bullets);
  1700.         fl_set_object_lcol(fd_form_document->button_bullets,
  1701.                    FL_BLACK);
  1702.     }
  1703.     return true; 
  1704. }
  1705.  
  1706.  
  1707. void MenuLayoutDocument()
  1708. {
  1709.     if (UpdateLayoutDocument()) {
  1710.         if (current_view->currentBuffer()->isReadonly()) {
  1711.           DisableDocumentLayout();
  1712.           WriteAlert(_("Any changes will be ignored"),
  1713.                  _("The document is read-only:"),
  1714.                  current_view->currentBuffer()->getFileName());
  1715.         }
  1716.       
  1717.         if (fd_form_document->form_document->visible) {
  1718.             fl_raise_form(fd_form_document->form_document);
  1719.         } else {
  1720.             fl_show_form(fd_form_document->form_document,
  1721.                      FL_PLACE_MOUSE | FL_FREE_SIZE,
  1722.                      FL_FULLBORDER,
  1723.                      _("Document Layout"));
  1724.         }
  1725.     }
  1726. }
  1727.  
  1728.  
  1729. bool UpdateLayoutQuotes()
  1730. {
  1731.     bool update = true;
  1732.     if (!current_view->getScreen() || !current_view->available())
  1733.         update = false;
  1734.  
  1735.     if (update) {
  1736.         fl_set_choice(fd_form_quotes->choice_quotes_language,
  1737.               current_view->currentBuffer()->params.quotes_language + 1);
  1738.         fl_set_button(fd_form_quotes->radio_single, 0);
  1739.         fl_set_button(fd_form_quotes->radio_double, 0);
  1740.     
  1741.         if (current_view->currentBuffer()->params.quotes_times == InsetQuotes::SingleQ)
  1742.             fl_set_button(fd_form_quotes->radio_single, 1);
  1743.         else
  1744.             fl_set_button(fd_form_quotes->radio_double, 1);
  1745.     } else if (fd_form_quotes->form_quotes->visible) {
  1746.         fl_hide_form(fd_form_quotes->form_quotes);
  1747.     }
  1748.     return update;
  1749. }
  1750.  
  1751.  
  1752. void MenuLayoutQuotes()
  1753. {
  1754.     if (UpdateLayoutQuotes()) {
  1755.         if (fd_form_quotes->form_quotes->visible) {
  1756.             fl_raise_form(fd_form_quotes->form_quotes);
  1757.         } else {
  1758.             fl_show_form(fd_form_quotes->form_quotes,
  1759.                      FL_PLACE_MOUSE | FL_FREE_SIZE,
  1760.                      FL_FULLBORDER,
  1761.                      _("Quotes"));
  1762.         }
  1763.     }
  1764. }
  1765.  
  1766.  
  1767. bool UpdateLayoutPreamble()
  1768. {
  1769.     bool update = true;
  1770.     if (!current_view->getScreen() || ! current_view->available())
  1771.         update = false;
  1772.  
  1773.     if (update) {
  1774.         fl_set_input(fd_form_preamble->input_preamble,
  1775.              current_view->currentBuffer()->params.preamble.c_str());
  1776.  
  1777.         if (current_view->currentBuffer()->isReadonly()) {
  1778.           fl_deactivate_object(fd_form_preamble->input_preamble);
  1779.           fl_deactivate_object(fd_form_preamble->button_ok);
  1780.           fl_deactivate_object(fd_form_preamble->button_apply);
  1781.           fl_set_object_lcol(fd_form_preamble->button_ok, FL_INACTIVE);
  1782.           fl_set_object_lcol(fd_form_preamble->button_apply, FL_INACTIVE);
  1783.         }
  1784.         else {
  1785.           fl_activate_object(fd_form_preamble->input_preamble);
  1786.           fl_activate_object(fd_form_preamble->button_ok);
  1787.           fl_activate_object(fd_form_preamble->button_apply);
  1788.           fl_set_object_lcol(fd_form_preamble->button_ok, FL_BLACK);
  1789.           fl_set_object_lcol(fd_form_preamble->button_apply, FL_BLACK);
  1790.         }
  1791.     } else if (fd_form_preamble->form_preamble->visible) {
  1792.         fl_hide_form(fd_form_preamble->form_preamble);
  1793.     }
  1794.     return update;
  1795. }
  1796.  
  1797.  
  1798. void MenuLayoutPreamble()
  1799. {
  1800.     if (UpdateLayoutPreamble()) {
  1801.         if (fd_form_preamble->form_preamble->visible) {
  1802.             fl_raise_form(fd_form_preamble->form_preamble);
  1803.         } else {
  1804.             fl_show_form(fd_form_preamble->form_preamble,
  1805.                      FL_PLACE_MOUSE | FL_FREE_SIZE,
  1806.                      FL_FULLBORDER,
  1807.                      _("LaTeX Preamble"));
  1808.         }
  1809.     }
  1810. }
  1811.  
  1812.  
  1813. void MenuLayoutSave()
  1814. {
  1815.     if (!current_view->getScreen() || ! current_view->available())
  1816.         return;
  1817.  
  1818.     if (AskQuestion(_("Do you want to save the current settings"),
  1819.             _("for Character, Document, Paper and Quotes"),
  1820.             _("as default for new documents?")))
  1821.         current_view->currentBuffer()->saveParamsAsDefaults();
  1822. }
  1823.  
  1824. /* callbacks added for LinuxDoc support (Pascal AndrΘ) : 
  1825.  *   - marks and cross references TeX macros
  1826.  *   - url display macros
  1827.  *   - htmlurl macros
  1828.  */
  1829.  
  1830. /* inserts an url skeleton */
  1831. void UrlCB()
  1832. {
  1833. #warning do it right!
  1834. }
  1835.  
  1836.  
  1837. /* inserts an html url skeleton */ 
  1838. void HtmlUrlCB()
  1839. {
  1840. #warning do it right!
  1841. }
  1842.  
  1843. /* end of LinuxDoc SGML special CB */
  1844.  
  1845. void NoteCB()
  1846. {
  1847.     LString string;
  1848.     LString userName(getUserName());
  1849.     string = userName + ' ' + date();
  1850.     InsetInfo *new_inset = new InsetInfo(string);
  1851.     current_view->currentBuffer()->insertInset(new_inset);
  1852. }
  1853.  
  1854.  
  1855. void OpenStuff()
  1856. {
  1857.     if (current_view->available()) {
  1858.         minibuffer->Set(_("Open/Close..."));
  1859.         current_view->getScreen()->HideCursor();
  1860.         BeforeChange();
  1861.         current_view->currentBuffer()->update(-2);
  1862.         current_view->currentBuffer()->text->OpenStuff();
  1863.         current_view->currentBuffer()->update(0);
  1864.     }
  1865. }
  1866.  
  1867. void ToggleFloat()
  1868. {
  1869.     if (current_view->available()) {
  1870.         minibuffer->Set(_("Open/Close..."));
  1871.         current_view->getScreen()->HideCursor();
  1872.         BeforeChange();
  1873.         current_view->currentBuffer()->update(-2);
  1874.         current_view->currentBuffer()->text->ToggleFootnote();
  1875.         current_view->currentBuffer()->update(0);
  1876.     }
  1877. }
  1878.  
  1879.  
  1880. void MenuUndo()
  1881. {
  1882.     if (current_view->available()) {
  1883.         minibuffer->Set(_("Undo"));
  1884.         current_view->getScreen()->HideCursor();
  1885.         BeforeChange();
  1886.         current_view->currentBuffer()->update(-2);
  1887.         if (!current_view->currentBuffer()->text->TextUndo())
  1888.             minibuffer->Set(_("No further undo information"));
  1889.         else
  1890.             current_view->currentBuffer()->update(-1);
  1891.     }
  1892. }
  1893.  
  1894.  
  1895. void MenuRedo()
  1896. {
  1897.     if (current_view->currentBuffer()->the_locking_inset) {
  1898.         minibuffer->Set(_("Redo not yet supported in math mode"));
  1899.         return;
  1900.     }    
  1901.    
  1902.     if (current_view->available()) {
  1903.         minibuffer->Set(_("Redo"));
  1904.         current_view->getScreen()->HideCursor();
  1905.         BeforeChange();
  1906.         current_view->currentBuffer()->update(-2);
  1907.         if (!current_view->currentBuffer()->text->TextRedo())
  1908.             minibuffer->Set(_("No further redo information"));
  1909.         else
  1910.             current_view->currentBuffer()->update(-1);
  1911.     }
  1912. }
  1913.  
  1914.  
  1915. void HyphenationPoint()
  1916. {
  1917.     if (current_view->available())  {
  1918.         current_view->getScreen()->HideCursor();
  1919.         current_view->currentBuffer()->update(-2);
  1920.         InsetSpecialChar *new_inset = 
  1921.             new InsetSpecialChar(InsetSpecialChar::HYPHENATION);
  1922.         current_view->currentBuffer()->insertInset(new_inset);
  1923.     }
  1924. }
  1925.  
  1926.  
  1927. void Ldots()
  1928. {
  1929.     if (current_view->available())  {
  1930.         current_view->getScreen()->HideCursor();
  1931.         current_view->currentBuffer()->update(-2);
  1932.         InsetSpecialChar *new_inset = 
  1933.             new InsetSpecialChar(InsetSpecialChar::LDOTS);
  1934.         current_view->currentBuffer()->insertInset(new_inset);
  1935.     }
  1936. }
  1937.  
  1938.  
  1939. void EndOfSentenceDot()
  1940. {
  1941.     if (current_view->available())  {
  1942.         current_view->getScreen()->HideCursor();
  1943.         current_view->currentBuffer()->update(-2);
  1944.         InsetSpecialChar *new_inset = 
  1945.             new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE);
  1946.         current_view->currentBuffer()->insertInset(new_inset);
  1947.     }
  1948. }
  1949.  
  1950.  
  1951. void Newline()
  1952. {
  1953.     if (current_view->available())  {
  1954.         current_view->getScreen()->HideCursor();
  1955.         current_view->currentBuffer()->update(-2);
  1956.         current_view->currentBuffer()->text->InsertChar(LYX_META_NEWLINE);
  1957.         current_view->currentBuffer()->update(-1);
  1958.     }
  1959. }
  1960.  
  1961.  
  1962. void ProtectedBlank()
  1963. {
  1964.     if (current_view->available())  {
  1965.         current_view->getScreen()->HideCursor();
  1966.         current_view->currentBuffer()->update(-2);
  1967.         current_view->currentBuffer()->text->InsertChar(LYX_META_PROTECTED_SEPARATOR);
  1968.         current_view->currentBuffer()->update(-1);
  1969.     }
  1970. }
  1971.  
  1972.  
  1973. void HFill()
  1974. {
  1975.     if (current_view->available())  {
  1976.         current_view->getScreen()->HideCursor();
  1977.         current_view->currentBuffer()->update(-2);
  1978.         current_view->currentBuffer()->text->InsertChar(LYX_META_HFILL);
  1979.         current_view->currentBuffer()->update(-1);
  1980.     }
  1981. }
  1982.  
  1983.  
  1984. /* -------> These CB's use ToggleFree() as the (one and only?) font-changer. 
  1985.             They also show the current font state. */
  1986.  
  1987. static
  1988. void ToggleAndShow(LyXFont const &);
  1989.  
  1990.  
  1991. void FontSizeCB(LString const & size)
  1992. {
  1993.     LyXFont font(LyXFont::ALL_IGNORE);
  1994.     font.setGUISize(size);
  1995.     ToggleAndShow( font);
  1996. }
  1997.  
  1998.  
  1999. void EmphCB()
  2000. {
  2001.     LyXFont font(LyXFont::ALL_IGNORE);
  2002.     font.setEmph(LyXFont::TOGGLE);
  2003.     ToggleAndShow(font);
  2004. }
  2005.  
  2006.  
  2007. void NounCB()
  2008. {
  2009.     LyXFont font(LyXFont::ALL_IGNORE);
  2010.     font.setNoun(LyXFont::TOGGLE);
  2011.     ToggleAndShow( font);
  2012. }
  2013.  
  2014.  
  2015. void BoldCB()
  2016. {
  2017.     LyXFont font(LyXFont::ALL_IGNORE);
  2018.     font.setSeries(LyXFont::BOLD_SERIES);
  2019.     ToggleAndShow( font);
  2020. }
  2021.  
  2022.  
  2023. void UnderlineCB()
  2024. {
  2025.     LyXFont font(LyXFont::ALL_IGNORE);
  2026.     font.setUnderbar(LyXFont::TOGGLE);
  2027.     ToggleAndShow( font);
  2028. }
  2029.  
  2030.  
  2031. void CodeCB()
  2032. {
  2033.     LyXFont font(LyXFont::ALL_IGNORE);
  2034.     font.setFamily(LyXFont::TYPEWRITER_FAMILY); // no good
  2035.     ToggleAndShow( font);
  2036. }
  2037.  
  2038.  
  2039. void SansCB()
  2040. {
  2041.     LyXFont font(LyXFont::ALL_IGNORE);
  2042.     font.setFamily(LyXFont::SANS_FAMILY);
  2043.     ToggleAndShow( font);
  2044. }
  2045.  
  2046.  
  2047. void RomanCB()
  2048. {
  2049.     LyXFont font(LyXFont::ALL_IGNORE);
  2050.     font.setFamily(LyXFont::ROMAN_FAMILY);
  2051.     ToggleAndShow( font);
  2052. }
  2053.  
  2054.  
  2055. void TexCB()
  2056. {
  2057.     LyXFont font(LyXFont::ALL_IGNORE);
  2058.     font.setLatex (LyXFont::TOGGLE);
  2059.     ToggleAndShow( font);
  2060. }
  2061.  
  2062.  
  2063. void StyleResetCB()
  2064. {
  2065.     LyXFont font(LyXFont::ALL_INHERIT);
  2066.     ToggleAndShow( font);
  2067. }
  2068.  
  2069.  
  2070. /* -------> Returns the current font and depth by printing a message. In the
  2071.  * future perhaps we could try to implement a callback to the button-bar.
  2072.  * That is, `light' the bold button when the font is currently bold, etc.
  2073.  */
  2074. LString CurrentState()
  2075. {
  2076.     LString state;
  2077.     if (current_view->available()) { 
  2078.         // I think we should only show changes from the default
  2079.         // font. (Asger)
  2080.         Buffer * buffer = current_view->currentBuffer();
  2081.         LyXFont font = buffer->text->real_current_font;
  2082.         LyXFont defaultfont = lyxstyle.TextClass(buffer->
  2083.                              params.textclass)->defaultfont;
  2084.         font.reduce(defaultfont);
  2085.         state = _("Font: ") + font.stateText();
  2086.  
  2087.         int depth = buffer->text->GetDepth();
  2088.         if (depth>0) 
  2089.             state += LString(_(", Depth: ")) + depth;
  2090.     }
  2091.     return state;
  2092. }
  2093.  
  2094.  
  2095. /* -------> Does the actual toggle job of the XxxCB() calls above.
  2096.  * Also shows the current font state.
  2097.  */
  2098. static
  2099. void ToggleAndShow(LyXFont const & font)
  2100. {
  2101.     if (current_view->available()) { 
  2102.         current_view->getScreen()->HideCursor();
  2103.         current_view->currentBuffer()->update(-2);
  2104.          current_view->currentBuffer()->text->ToggleFree(font);
  2105.         current_view->currentBuffer()->update(1);
  2106.     }
  2107. }
  2108.  
  2109.  
  2110. void MarginCB(FL_OBJECT *, long)
  2111. {
  2112.     if (current_view->available()) {
  2113.         minibuffer->Set(_("Inserting margin note..."));
  2114.         current_view->getScreen()->HideCursor();
  2115.         current_view->currentBuffer()->update(-2);
  2116.         current_view->currentBuffer()->text->InsertFootnoteEnvironment(LyXParagraph::MARGIN);
  2117.         current_view->currentBuffer()->update(1);
  2118.     }
  2119. }
  2120.  
  2121.  
  2122. void FigureCB(FL_OBJECT *, long)
  2123. {
  2124.     if (fd_form_figure->form_figure->visible) {
  2125.         fl_raise_form(fd_form_figure->form_figure);
  2126.     } else {
  2127.         fl_show_form(fd_form_figure->form_figure,
  2128.                  FL_PLACE_MOUSE, FL_FULLBORDER,
  2129.                  _("Insert Figure"));
  2130.     }
  2131. }
  2132.  
  2133.  
  2134. void TableCB(FL_OBJECT *, long)
  2135. {
  2136.     if (fd_form_table->form_table->visible) {
  2137.         fl_raise_form(fd_form_table->form_table);
  2138.     } else {
  2139.         fl_show_form(fd_form_table->form_table,
  2140.                  FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
  2141.                  _("Insert Table"));
  2142.     }
  2143. }
  2144.  
  2145.  
  2146. void CopyEnvironmentCB()
  2147. {
  2148.     if (current_view->available()) {
  2149.         current_view->currentBuffer()->text->copyEnvironmentType();
  2150.         /* clear the selection, even if mark_set */ 
  2151.         current_view->getScreen()->ToggleSelection();
  2152.         current_view->currentBuffer()->text->ClearSelection();
  2153.         current_view->currentBuffer()->update(-2);
  2154.         minibuffer->Set(_("Paragraph environment type copied"));
  2155.     }
  2156. }
  2157.  
  2158.  
  2159. void PasteEnvironmentCB()
  2160. {
  2161.     if (current_view->available()) {
  2162.         current_view->currentBuffer()->text->pasteEnvironmentType();
  2163.         minibuffer->Set(_("Paragraph environment type set"));
  2164.         current_view->currentBuffer()->update(1);
  2165.     }
  2166. }
  2167.  
  2168.  
  2169. void CopyCB()
  2170. {
  2171.     if (current_view->available()) {
  2172.         current_view->currentBuffer()->text->CopySelection();
  2173.         /* clear the selection, even if mark_set */ 
  2174.         current_view->getScreen()->ToggleSelection();
  2175.         current_view->currentBuffer()->text->ClearSelection();
  2176.         current_view->currentBuffer()->update(-2);
  2177.         minibuffer->Set(_("Copy"));
  2178.     }
  2179. }
  2180.  
  2181.  
  2182. void CutCB()
  2183. {
  2184.     if (current_view->available()) {
  2185.         current_view->getScreen()->HideCursor();
  2186.         current_view->currentBuffer()->update(-2);
  2187.         current_view->currentBuffer()->text->CutSelection();
  2188.         current_view->currentBuffer()->update(1);
  2189.         minibuffer->Set(_("Cut"));
  2190.     }
  2191. }
  2192.  
  2193.  
  2194. void PasteCB()
  2195. {
  2196.     if (!current_view->available()) return;
  2197.     
  2198.     minibuffer->Set(_("Paste"));
  2199.     current_view->getScreen()->HideCursor();
  2200.     /* clear the selection */ 
  2201.     current_view->getScreen()->ToggleSelection();
  2202.     current_view->currentBuffer()->text->ClearSelection();
  2203.     current_view->currentBuffer()->update(-2);
  2204.     
  2205.     /* paste */ 
  2206.     current_view->currentBuffer()->text->PasteSelection();
  2207.     current_view->currentBuffer()->update(1);
  2208.     
  2209.     /* clear the selection */ 
  2210.     current_view->getScreen()->ToggleSelection();
  2211.     current_view->currentBuffer()->text->ClearSelection();
  2212.     current_view->currentBuffer()->update(-2);
  2213. }
  2214.  
  2215.  
  2216. void MeltCB(FL_OBJECT *, long)
  2217. {
  2218.     if (!current_view->available()) return;
  2219.     
  2220.     minibuffer->Set(_("Melt"));
  2221.     current_view->getScreen()->HideCursor();
  2222.     BeforeChange();
  2223.     current_view->currentBuffer()->update(-2);
  2224.     current_view->currentBuffer()->text->MeltFootnoteEnvironment();
  2225.     current_view->currentBuffer()->update(1);
  2226. }
  2227.  
  2228.  
  2229. // Change environment depth.
  2230. // if decInc == 0, depth change taking mouse button number into account
  2231. // if decInc == 1, increment depth
  2232. // if decInc == -1, decrement depth
  2233. void DepthCB(FL_OBJECT *ob, long decInc)
  2234. {
  2235.     int button = 1;
  2236.  
  2237.     /* When decInc != 0, fake a mouse button. This allows us to
  2238.        implement depth-plus and depth-min commands. RVDK_PATCH_5. */
  2239.     /* check out wether ob is defined, too (Matthias) */ 
  2240.     if ( decInc < 0 )
  2241.         button = 0;
  2242.     else if (!decInc && ob) {
  2243.         button = fl_get_button_numb(ob);
  2244.     }
  2245.   
  2246.     if (current_view->available()) {
  2247.         current_view->getScreen()->HideCursor();
  2248.         current_view->currentBuffer()->update(-2);
  2249.         if (button == 1)
  2250.             current_view->currentBuffer()->text->IncDepth();
  2251.         else
  2252.             current_view->currentBuffer()->text->DecDepth();
  2253.         current_view->currentBuffer()->update(1);
  2254.         minibuffer->Set(_("Changed environment depth"
  2255.                   " (in possible range, maybe not)"));
  2256.     }
  2257. }
  2258.  
  2259.  
  2260. // This is both GUI and LyXFont dependent. Don't know where to put it. (Asger)
  2261. // Well, it's mostly GUI dependent, so I guess it will stay here. (Asger)
  2262. LyXFont UserFreeFont()
  2263. {
  2264.     LyXFont font(LyXFont::ALL_IGNORE);
  2265.     int pos;
  2266.  
  2267.     pos = fl_get_choice(fd_form_character->choice_family);
  2268.     switch(pos) {
  2269.     case 1: font.setFamily(LyXFont::IGNORE_FAMILY); break;
  2270.     case 2: font.setFamily(LyXFont::ROMAN_FAMILY); break;
  2271.     case 3: font.setFamily(LyXFont::SANS_FAMILY); break;
  2272.     case 4: font.setFamily(LyXFont::TYPEWRITER_FAMILY); break;
  2273.     case 5: font.setFamily(LyXFont::INHERIT_FAMILY); break;
  2274.     }
  2275.  
  2276.     pos = fl_get_choice(fd_form_character->choice_series);
  2277.     switch(pos) {
  2278.     case 1: font.setSeries(LyXFont::IGNORE_SERIES); break;
  2279.     case 2: font.setSeries(LyXFont::MEDIUM_SERIES); break;
  2280.     case 3: font.setSeries(LyXFont::BOLD_SERIES); break;
  2281.     case 4: font.setSeries(LyXFont::INHERIT_SERIES); break;
  2282.     }
  2283.  
  2284.     pos = fl_get_choice(fd_form_character->choice_shape);
  2285.     switch(pos) {
  2286.     case 1: font.setShape(LyXFont::IGNORE_SHAPE); break;
  2287.     case 2: font.setShape(LyXFont::UP_SHAPE); break;
  2288.     case 3: font.setShape(LyXFont::ITALIC_SHAPE); break;
  2289.     case 4: font.setShape(LyXFont::SLANTED_SHAPE); break;
  2290.     case 5: font.setShape(LyXFont::SMALLCAPS_SHAPE); break;
  2291.     case 6: font.setShape(LyXFont::INHERIT_SHAPE); break;
  2292.     }
  2293.  
  2294.     pos = fl_get_choice(fd_form_character->choice_size);
  2295.     switch(pos) {
  2296.     case 1: font.setSize(LyXFont::IGNORE_SIZE); break;
  2297.     case 2: font.setSize(LyXFont::SIZE_TINY); break;
  2298.     case 3: font.setSize(LyXFont::SIZE_SCRIPT); break;
  2299.     case 4: font.setSize(LyXFont::SIZE_FOOTNOTE); break;
  2300.     case 5: font.setSize(LyXFont::SIZE_SMALL); break;
  2301.     case 6: font.setSize(LyXFont::SIZE_NORMAL); break;
  2302.     case 7: font.setSize(LyXFont::SIZE_LARGE); break;
  2303.     case 8: font.setSize(LyXFont::SIZE_LARGER); break;
  2304.     case 9: font.setSize(LyXFont::SIZE_LARGEST); break;
  2305.     case 10: font.setSize(LyXFont::SIZE_HUGE); break;
  2306.     case 11: font.setSize(LyXFont::SIZE_HUGER); break;
  2307.     case 12: font.setSize(LyXFont::INCREASE_SIZE); break;
  2308.     case 13: font.setSize(LyXFont::DECREASE_SIZE); break;
  2309.     case 14: font.setSize(LyXFont::INHERIT_SIZE); break;
  2310.     }
  2311.  
  2312.     pos = fl_get_choice(fd_form_character->choice_bar);
  2313.     switch(pos) {
  2314.     case 1: font.setEmph(LyXFont::IGNORE);
  2315.         font.setUnderbar(LyXFont::IGNORE);
  2316.         font.setNoun(LyXFont::IGNORE);
  2317.         font.setLatex(LyXFont::IGNORE);
  2318.         break;
  2319.     case 2: font.setEmph(LyXFont::TOGGLE); break;
  2320.     case 3: font.setUnderbar(LyXFont::TOGGLE); break;
  2321.     case 4: font.setNoun(LyXFont::TOGGLE); break;
  2322.     case 5: font.setLatex(LyXFont::TOGGLE); break;
  2323.     case 6: font.setEmph(LyXFont::INHERIT);
  2324.         font.setUnderbar(LyXFont::INHERIT);
  2325.         font.setNoun(LyXFont::INHERIT);
  2326.         font.setLatex(LyXFont::INHERIT);
  2327.         break;
  2328.     }
  2329.  
  2330.     pos = fl_get_choice(fd_form_character->choice_color);
  2331.     switch(pos) {
  2332.     case 1: font.setColor(LyXFont::IGNORE_COLOR); break;
  2333.     case 2: font.setColor(LyXFont::NONE); break;
  2334.     case 3: font.setColor(LyXFont::BLACK); break;
  2335.     case 4: font.setColor(LyXFont::WHITE); break;
  2336.     case 5: font.setColor(LyXFont::RED); break;
  2337.     case 6: font.setColor(LyXFont::GREEN); break;
  2338.     case 7: font.setColor(LyXFont::BLUE); break;
  2339.     case 8: font.setColor(LyXFont::CYAN); break;
  2340.     case 9: font.setColor(LyXFont::MAGENTA); break;
  2341.     case 10: font.setColor(LyXFont::YELLOW); break;
  2342.     case 11: font.setColor(LyXFont::INHERIT_COLOR); break;
  2343.     }
  2344.  
  2345.     return font; 
  2346. }
  2347.  
  2348.  
  2349. void FreeCB()
  2350. {
  2351.     ToggleAndShow( UserFreeFont());
  2352. }
  2353.  
  2354.  
  2355. /* callbacks for form form_title */
  2356. void TimerCB(FL_OBJECT *, long)
  2357. {
  2358.     // only if the form still exists
  2359.     if (fd_form_title->form_title != NULL) {
  2360.         if (fd_form_title->form_title->visible) {
  2361.             fl_hide_form(fd_form_title->form_title);
  2362.         }
  2363.         fl_free_form(fd_form_title->form_title);
  2364.         fd_form_title->form_title = NULL;
  2365.     }
  2366. }
  2367.  
  2368.  
  2369. /* callbacks for form form_paragraph */
  2370.  
  2371. void ParagraphVSpaceCB(FL_OBJECT* obj, long )
  2372. {
  2373.     // "Synchronize" the choices and input fields, making it
  2374.     // impossible to commit senseless data.
  2375.  
  2376.     const FD_form_paragraph* fp = fd_form_paragraph;
  2377.  
  2378.     if (obj == fp->choice_space_above) {
  2379.         if (fl_get_choice (fp->choice_space_above) != 7) {
  2380.             fl_set_input (fp->input_space_above, "");
  2381.             ActivateParagraphButtons();
  2382.         }
  2383.     } else if (obj == fp->choice_space_below) {
  2384.         if (fl_get_choice (fp->choice_space_below) != 7) {
  2385.             fl_set_input (fp->input_space_below, "");
  2386.             ActivateParagraphButtons();
  2387.         }
  2388.     } else if (obj == fp->input_space_above) {
  2389.         LString input = fl_get_input (fp->input_space_above);
  2390.  
  2391.         if (input.empty()) {
  2392.             fl_set_choice (fp->choice_space_above, 1);
  2393.             ActivateParagraphButtons();
  2394.         }
  2395.         else if (isValidGlueLength (input)) {
  2396.             fl_set_choice (fp->choice_space_above, 7);
  2397.             ActivateParagraphButtons();
  2398.         }
  2399.         else {
  2400.             fl_set_choice (fp->choice_space_above, 7);
  2401.             DeactivateParagraphButtons();
  2402.         }
  2403.     } else if (obj == fp->input_space_below) {
  2404.         LString input = fl_get_input (fp->input_space_below);
  2405.  
  2406.         if (input.empty()) {
  2407.             fl_set_choice (fp->choice_space_below, 1);
  2408.             ActivateParagraphButtons();
  2409.         }
  2410.         else if (isValidGlueLength (input)) {
  2411.             fl_set_choice (fp->choice_space_below, 7);
  2412.             ActivateParagraphButtons();
  2413.         }
  2414.         else {
  2415.             fl_set_choice (fp->choice_space_below, 7);
  2416.             DeactivateParagraphButtons();
  2417.         }
  2418.     }
  2419. }
  2420.  
  2421.  
  2422. void ParagraphApplyCB(FL_OBJECT *, long)
  2423. {
  2424.     if (!current_view->available())
  2425.         return;
  2426.     
  2427.     bool line_top, line_bottom;
  2428.     bool pagebreak_top, pagebreak_bottom;
  2429.     VSpace space_top, space_bottom;
  2430.     char align;
  2431.     LString labelwidthstring;
  2432.     bool noindent;
  2433.  
  2434.     // If a vspace kind is "Length" but there's no text in
  2435.     // the input field, reset the kind to "None". 
  2436.     if (fl_get_choice (fd_form_paragraph->choice_space_above) == 7
  2437.         && !*(fl_get_input (fd_form_paragraph->input_space_above))) {
  2438.         fl_set_choice (fd_form_paragraph->choice_space_above, 1);
  2439.     }
  2440.     if (fl_get_choice (fd_form_paragraph->choice_space_below) == 7
  2441.         && !*(fl_get_input (fd_form_paragraph->input_space_below))) {
  2442.         fl_set_choice (fd_form_paragraph->choice_space_below, 1);
  2443.     }
  2444.    
  2445.     line_top = fl_get_button(fd_form_paragraph->check_lines_top);
  2446.     line_bottom = fl_get_button(fd_form_paragraph->check_lines_bottom);
  2447.     pagebreak_top = fl_get_button(fd_form_paragraph->check_pagebreaks_top);
  2448.     pagebreak_bottom = fl_get_button(fd_form_paragraph->check_pagebreaks_bottom);
  2449.     switch (fl_get_choice (fd_form_paragraph->choice_space_above)) {
  2450.     case 1: space_top = VSpace::NONE; break;
  2451.     case 2: space_top = VSpace::DEFSKIP; break;
  2452.     case 3: space_top = VSpace::SMALLSKIP; break;
  2453.     case 4: space_top = VSpace::MEDSKIP; break;
  2454.     case 5: space_top = VSpace::BIGSKIP; break;
  2455.     case 6: space_top = VSpace::VFILL; break;
  2456.     case 7: space_top = LyXGlueLength (fl_get_input (fd_form_paragraph->input_space_above)); break;
  2457.     }
  2458.     if (fl_get_button (fd_form_paragraph->check_space_above))
  2459.       space_top.setKeep (true);
  2460.     switch (fl_get_choice (fd_form_paragraph->choice_space_below)) {
  2461.     case 1: space_bottom = VSpace::NONE; break;
  2462.     case 2: space_bottom = VSpace::DEFSKIP; break;
  2463.     case 3: space_bottom = VSpace::SMALLSKIP; break;
  2464.     case 4: space_bottom = VSpace::MEDSKIP; break;
  2465.     case 5: space_bottom = VSpace::BIGSKIP; break;
  2466.     case 6: space_bottom = VSpace::VFILL; break;
  2467.     case 7: space_bottom = LyXGlueLength (fl_get_input (fd_form_paragraph->input_space_below)); break;
  2468.     }
  2469.     if (fl_get_button (fd_form_paragraph->check_space_below))
  2470.       space_bottom.setKeep (true);
  2471.  
  2472.     if (fl_get_button(fd_form_paragraph->radio_align_left))
  2473.         align = LYX_ALIGN_LEFT;
  2474.     else if (fl_get_button(fd_form_paragraph->radio_align_right))
  2475.         align = LYX_ALIGN_RIGHT;
  2476.     else if (fl_get_button(fd_form_paragraph->radio_align_center))
  2477.         align = LYX_ALIGN_CENTER;
  2478.     else 
  2479.         align = LYX_ALIGN_BLOCK;
  2480.    
  2481.     labelwidthstring = fl_get_input(fd_form_paragraph->input_labelwidth);
  2482.     noindent = fl_get_button(fd_form_paragraph->check_noindent);
  2483.    
  2484.     current_view->currentBuffer()->text->SetParagraph(line_top,
  2485.                               line_bottom,
  2486.                               pagebreak_top,
  2487.                               pagebreak_bottom,
  2488.                               space_top,
  2489.                               space_bottom,
  2490.                               align, 
  2491.                               labelwidthstring,
  2492.                               noindent);
  2493.     current_view->currentBuffer()->update(1);
  2494.     minibuffer->Set(_("Paragraph layout set"));
  2495. }
  2496.  
  2497.  
  2498. void ParagraphCancelCB(FL_OBJECT *, long)
  2499. {
  2500.     fl_hide_form(fd_form_paragraph->form_paragraph);
  2501. }
  2502.  
  2503.  
  2504. void ParagraphOKCB(FL_OBJECT *ob, long data)
  2505. {
  2506.     ParagraphApplyCB(ob, data);
  2507.     ParagraphCancelCB(ob, data);
  2508. }
  2509.  
  2510.  
  2511. /* callbacks for form form_character */
  2512.  
  2513. void CharacterApplyCB(FL_OBJECT *, long)
  2514. {
  2515.     ToggleAndShow( UserFreeFont());
  2516. }
  2517.  
  2518.  
  2519. void CharacterCancelCB(FL_OBJECT *, long)
  2520. {
  2521.     fl_hide_form(fd_form_character->form_character);
  2522. }
  2523.  
  2524.  
  2525. void CharacterOKCB(FL_OBJECT *ob, long data)
  2526. {
  2527.     CharacterApplyCB(ob,data);
  2528.     CharacterCancelCB(ob,data);
  2529. }
  2530.  
  2531.  
  2532. /* callbacks for form form_document */
  2533.  
  2534. void UpdateDocumentButtons(BufferParams const ¶ms) 
  2535. {
  2536.     fl_set_choice(fd_form_document->choice_pagestyle, 1);
  2537.     
  2538.     if (params.sides == 2)
  2539.         fl_set_button(fd_form_document->radio_sides_two, 1);
  2540.     else
  2541.         fl_set_button(fd_form_document->radio_sides_one, 1);
  2542.     
  2543.     if (params.columns == 2)
  2544.         fl_set_button(fd_form_document->radio_columns_two, 1);
  2545.     else
  2546.         fl_set_button(fd_form_document->radio_columns_one, 1);
  2547.     
  2548.     fl_set_input(fd_form_document->input_extra, params.options.c_str());
  2549.     fl_set_counter_value(fd_form_document->slider_secnumdepth, 
  2550.                  params.secnumdepth);
  2551.     fl_set_counter_value(fd_form_document->slider_tocdepth, 
  2552.                  params.tocdepth);
  2553.     
  2554. }
  2555.  
  2556. void ChoiceClassCB(FL_OBJECT *ob, long)
  2557. {
  2558.     ProhibitInput();
  2559.     if (lyxstyle.Load(fl_get_choice(ob)-1)) {
  2560.         if (AskQuestion(_("Should I set some parameters to"),
  2561.                 fl_get_choice_text(ob),
  2562.                 _("the defaults of this document class?"))) {
  2563.             BufferParams params = BufferParams();
  2564.             params.textclass = fl_get_choice(ob)-1;
  2565.             params.useClassDefaults();
  2566.             UpdateLayoutDocument(¶ms);
  2567.             UpdateDocumentButtons(params);
  2568.         }
  2569.     } else {
  2570.         // unable to load new style
  2571.         WriteAlert(_("Conversion Errors!"),
  2572.                _("Unable to switch to new document class."),
  2573.                _("Reverting to original document class."));
  2574.         fl_set_choice(fd_form_document->choice_class, 
  2575.                   GetCurrentTextClass() + 1);
  2576.     }
  2577.     AllowInput();
  2578. }
  2579.  
  2580.  
  2581. void DocumentDefskipCB(FL_OBJECT *obj, long)
  2582. {
  2583.     // "Synchronize" the choice and the input field, so that it
  2584.     // is impossible to commit senseless data.
  2585.     const FD_form_document* fd = fd_form_document;
  2586.  
  2587.     if (obj == fd->choice_default_skip) {
  2588.         if (fl_get_choice (fd->choice_default_skip) != 4) {
  2589.             fl_set_input (fd->input_default_skip, "");
  2590.             ActivateDocumentButtons();
  2591.         }
  2592.     } else if (obj == fd->input_default_skip) {
  2593.  
  2594.         const char* input = fl_get_input (fd->input_default_skip);
  2595.  
  2596.         if (!*input) {
  2597.             fl_set_choice (fd->choice_default_skip, 2);
  2598.             ActivateDocumentButtons();
  2599.         } else if (isValidGlueLength (input)) {
  2600.             fl_set_choice (fd->choice_default_skip, 4);
  2601.             ActivateDocumentButtons();
  2602.         } else {
  2603.             fl_set_choice (fd->choice_default_skip, 4);
  2604.             DeactivateDocumentButtons();
  2605.         }
  2606.     }
  2607. }
  2608.  
  2609.  
  2610. void DocumentApplyCB(FL_OBJECT *, long)
  2611. {
  2612.     bool redo = false;
  2613.     BufferParams *params = &(current_view->currentBuffer()->params);
  2614.     current_view->currentBuffer()->params.language =
  2615.         combo_language->getline();
  2616.  
  2617.     // If default skip is a "Length" but there's no text in the
  2618.     // input field, reset the kind to "Medskip", which is the default.
  2619.     if (fl_get_choice (fd_form_document->choice_default_skip) == 4
  2620.         && !*(fl_get_input (fd_form_document->input_default_skip))) {
  2621.         fl_set_choice (fd_form_document->choice_default_skip, 2);
  2622.     }
  2623.  
  2624.     params->fonts =
  2625.         fl_get_choice_text(fd_form_document->choice_fonts);
  2626.     params->inputenc =
  2627.         fl_get_choice_text(fd_form_document->choice_inputenc);
  2628.     params->fontsize =
  2629.         fl_get_choice_text(fd_form_document->choice_fontsize);
  2630.     params->pagestyle =
  2631.         fl_get_choice_text(fd_form_document->choice_pagestyle);
  2632.     params->graphicsDriver =
  2633.         fl_get_choice_text(fd_form_document->choice_postscript_driver);
  2634.     params->use_amsmath =
  2635.         fl_get_button(fd_form_document->check_use_amsmath);
  2636.    
  2637.     if (!current_view->available())
  2638.         return;
  2639.  
  2640.     char new_class = fl_get_choice(fd_form_document->choice_class) - 1;
  2641.     if (params->textclass != new_class) {
  2642.         // try to load new_class
  2643.         if (lyxstyle.Load(new_class)) {
  2644.             // successfully loaded
  2645.             redo = true;
  2646.             minibuffer->Set(_("Converting document to new document class..."));
  2647.             int ret = current_view->currentBuffer()->
  2648.                 text->
  2649.                 SwitchLayoutsBetweenClasses(current_view->currentBuffer()->
  2650.                                 params.textclass,
  2651.                                 new_class,
  2652.                                 current_view->currentBuffer()->
  2653.                                 paragraph);
  2654.  
  2655.             if (ret){
  2656.                 LString s;
  2657.                 if (ret==1)
  2658.                     s= _("One paragraph couldn't be converted");
  2659.                 else {
  2660.                     s += ret;
  2661.                     s += _(" paragraphs couldn't be converted");
  2662.                 }
  2663.                 WriteAlert(_("Conversion Errors!"),s,
  2664.                        _("into chosen document class"));
  2665.             }
  2666.  
  2667.             params->textclass = new_class;
  2668.         } else {
  2669.             // problem changing class -- warn user and retain old style
  2670.             WriteAlert(_("Conversion Errors!"),
  2671.                    _("Unable to switch to new document class."),
  2672.                    _("Reverting to original document class."));
  2673.             fl_set_choice(fd_form_document->choice_class, params->textclass + 1);
  2674.         }
  2675.     }
  2676.  
  2677.     char tmpsep = params->paragraph_separation;
  2678.     if (fl_get_button(fd_form_document->radio_indent))
  2679.         params->paragraph_separation = LYX_PARSEP_INDENT;
  2680.     else
  2681.         params->paragraph_separation = LYX_PARSEP_SKIP;
  2682.     if (tmpsep != params->paragraph_separation)
  2683.         redo = true;
  2684.    
  2685.     VSpace tmpdefskip = params->getDefSkip();
  2686.     switch (fl_get_choice (fd_form_document->choice_default_skip)) {
  2687.     case 1: params->setDefSkip(VSpace::SMALLSKIP); break;
  2688.     case 2: params->setDefSkip(VSpace::MEDSKIP); break;
  2689.     case 3: params->setDefSkip(VSpace::BIGSKIP); break;
  2690.     case 4: params->setDefSkip( 
  2691.         VSpace (LyXGlueLength (fl_get_input 
  2692.                        (fd_form_document->input_default_skip))));
  2693.     break;
  2694.     // DocumentDefskipCB assures that this never happens
  2695.     default: params->setDefSkip(VSpace::MEDSKIP); break;
  2696.     }
  2697.     if (!(tmpdefskip == params->getDefSkip()))
  2698.         redo = true;
  2699.  
  2700.     if (fl_get_button(fd_form_document->radio_columns_two))
  2701.         params->columns = 2;
  2702.     else
  2703.         params->columns = 1;
  2704.     if (fl_get_button(fd_form_document->radio_sides_two))
  2705.         params->sides = 2;
  2706.     else
  2707.         params->sides = 1;
  2708.  
  2709.     Spacing tmpSpacing = params->spacing;
  2710.     switch(fl_get_choice(fd_form_document->choice_spacing)) {
  2711.     case 1:
  2712.         lyxerr.debug("Spacing: SINGLE");
  2713.         params->spacing.set(Spacing::Single);
  2714.         break;
  2715.     case 2:
  2716.         lyxerr.debug("Spacing: ONEHALF");
  2717.         params->spacing.set(Spacing::Onehalf);
  2718.         break;
  2719.     case 3:
  2720.         lyxerr.debug("Spacing: DOUBLE");
  2721.         params->spacing.set(Spacing::Double);
  2722.         break;
  2723.     case 4:
  2724.         lyxerr.debug("Spacing: OTHER");
  2725.         // not fully supported yet.
  2726.         params->spacing.set(Spacing::Other, 1.0);
  2727.         // The value needs to be set in another way.
  2728.         break;
  2729.     }
  2730.     if (tmpSpacing != params->spacing)
  2731.         redo = true;
  2732.     
  2733.     signed char tmpchar = (signed char) 
  2734.         fl_get_counter_value(fd_form_document->slider_secnumdepth);;
  2735.     if (params->secnumdepth != tmpchar)
  2736.         redo = true;
  2737.     params->secnumdepth = tmpchar;
  2738.    
  2739.     params->tocdepth = (signed char) 
  2740.         fl_get_counter_value(fd_form_document->slider_tocdepth);;
  2741.  
  2742.     params->float_placement =
  2743.         fl_get_input(fd_form_document->input_float_placement);
  2744.  
  2745.     // More checking should be done to ensure the string doesn't have
  2746.     // spaces or illegal placement characters in it. (thornley)
  2747.  
  2748.     if (redo)
  2749.         current_view->redoCurrentBuffer();
  2750.    
  2751.     minibuffer->Set(_("Document layout set"));
  2752.     current_view->currentBuffer()->markDirty();
  2753.  
  2754.         params->options =
  2755.         fl_get_input(fd_form_document->input_extra);
  2756.    
  2757. }
  2758.  
  2759.  
  2760. void DocumentCancelCB(FL_OBJECT *, long)
  2761. {
  2762.     fl_hide_form(fd_form_document->form_document);
  2763. }
  2764.  
  2765.  
  2766. void DocumentOKCB(FL_OBJECT *ob, long data)
  2767. {
  2768.     DocumentCancelCB(ob,data);
  2769.     DocumentApplyCB(ob,data);
  2770. }
  2771.  
  2772.  
  2773. void DocumentBulletsCB(FL_OBJECT *, long)
  2774. {
  2775.     bulletForm();
  2776.     // bullet callbacks etc. in bullet_panel.C -- ARRae
  2777. }
  2778.  
  2779.  
  2780. void GotoNote()
  2781. {
  2782.     if (!current_view->getScreen())
  2783.         return;
  2784.    
  2785.     current_view->getScreen()->HideCursor();
  2786.     BeforeChange();
  2787.     current_view->currentBuffer()->update(-2);
  2788.     LyXCursor tmp;
  2789.    
  2790.     if (!current_view->currentBuffer()->text->GotoNextNote()) {
  2791.         if (current_view->currentBuffer()->text->cursor.pos 
  2792.             || current_view->currentBuffer()->text->cursor.par !=
  2793.             current_view->currentBuffer()->text->FirstParagraph())
  2794.             {
  2795.                 tmp = current_view->currentBuffer()->text->cursor;
  2796.                 current_view->currentBuffer()->text->cursor.par =
  2797.                     current_view->currentBuffer()->text->FirstParagraph();
  2798.                 current_view->currentBuffer()->text->cursor.pos = 0;
  2799.                 if (!current_view->currentBuffer()->text->GotoNextNote()) {
  2800.                     current_view->currentBuffer()->text->cursor = tmp;
  2801.                     minibuffer->Set(_("No more notes"));
  2802.                     LyXBell();
  2803.                 }
  2804.             } else {
  2805.                 minibuffer->Set(_("No more notes"));
  2806.                 LyXBell();
  2807.             }
  2808.     }
  2809.     current_view->currentBuffer()->update(0);
  2810.     current_view->currentBuffer()->text->sel_cursor =
  2811.         current_view->currentBuffer()->text->cursor;
  2812. }
  2813.  
  2814.  
  2815. void InsertCorrectQuote()
  2816. {
  2817.     Buffer *cbuffer = current_view->currentBuffer();
  2818.     char c;
  2819.  
  2820.     if  (cbuffer->text->cursor.pos )
  2821.         c = cbuffer->text->cursor.par->GetChar(cbuffer->text->cursor.pos - 1);
  2822.     else 
  2823.         c = ' ';
  2824.  
  2825.     cbuffer->insertInset(new InsetQuotes(c, cbuffer->params));
  2826. }
  2827.  
  2828.  
  2829. /* callbacks for form form_quotes */
  2830.  
  2831. void QuotesApplyCB(FL_OBJECT *, long)
  2832. {
  2833.     if (!current_view->available())
  2834.         return;
  2835.     
  2836.     minibuffer->Set(_("Quotes type set"));
  2837.     InsetQuotes::quote_language lga = InsetQuotes::EnglishQ;
  2838.     switch(fl_get_choice(fd_form_quotes->choice_quotes_language) - 1) {
  2839.     case 0:
  2840.         lga = InsetQuotes::EnglishQ;
  2841.         break;
  2842.     case 1:
  2843.         lga = InsetQuotes::SwedishQ;
  2844.         break;
  2845.     case 2:
  2846.         lga = InsetQuotes::GermanQ;
  2847.         break;
  2848.     case 3:
  2849.         lga = InsetQuotes::PolishQ;
  2850.         break;
  2851.     case 4:
  2852.         lga = InsetQuotes::FrenchQ;
  2853.         break;
  2854.     case 5:
  2855.         lga = InsetQuotes::DanishQ;
  2856.         break;
  2857.     }
  2858.     current_view->currentBuffer()->params.quotes_language = lga;
  2859.     if (fl_get_button(fd_form_quotes->radio_single))   
  2860.         current_view->currentBuffer()->
  2861.             params.quotes_times = InsetQuotes::SingleQ;
  2862.     else
  2863.         current_view->currentBuffer()->
  2864.             params.quotes_times = InsetQuotes::DoubleQ;
  2865. }
  2866.  
  2867.  
  2868. void QuotesCancelCB(FL_OBJECT *, long)
  2869. {
  2870.     fl_hide_form(fd_form_quotes->form_quotes);
  2871. }
  2872.  
  2873.  
  2874. void QuotesOKCB(FL_OBJECT *ob, long data)
  2875. {
  2876.     QuotesApplyCB(ob, data);
  2877.     QuotesCancelCB(ob, data);
  2878. }
  2879.  
  2880.  
  2881.  
  2882. /* callbacks for form form_preamble */
  2883.  
  2884. void PreambleCancelCB(FL_OBJECT *, long)
  2885. {
  2886.     fl_hide_form(fd_form_preamble->form_preamble);
  2887. }
  2888.  
  2889.  
  2890. void PreambleApplyCB(FL_OBJECT *, long)
  2891. {
  2892.     if (!current_view->available())
  2893.         return;
  2894.     
  2895.     current_view->currentBuffer()->params.preamble =
  2896.         fl_get_input(fd_form_preamble->input_preamble);
  2897.     current_view->currentBuffer()->markDirty();
  2898.     minibuffer->Set(_("LaTeX preamble set"));
  2899. }
  2900.  
  2901.    
  2902. void PreambleOKCB(FL_OBJECT *ob, long data)
  2903. {
  2904.     PreambleApplyCB(ob, data);
  2905.     PreambleCancelCB(ob, data);
  2906. }
  2907.  
  2908.  
  2909. /* callbacks for form form_table */
  2910.  
  2911. void TableApplyCB(FL_OBJECT *, long)
  2912. {
  2913.     int xsize,ysize;
  2914.     if (!current_view->getScreen())
  2915.         return;
  2916.    
  2917.     // check for tables in tables
  2918.     if (current_view->currentBuffer()->text->cursor.par->table){
  2919.         WriteAlert(_("Impossible Operation!"),
  2920.                _("Cannot insert table in table."),
  2921.                _("Sorry."));
  2922.         return;
  2923.     }
  2924.  
  2925.     minibuffer->Set(_("Inserting table..."));
  2926.  
  2927.     ysize = int(fl_get_slider_value(fd_form_table->slider_columns) + 0.5);
  2928.     xsize = int(fl_get_slider_value(fd_form_table->slider_rows) + 0.5);
  2929.    
  2930.    
  2931.     current_view->getScreen()->HideCursor();
  2932.     BeforeChange();
  2933.     current_view->currentBuffer()->update(-2);
  2934.    
  2935.     current_view->currentBuffer()->text->SetCursorParUndo(); 
  2936.     current_view->currentBuffer()->text->FreezeUndo();
  2937.  
  2938.     current_view->currentBuffer()->text->BreakParagraph();
  2939.     current_view->currentBuffer()->update(-1);
  2940.    
  2941.     if (current_view->currentBuffer()->text->cursor.par->Last()) {
  2942.         current_view->currentBuffer()->text->CursorLeft();
  2943.       
  2944.         current_view->currentBuffer()->text->BreakParagraph();
  2945.         current_view->currentBuffer()->update(-1);
  2946.     }
  2947.  
  2948.     current_view->currentBuffer()->text->current_font.setLatex(LyXFont::OFF);
  2949.     // insert the new wysiwy table
  2950.     current_view->currentBuffer()->text->SetLayout(0); // standard layout
  2951.     if (current_view->currentBuffer()->text->cursor.par->footnoteflag ==
  2952.         LyXParagraph::NO_FOOTNOTE) {
  2953.         current_view->currentBuffer()->
  2954.             text->SetParagraph(0, 0,
  2955.                        0, 0,
  2956.                        VSpace (0.3 * current_view->currentBuffer()->
  2957.                            params.spacing.getValue(),
  2958.                            LyXLength::CM),
  2959.                        VSpace (0.3 * current_view->currentBuffer()->
  2960.                            params.spacing.getValue(),
  2961.                            LyXLength::CM),
  2962.                        LYX_ALIGN_CENTER,
  2963.                        LString(),
  2964.                        0);
  2965.     } else
  2966.         current_view->currentBuffer()->text->SetParagraph(0, 0,
  2967.                        0, 0,
  2968.                        VSpace::NONE, VSpace::NONE,
  2969.                        LYX_ALIGN_CENTER, 
  2970.                        LString(),
  2971.                        0);
  2972.  
  2973.     current_view->currentBuffer()->text->cursor.par->table = new LyXTable(xsize, ysize);
  2974.     int i;
  2975.     for (i=0; i<xsize * ysize - 1; i++)
  2976.         current_view->currentBuffer()->text->cursor.par->InsertChar(0,LYX_META_NEWLINE);
  2977.     current_view->currentBuffer()->text->RedoParagraph();
  2978.    
  2979.     current_view->currentBuffer()->text->UnFreezeUndo();
  2980.      
  2981.     current_view->currentBuffer()->update(1);
  2982.     minibuffer->Set(_("Table inserted"));
  2983. }
  2984.  
  2985.  
  2986. void TableCancelCB(FL_OBJECT *, long)
  2987. {
  2988.     fl_hide_form(fd_form_table->form_table);
  2989. }
  2990.  
  2991.  
  2992. void TableOKCB(FL_OBJECT *ob, long data)
  2993. {
  2994.     TableApplyCB(ob,data);
  2995.     TableCancelCB(ob,data);
  2996. }
  2997.  
  2998.  
  2999. /* callbacks for form form_print */
  3000.  
  3001. void PrintCancelCB(FL_OBJECT *, long)
  3002. {
  3003.     fl_hide_form(fd_form_print->form_print);
  3004. }
  3005.  
  3006.  
  3007. void PrintApplyCB(FL_OBJECT *, long)
  3008. {
  3009.     if (!current_view->available())
  3010.         return;
  3011.         Buffer *buffer = current_view->currentBuffer();
  3012.         LString path = OnlyPath(buffer->getFileName());
  3013.  
  3014.     LString pageflag;
  3015.     if (fl_get_button(fd_form_print->radio_even_pages))
  3016.         pageflag = lyxrc->print_evenpage_flag + ' ';
  3017.     else if (fl_get_button(fd_form_print->radio_odd_pages))
  3018.         pageflag = lyxrc->print_oddpage_flag + ' ';
  3019.    
  3020.     LString reverseflag;
  3021.     if (fl_get_button(fd_form_print->radio_order_reverse))
  3022.         reverseflag = lyxrc->print_reverse_flag + ' ';
  3023.    
  3024.     LString orientationflag;
  3025.     if (buffer->params.orientation == ORIENTATION_LANDSCAPE)
  3026.         orientationflag = lyxrc->print_landscape_flag + ' ';
  3027.    
  3028.     LString ps_file = fl_get_input(fd_form_print->input_file);
  3029.     LString printer = fl_get_input(fd_form_print->input_printer);
  3030.  
  3031.     LString printerflag;
  3032.     if (lyxrc->print_adapt_output // printer name should be passed to dvips
  3033.         && ! printer.empty()) // a printer name has been given
  3034.         printerflag = lyxrc->print_to_printer + printer + ' ';
  3035.      
  3036.     LString command = lyxrc->print_command + ' ' 
  3037.         + printerflag + pageflag + reverseflag 
  3038.         + orientationflag + lyxrc->print_extra_options;
  3039.  
  3040.     if (fl_get_button(fd_form_print->radio_file))
  3041.         command += lyxrc->print_to_file + " \""
  3042.             + MakeAbsPath(ps_file, path)
  3043.             + '\"';
  3044.     else if (!lyxrc->print_spool_command.empty())
  3045.         command += lyxrc->print_to_file 
  3046.             + " \"" + ps_file + '\"';
  3047.     
  3048.     // push directorypath, if necessary 
  3049.         if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)){
  3050.         path = buffer->tmppath;
  3051.         }
  3052.         //PathPush(path);
  3053.     Path p(path);
  3054.     if (!lyxrc->print_spool_command.empty() && 
  3055.         !fl_get_button(fd_form_print->radio_file)) {
  3056.             LString command2 = lyxrc->print_spool_command + ' ';
  3057.         if (!printer.empty())
  3058.             command2 += lyxrc->print_spool_printerprefix 
  3059.                     + printer;
  3060.         // First run dvips and, if succesful, then spool command
  3061.         if (RunScript(buffer, true, command)) {
  3062.             RunScript(buffer, false, command2, ps_file);
  3063.         }
  3064.         } else
  3065.         RunScript(buffer, false, command);
  3066.         //PathPop();
  3067. }
  3068.  
  3069.  
  3070. void PrintOKCB(FL_OBJECT *ob, long data)
  3071. {
  3072.     PrintCancelCB(ob, data);  
  3073.     PrintApplyCB(ob,data);
  3074. }
  3075.  
  3076.  
  3077. /* callbacks for form form_figure */
  3078.  
  3079. void FigureApplyCB(FL_OBJECT *, long)
  3080. {
  3081.     if (!current_view->available())
  3082.         return;
  3083.  
  3084.     Buffer * buffer = current_view->currentBuffer();
  3085.     if(buffer->isReadonly()) // paranoia
  3086.         return;
  3087.     
  3088.     minibuffer->Set(_("Inserting figure..."));
  3089.     if (fl_get_button(fd_form_figure->radio_inline)
  3090.         || buffer->text->cursor.par->table){
  3091.         buffer->insertInset(new InsetFig(100, 20, buffer));
  3092.         minibuffer->Set(_("Figure inserted"));
  3093.         return;
  3094.     }
  3095.     
  3096.     current_view->getScreen()->HideCursor();
  3097.     buffer->update(-2);
  3098.     BeforeChange();
  3099.       
  3100.     buffer->text->SetCursorParUndo(); 
  3101.     buffer->text->FreezeUndo();
  3102.  
  3103.     buffer->text->BreakParagraph();
  3104.     buffer->update(-1);
  3105.       
  3106.     if (buffer->text->cursor.par->Last()) {
  3107.         buffer->text->CursorLeft();
  3108.      
  3109.         buffer->text->BreakParagraph();
  3110.         buffer->update(-1);
  3111.     }
  3112.  
  3113.     // The standard layout should always be numer 0;
  3114.     buffer->text->SetLayout(0);
  3115.     
  3116.     if (buffer->text->cursor.par->footnoteflag ==
  3117.         LyXParagraph::NO_FOOTNOTE) {
  3118.         buffer->text->SetParagraph(0, 0,
  3119.                        0, 0,
  3120.                        VSpace (0.3 * buffer->params.spacing.getValue(),
  3121.                            LyXLength::CM),
  3122.                        VSpace (0.3 *
  3123.                            buffer->params.spacing.getValue(),
  3124.                            LyXLength::CM),
  3125.                        LYX_ALIGN_CENTER, LString(), 0);
  3126.     } else
  3127.         buffer->text->SetParagraph(0, 0,
  3128.                        0, 0,
  3129.                        VSpace::NONE, VSpace::NONE,
  3130.                        LYX_ALIGN_CENTER, 
  3131.                        LString(),
  3132.                        0);
  3133.     
  3134.     buffer->update(-1);
  3135.       
  3136.     Inset *new_inset = NULL;
  3137.     
  3138.     new_inset = new InsetFig(100, 100, buffer);
  3139.     buffer->insertInset(new_inset);
  3140.     
  3141.     buffer->update(0);
  3142.     minibuffer->Set(_("Figure inserted"));
  3143.     buffer->text->UnFreezeUndo();
  3144. }
  3145.  
  3146.    
  3147. void FigureCancelCB(FL_OBJECT *, long)
  3148. {
  3149.     fl_hide_form(fd_form_figure->form_figure);
  3150. }
  3151.  
  3152.  
  3153. void FigureOKCB(FL_OBJECT *ob, long data)
  3154. {
  3155.     FigureApplyCB(ob,data);
  3156.     FigureCancelCB(ob,data);
  3157. }
  3158.  
  3159. void ScreenApplyCB(FL_OBJECT *, long)
  3160. {
  3161.     lyxrc->roman_font_name = fl_get_input(fd_form_screen->input_roman);
  3162.     lyxrc->sans_font_name = fl_get_input(fd_form_screen->input_sans);
  3163.     lyxrc->typewriter_font_name = fl_get_input(fd_form_screen->input_typewriter);
  3164.     lyxrc->font_norm = fl_get_input(fd_form_screen->input_font_norm);
  3165.     lyxrc->zoom = atoi(fl_get_input(fd_form_screen->intinput_size));
  3166.     fontloader.update();
  3167.    
  3168.     // All buffers will need resize
  3169.     bufferlist.resize();
  3170.  
  3171.     minibuffer->Set(_("Screen options set"));
  3172. }
  3173.  
  3174.  
  3175. void ScreenCancelCB(FL_OBJECT *, long)
  3176. {
  3177.     fl_hide_form(fd_form_screen->form_screen);
  3178. }
  3179.  
  3180.  
  3181. void ScreenOKCB(FL_OBJECT *ob, long data)
  3182. {
  3183.     ScreenCancelCB(ob,data);
  3184.     ScreenApplyCB(ob,data);
  3185. }
  3186.  
  3187.  
  3188. void LaTeXOptions()
  3189. {
  3190.     if (!current_view->available())
  3191.         return;
  3192.  
  3193.     fl_set_button(fd_latex_options->accents,
  3194.               (int)current_view->currentBuffer()->params.allowAccents);
  3195.     
  3196.     if (fd_latex_options->LaTeXOptions->visible) {
  3197.         fl_raise_form(fd_latex_options->LaTeXOptions);
  3198.     } else {
  3199.         fl_show_form(fd_latex_options->LaTeXOptions,
  3200.                  FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
  3201.                  _("LaTeX Options"));
  3202.     }
  3203. }
  3204.  
  3205.  
  3206. // This function runs "configure" and then rereads lyx.defaults to
  3207. // reconfigure the automatic settings.
  3208. void Reconfigure()
  3209. {
  3210.     minibuffer->Set(_("Running configure..."));
  3211.  
  3212.     // Run configure in user lyx directory
  3213.     //PathPush(user_lyxdir);
  3214.     Path p(user_lyxdir);
  3215.     Systemcalls one(Systemcalls::System, 
  3216.                           AddName(system_lyxdir,"configure"));
  3217.     //PathPop();
  3218.     minibuffer->Set(_("Reloading configuration..."));
  3219.     lyxrc->Read(LibFileSearch(LString(), "lyxrc.defaults"));
  3220.     WriteAlert(_("The system has been reconfigured."), 
  3221.            _("You need to restart LyX to make use of any"),
  3222.            _("updated document class specifications."));
  3223. }
  3224.  
  3225.  
  3226. /* these functions are for the spellchecker */ 
  3227. char* NextWord(float &value)
  3228. {
  3229.     if (!current_view->available()){
  3230.         value = 1;
  3231.         return NULL;
  3232.     }
  3233.    
  3234.     char* string =  current_view->currentBuffer()->text->SelectNextWord(value);
  3235.  
  3236.     return string;
  3237. }
  3238.  
  3239.   
  3240. void SelectLastWord()
  3241. {
  3242.     if (!current_view->available())
  3243.         return;
  3244.    
  3245.     current_view->getScreen()->HideCursor();
  3246.     BeforeChange(); 
  3247.     current_view->currentBuffer()->text->SelectSelectedWord();
  3248.     current_view->getScreen()->ToggleSelection(false);
  3249.     current_view->currentBuffer()->update(0);
  3250. }
  3251.  
  3252.  
  3253. void EndOfSpellCheck()
  3254. {
  3255.     if (!current_view->available())
  3256.         return;
  3257.    
  3258.     current_view->getScreen()->HideCursor();
  3259.     BeforeChange(); 
  3260.     current_view->currentBuffer()->text->SelectSelectedWord();
  3261.     current_view->currentBuffer()->text->ClearSelection();
  3262.     current_view->currentBuffer()->update(0);
  3263. }
  3264.  
  3265.  
  3266. void ReplaceWord(LString const & replacestring)
  3267. {
  3268.     if (!current_view->getScreen())
  3269.         return;
  3270.  
  3271.     current_view->getScreen()->HideCursor();
  3272.     current_view->currentBuffer()->update(-2);
  3273.    
  3274.     /* clear the selection (if there is any) */ 
  3275.     current_view->getScreen()->ToggleSelection(false);
  3276.     current_view->currentBuffer()->text->
  3277.         ReplaceSelectionWithString(replacestring.c_str());
  3278.    
  3279.     current_view->currentBuffer()->text->SetSelectionOverString(replacestring.c_str());
  3280.  
  3281.     // Go back so that replacement string is also spellchecked
  3282.     for (int i=-1; i< replacestring.length(); i++) {
  3283.         current_view->currentBuffer()->text->CursorLeftIntern();
  3284.     }
  3285.     current_view->currentBuffer()->update(1);
  3286. }
  3287. // End of spellchecker stuff
  3288.  
  3289.  
  3290.  
  3291. //
  3292. // Table of Contents
  3293. //
  3294.  
  3295. struct TocList {
  3296.     char counter[6];
  3297.     TocList *next;
  3298. };
  3299.  
  3300.  
  3301. static TocList* toclist = NULL;
  3302.  
  3303.  
  3304. void TocSelectCB(FL_OBJECT *ob, long)
  3305. {
  3306.     if (!current_view->available())
  3307.         return;
  3308.    
  3309.     TocList* tmptoclist = toclist;
  3310.     int i = fl_get_browser(ob);
  3311.     int a = 0;
  3312.  
  3313.     for (a=1; a<i && tmptoclist->next; a++){
  3314.         tmptoclist = tmptoclist->next;
  3315.     }
  3316.  
  3317.     if (!tmptoclist)
  3318.         return;
  3319.      
  3320.  
  3321.     LyXParagraph *par = current_view->currentBuffer()->paragraph;
  3322.     while (par && 
  3323.            (
  3324.                par->GetCounter(0) != tmptoclist->counter[0] ||
  3325.                par->GetCounter(1) != tmptoclist->counter[1] ||
  3326.                par->GetCounter(2) != tmptoclist->counter[2] ||
  3327.                par->GetCounter(3) != tmptoclist->counter[3] ||
  3328.                par->GetCounter(4) != tmptoclist->counter[4] ||
  3329.                par->GetCounter(5) != tmptoclist->counter[5]
  3330.                )
  3331.         ) {
  3332.         par = par->LastPhysicalPar()->Next();
  3333.     }
  3334.    
  3335.     if (par) {
  3336.         BeforeChange();
  3337.         current_view->currentBuffer()->text->SetCursor(par, 0);
  3338.         current_view->currentBuffer()->text->sel_cursor =
  3339.             current_view->currentBuffer()->text->cursor;
  3340.         current_view->currentBuffer()->update(0);
  3341.     }
  3342.     else {
  3343.         WriteAlert(_("Error"), 
  3344.                _("Couldn't find this label"), 
  3345.                _("in current document."));
  3346.     }
  3347.       
  3348. }
  3349.  
  3350.  
  3351. void TocCancelCB(FL_OBJECT *, long)
  3352. {
  3353.     fl_hide_form(fd_form_toc->form_toc);
  3354. }
  3355.  
  3356.  
  3357. void TocUpdateCB(FL_OBJECT *, long)
  3358. {
  3359.     static LyXParagraph* stapar = NULL;
  3360.     TocList *tmptoclist = NULL;
  3361.    
  3362.     /* deleted the toclist */ 
  3363.     if (toclist){
  3364.         while (toclist){
  3365.             tmptoclist = toclist->next;
  3366.             delete toclist;
  3367.             toclist = tmptoclist;
  3368.         }
  3369.     }
  3370.     toclist = NULL;
  3371.     tmptoclist = toclist;
  3372.  
  3373.  
  3374.     fl_clear_browser(fd_form_toc->browser_toc);
  3375.     if (!current_view->available()) {
  3376.         fl_add_browser_line(fd_form_toc->browser_toc, _("*** No Document ***"));
  3377.         return;
  3378.     }
  3379.     fl_hide_object(fd_form_toc->browser_toc);
  3380.     /* get the table of contents */ 
  3381.     LyXParagraph *par = current_view->currentBuffer()->paragraph;
  3382.     char labeltype;
  3383.     char* line = new char[200];
  3384.     int i = 0;
  3385.     int pos = 0;
  3386.     unsigned char c;
  3387.     int topline = 0;
  3388.    
  3389.     if (stapar == par)
  3390.         topline = fl_get_browser_topline(fd_form_toc->browser_toc);
  3391.     stapar = par;
  3392.    
  3393.     while (par) {
  3394.         labeltype = lyxstyle.Style(current_view->currentBuffer()->params.textclass, 
  3395.                        par->GetLayout())->labeltype;
  3396.       
  3397.         if (labeltype >= LABEL_COUNTER_CHAPTER
  3398.             && labeltype <= LABEL_COUNTER_CHAPTER +
  3399.             current_view->currentBuffer()->params.tocdepth) {
  3400.             /* insert this into the table of contents */ 
  3401.             /* first indent a little bit */ 
  3402.             
  3403.             for (pos=0; 
  3404.                  pos < (labeltype - 
  3405.                     lyxstyle.TextClass(current_view->currentBuffer()->
  3406.                                params.textclass)->maxcounter) * 4 + 2;
  3407.                  pos++)
  3408.                 line[pos] = ' ';
  3409.             
  3410.             /* then the labelstring */ 
  3411.             i = 0;
  3412.             if (!par->labelstring.empty()) {
  3413.                 while (pos < 199 && i < par->labelstring.length()) {
  3414.                     line[pos] = par->labelstring[i];
  3415.                     i++;
  3416.                     pos++;
  3417.                 }
  3418.             }
  3419.      
  3420.             line[pos] = ' ';
  3421.             pos++;
  3422.             
  3423.             /* now the contents */ 
  3424.             i = 0;
  3425.             while (pos < 199 && i < par->last) {
  3426.                 c = par->GetChar(i);
  3427.                 if (isprint((unsigned char) c) || c >= 128) {
  3428.                     line[pos] = c;
  3429.                     pos++;
  3430.                 }
  3431.                 i++;
  3432.             }
  3433.             line[pos] = '\0';
  3434.             fl_add_browser_line(fd_form_toc->browser_toc, line);
  3435.             
  3436.             /* make a toclist entry */
  3437.             if (!tmptoclist){
  3438.                 tmptoclist = new TocList;
  3439.                 toclist = tmptoclist;
  3440.             } else {
  3441.                 tmptoclist->next = new TocList;
  3442.                 tmptoclist = tmptoclist->next;
  3443.             }
  3444.             
  3445.             tmptoclist->next = NULL;
  3446.             int a = 0;
  3447.             for (a=0; a<6; a++){
  3448.                 tmptoclist->counter[a] = par->GetCounter(a);
  3449.             }
  3450.         }
  3451.         par = par->LastPhysicalPar()->Next();
  3452.         
  3453.     }
  3454.     delete[] line;
  3455.     fl_set_browser_topline(fd_form_toc->browser_toc, topline);
  3456.     fl_show_object(fd_form_toc->browser_toc);
  3457. }
  3458.  
  3459.  
  3460. /* callbacks for form form_ref */
  3461. void RefSelectCB(FL_OBJECT *, long data)
  3462. {
  3463.     if (!current_view->available())
  3464.         return;
  3465.  
  3466.     LString s =
  3467.         fl_get_browser_line(fd_form_ref->browser_ref,
  3468.                     fl_get_browser(fd_form_ref->browser_ref));
  3469.     if (s.empty())
  3470.         return;
  3471.  
  3472.     if (!current_view->currentBuffer()->isLinuxDoc()) {
  3473.             if (data==2) {
  3474.                     current_view->getOwner()->getLyXFunc()->Dispatch(LFUN_REFGOTO, s.c_str());
  3475.                 return;
  3476.         }
  3477.         
  3478.         LString t;
  3479.         if (data==0)
  3480.             t += "\\ref{";
  3481.         else
  3482.             t += "\\pageref{";
  3483.         t += s;
  3484.         t += '}';
  3485.         Inset *new_inset =
  3486.             new InsetRef(t, current_view->currentBuffer());
  3487.         current_view->currentBuffer()->insertInset(new_inset);
  3488.     } else {
  3489. #ifdef WITH_WARNINGS
  3490. #warning FIXME!
  3491. #endif
  3492.         // probably changes should be made to InsetRef to handle
  3493.         // linuxdoc as well. (Lgb)
  3494.     }
  3495. }
  3496.  
  3497.  
  3498. void RefUpdateCB(FL_OBJECT *, long)
  3499. {
  3500.     fl_clear_browser(fd_form_ref->browser_ref);
  3501.     if (!current_view->available())
  3502.         return;
  3503.  
  3504.     LString references;
  3505.     LString curr_ref;
  3506.     int ref_num;
  3507.  
  3508.     ref_num=0;
  3509.     references=current_view->currentBuffer()->getReferenceList();
  3510.     
  3511.     while(true) {
  3512.         curr_ref=references.token('|',ref_num);
  3513.         
  3514.         if (curr_ref=="")
  3515.             break;
  3516.  
  3517.         fl_add_browser_line(fd_form_ref->browser_ref,curr_ref.c_str());
  3518.         ref_num++;
  3519.     }
  3520.  
  3521.     if (!fl_get_browser_maxline(fd_form_ref->browser_ref)) {
  3522.         fl_add_browser_line(fd_form_ref->browser_ref, 
  3523.                     _("*** No labels found in document ***"));
  3524.         fl_deactivate_object(fd_form_ref->browser_ref);
  3525.     } else {
  3526.         fl_select_browser_line(fd_form_ref->browser_ref, 1);
  3527.         fl_activate_object(fd_form_ref->browser_ref);
  3528.     }
  3529. }
  3530.  
  3531.  
  3532. void RefHideCB(FL_OBJECT *, long)
  3533. {
  3534.     fl_hide_form(fd_form_ref->form_ref);
  3535. }
  3536.  
  3537.  
  3538. void UpdateInset(Inset* inset, bool mark_dirty)
  3539. {
  3540.     if (!inset)
  3541.         return;
  3542.  
  3543.     /* very first check for locking insets*/
  3544.     if (current_view->currentBuffer()->the_locking_inset == inset){
  3545.         if (current_view->currentBuffer()->text->UpdateInset(inset)){
  3546.             current_view->update();
  3547.             if (mark_dirty){
  3548.                 if (current_view->currentBuffer()->isLyxClean())
  3549.                     minibuffer->setTimer(4);
  3550.                 current_view->currentBuffer()->markDirty();
  3551.             }
  3552.             current_view->updateScrollbar();
  3553.             return;
  3554.         }
  3555.     }
  3556.   
  3557.     /* first check the current buffer */
  3558.     if (current_view->available()){
  3559.         current_view->getScreen()->HideCursor();
  3560.         current_view->currentBuffer()->update(-3);
  3561.         if (current_view->currentBuffer()->text->UpdateInset(inset)){
  3562.             if (mark_dirty)
  3563.                 current_view->currentBuffer()->update(1);
  3564.             else 
  3565.                 current_view->currentBuffer()->update(3);
  3566.             return;
  3567.         }
  3568.     }
  3569.   
  3570.     // check all buffers
  3571.     bufferlist.updateInset(inset, mark_dirty);
  3572.  
  3573. }
  3574.  
  3575.  
  3576. /* these functions return 1 if an error occured, 
  3577.    otherwise 0 */
  3578. bool LockInset(UpdatableInset* inset)
  3579. {
  3580.     if (!current_view->currentBuffer()->the_locking_inset && inset){
  3581.         current_view->currentBuffer()->the_locking_inset = inset;
  3582.         return false;
  3583.     }
  3584.     return true;
  3585. }
  3586.  
  3587.  
  3588. void ShowLockedInsetCursor(long x, long y, int asc, int desc)
  3589. {
  3590.     if (current_view->currentBuffer()->the_locking_inset &&
  3591.         current_view->getScreen()){
  3592.         y += current_view->currentBuffer()->text->cursor.y;
  3593.         current_view->getScreen()->ShowManualCursor(x, y,
  3594.                                 asc, desc);
  3595.     }
  3596. }
  3597.  
  3598.  
  3599. void HideLockedInsetCursor(long x, long y, int asc, int desc)
  3600. {
  3601.     if (current_view->currentBuffer()->the_locking_inset &&
  3602.         current_view->getScreen()){
  3603.         y += current_view->currentBuffer()->text->cursor.y;
  3604.         current_view->getScreen()->HideManualCursor(x, y,
  3605.                                 asc, desc);
  3606.     }
  3607. }
  3608.  
  3609.  
  3610. void FitLockedInsetCursor(long x, long y, int asc, int desc)
  3611. {
  3612.     if (current_view->currentBuffer()->the_locking_inset &&
  3613.         current_view->getScreen()){
  3614.         y += current_view->currentBuffer()->text->cursor.y;
  3615.         if (current_view->getScreen()->FitManualCursor(x, y, asc, desc))
  3616.             current_view->updateScrollbar();
  3617.     }
  3618. }
  3619.  
  3620.  
  3621. int UnlockInset(UpdatableInset* inset)
  3622. {
  3623.     if (inset &&
  3624.         current_view->currentBuffer()->the_locking_inset == inset){
  3625.         inset->InsetUnlock();
  3626.         current_view->currentBuffer()->the_locking_inset = NULL;
  3627.         current_view->currentBuffer()->text->FinishUndo();
  3628.         return 0;
  3629.     }
  3630.     return bufferlist.unlockInset(inset);
  3631. }
  3632.  
  3633.  
  3634. void LockedInsetStoreUndo(Undo::undo_kind kind)
  3635. {
  3636.     if (!current_view->currentBuffer()->the_locking_inset)
  3637.         return; // shouldn't happen
  3638.     if (kind == Undo::EDIT) // in this case insets would not be stored!
  3639.         kind = Undo::FINISH;
  3640.     current_view->currentBuffer()->text->SetUndo(kind,
  3641.                   current_view->currentBuffer()->text->cursor.par->
  3642.                   ParFromPos(current_view->currentBuffer()->text->cursor.pos)->previous, 
  3643.                   current_view->currentBuffer()->text->cursor.par->
  3644.                   ParFromPos(current_view->currentBuffer()->text->cursor.pos)->next); 
  3645. }
  3646.  
  3647.  
  3648. void PutInsetIntoInsetUpdateList(Inset* inset)
  3649. {
  3650.     if (inset) {
  3651.         InsetUpdateStruct* tmp = new InsetUpdateStruct();
  3652.         tmp->inset = inset;
  3653.         tmp->next = InsetUpdateList;
  3654.         InsetUpdateList = tmp;
  3655.     }
  3656. }
  3657.  
  3658.  
  3659. void UpdateInsetUpdateList()
  3660. {
  3661.     InsetUpdateStruct *tmp = InsetUpdateList;
  3662.     while (tmp) {
  3663.         UpdateInset(tmp->inset, false); // "false" because no document change
  3664.         tmp = tmp->next;
  3665.     }
  3666.   
  3667.     /* delete the update list */
  3668.     while (InsetUpdateList) {
  3669.         tmp = InsetUpdateList;
  3670.         InsetUpdateList = InsetUpdateList->next;
  3671.         delete tmp;
  3672.     }
  3673.     InsetUpdateList = NULL;
  3674. }
  3675.