src/lyx_cb.C

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