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 #ifdef WITH_WARNINGS
1258 #warning remove this once we have a proper geometry class
1259 #endif
1260                 BufferParams::PAPER_SIZE ps = static_cast<BufferParams::PAPER_SIZE>(current_view->buffer()->params.papersize);
1261                 switch (ps) {
1262                 case BufferParams::PAPER_A4PAPER:
1263                         add_flags = "-p a4";
1264                         break;
1265                 case BufferParams::PAPER_USLETTER:
1266                         add_flags = "-p letter";
1267                         break;
1268                 default: /* nothing to be done yet ;-) */     break;
1269                 }
1270         }
1271
1272         ProhibitInput();
1273
1274         Systemcalls one;
1275         switch (flag) {
1276         case -1: /* Import file */
1277                 minibuffer->Set(_("Importing LinuxDoc SGML file `"),
1278                                 MakeDisplayPath(filename), "'...");
1279                 s2 = "sgml2lyx " + lyxrc->sgml_extra_options + ' '
1280                         + name;
1281                 if (one.startscript(Systemcalls::System, s2))
1282                         errorcode = 1;
1283                 break;
1284         case 0: /* TeX output asked */
1285                 minibuffer->Set(_("Converting LinuxDoc SGML to TeX file..."));
1286                 s2 = "sgml2latex " + add_flags + " -o tex "
1287                         + lyxrc->sgml_extra_options + ' ' + name;
1288                 if (one.startscript(Systemcalls::System, s2))
1289                         errorcode = 1;
1290                 break;
1291         case 1: /* dvi output asked */
1292                 minibuffer->Set(_("Converting LinuxDoc SGML to dvi file..."));
1293                 s2 = "sgml2latex " + add_flags + " -o dvi "
1294                         + lyxrc->sgml_extra_options + ' ' + name;
1295                 if (one.startscript(Systemcalls::System, s2)) {
1296                         errorcode = 1;
1297                 } else
1298                         current_view->buffer()->markDviClean();
1299                 break;
1300         default: /* unknown output */
1301                 break;
1302         }
1303
1304         AllowInput();
1305
1306         current_view->buffer()->redraw();
1307         return errorcode;
1308 }
1309
1310
1311 /*
1312  * SGML DocBook support:
1313  * (flag == 1) make dvi output
1314  */
1315 int RunDocBook(int flag, string const & filename)
1316 {
1317         string name;
1318         string s2;
1319         string path;
1320
1321         int errorcode = 0;
1322
1323         /* generate a path-less extension name */
1324         name = ChangeExtension (filename, ".sgml", true);
1325         path = OnlyPath (filename);
1326         if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) {
1327                 path = current_view->buffer()->tmppath;
1328         }
1329         Path p(path);
1330
1331         if (!current_view->available())
1332                 return 0;
1333
1334         current_view->buffer()->makeDocBookFile(name, 0);
1335
1336         // Shall this code go or should it stay? (Lgb)
1337 //      string add_flags;
1338 //      LYX_PAPER_SIZE ps = (LYX_PAPER_SIZE) current_view->buffer()->params.papersize;
1339 //      switch (ps) {
1340 //      case BufferParams::PAPER_A4PAPER:  add_flags = "-p a4";     break;
1341 //      case BufferParams::PAPER_USLETTER: add_flags = "-p letter"; break;
1342 //      default: /* nothing to be done yet ;-) */     break;
1343 //      }
1344         ProhibitInput();
1345
1346         Systemcalls one;
1347         switch (flag) {
1348         case 1: /* dvi output asked */
1349                 minibuffer->Set(_("Converting DocBook SGML to dvi file..."));
1350                 s2 = "sgmltools --backend dvi " + name;
1351                 if (one.startscript(Systemcalls::System, s2)) {
1352                         errorcode = 1;
1353                 } else
1354                         current_view->buffer()->markDviClean();
1355                 break;
1356         default: /* unknown output */
1357                 break;
1358         }
1359
1360         AllowInput();
1361
1362         current_view->buffer()->redraw();
1363         return errorcode;
1364 }
1365
1366
1367 void AllFloats(char flag, char figmar)
1368 {
1369         if (!current_view->available())
1370                 return;
1371
1372         LyXCursor cursor = current_view->buffer()->text->cursor;
1373
1374         if (!flag && cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE
1375             && ((figmar
1376                  && cursor.par->footnotekind != LyXParagraph::FOOTNOTE
1377                  && cursor.par->footnotekind != LyXParagraph::MARGIN)
1378                 || (!figmar
1379                     && cursor.par->footnotekind != LyXParagraph::FIG
1380                     && cursor.par->footnotekind != LyXParagraph::TAB
1381                     && cursor.par->footnotekind != LyXParagraph::WIDE_FIG
1382                     && cursor.par->footnotekind != LyXParagraph::WIDE_TAB
1383                     && cursor.par->footnotekind != LyXParagraph::ALGORITHM)))
1384                 ToggleFloat();
1385         else
1386                 BeforeChange();
1387
1388         LyXCursor tmpcursor = cursor;
1389         cursor.par = tmpcursor.par->ParFromPos(tmpcursor.pos);
1390         cursor.pos = tmpcursor.par->PositionInParFromPos(tmpcursor.pos);
1391
1392         LyXParagraph *par = current_view->buffer()->paragraph;
1393         while (par) {
1394                 if (flag) {
1395                         if (par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE
1396                             && (
1397                                     (figmar
1398                                      &&
1399                                      par->footnotekind != LyXParagraph::FOOTNOTE
1400                                      &&
1401                                      par->footnotekind !=  LyXParagraph::MARGIN
1402                                             )
1403                                     ||
1404                                     (!figmar
1405                                      &&
1406                                      par->footnotekind != LyXParagraph::FIG
1407                                      &&
1408                                      par->footnotekind != LyXParagraph::TAB
1409                                      &&
1410                                      par->footnotekind != LyXParagraph::WIDE_FIG
1411                                      &&
1412                                      par->footnotekind != LyXParagraph::WIDE_TAB
1413                                      &&
1414                                      par->footnotekind != LyXParagraph::ALGORITHM
1415                                             )
1416                                     )
1417                                 ){
1418                                 if (par->previous
1419                                     && par->previous->footnoteflag !=
1420                                     LyXParagraph::CLOSED_FOOTNOTE){ /* should be */
1421                                         current_view->buffer()->text->SetCursorIntern(par->previous,
1422                                                                       0);
1423                                         current_view->buffer()->text->OpenFootnote();
1424                                 }
1425                         }
1426                 }
1427                 else  {
1428                         if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
1429                             && (
1430                                     (figmar
1431                                      &&
1432                                      par->footnotekind != LyXParagraph::FOOTNOTE
1433                                      &&
1434                                      par->footnotekind !=  LyXParagraph::MARGIN
1435                                             )
1436                                     ||
1437                                     (!figmar
1438                                      &&
1439                                      par->footnotekind != LyXParagraph::FIG
1440                                      &&
1441                                      par->footnotekind != LyXParagraph::TAB
1442                                      &&
1443                                      par->footnotekind != LyXParagraph::WIDE_FIG
1444                                      &&
1445                                      par->footnotekind != LyXParagraph::WIDE_TAB
1446                                      &&
1447                                      par->footnotekind != LyXParagraph::ALGORITHM
1448                                             )
1449                                     )
1450                                 ){
1451                                 current_view->buffer()->text->SetCursorIntern(par, 0);
1452                                 current_view->buffer()->text->CloseFootnote();
1453                         }
1454                 }
1455                 par = par->next;
1456         }
1457
1458         current_view->buffer()->text->SetCursorIntern(cursor.par, cursor.pos);
1459         current_view->redraw();
1460         current_view->fitCursor();
1461         current_view->updateScrollbar();
1462 }
1463
1464
1465 void MenuLayoutCharacter()
1466 {
1467         static int ow = -1, oh;
1468
1469         if (fd_form_character->form_character->visible) {
1470                 fl_raise_form(fd_form_character->form_character);
1471         } else {
1472                 fl_show_form(fd_form_character->form_character,
1473                              FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
1474                              _("Character Style"));
1475                 if (ow < 0) {
1476                         ow = fd_form_character->form_character->w;
1477                         oh = fd_form_character->form_character->h;
1478                 }
1479                 fl_set_form_minsize(fd_form_character->form_character, ow, oh);
1480         }
1481 }
1482
1483
1484 inline void DeactivateParagraphButtons ()
1485 {
1486         fl_deactivate_object (fd_form_paragraph->button_ok);
1487         fl_deactivate_object (fd_form_paragraph->button_apply);
1488         fl_set_object_lcol (fd_form_paragraph->button_ok, FL_INACTIVE);
1489         fl_set_object_lcol (fd_form_paragraph->button_apply, FL_INACTIVE);
1490 }
1491
1492 inline void ActivateParagraphButtons ()
1493 {
1494         fl_activate_object (fd_form_paragraph->button_ok);
1495         fl_activate_object (fd_form_paragraph->button_apply);
1496         fl_set_object_lcol (fd_form_paragraph->button_ok, FL_BLACK);
1497         fl_set_object_lcol (fd_form_paragraph->button_apply, FL_BLACK);
1498 }
1499
1500 inline void DisableParagraphLayout ()
1501 {
1502         DeactivateParagraphButtons();
1503         fl_deactivate_object (fd_form_paragraph->input_labelwidth);
1504         fl_deactivate_object (fd_form_paragraph->check_lines_top);
1505         fl_deactivate_object (fd_form_paragraph->check_lines_bottom);
1506         fl_deactivate_object (fd_form_paragraph->check_pagebreaks_top);
1507         fl_deactivate_object (fd_form_paragraph->check_pagebreaks_bottom);
1508         fl_deactivate_object (fd_form_paragraph->check_noindent);
1509         fl_deactivate_object (fd_form_paragraph->group_radio_alignment);
1510         fl_deactivate_object (fd_form_paragraph->radio_align_right);
1511         fl_deactivate_object (fd_form_paragraph->radio_align_left);
1512         fl_deactivate_object (fd_form_paragraph->radio_align_block);
1513         fl_deactivate_object (fd_form_paragraph->radio_align_center);
1514         fl_deactivate_object (fd_form_paragraph->input_space_above);
1515         fl_deactivate_object (fd_form_paragraph->input_space_below);
1516         fl_deactivate_object (fd_form_paragraph->choice_space_above);
1517         fl_deactivate_object (fd_form_paragraph->choice_space_below);
1518         fl_deactivate_object (fd_form_paragraph->check_space_above);
1519         fl_deactivate_object (fd_form_paragraph->check_space_below);
1520 }
1521
1522 inline void EnableParagraphLayout ()
1523 {
1524         ActivateParagraphButtons();
1525         fl_activate_object (fd_form_paragraph->input_labelwidth);
1526         fl_activate_object (fd_form_paragraph->check_lines_top);
1527         fl_activate_object (fd_form_paragraph->check_lines_bottom);
1528         fl_activate_object (fd_form_paragraph->check_pagebreaks_top);
1529         fl_activate_object (fd_form_paragraph->check_pagebreaks_bottom);
1530         fl_activate_object (fd_form_paragraph->check_noindent);
1531         fl_activate_object (fd_form_paragraph->group_radio_alignment);
1532         fl_activate_object (fd_form_paragraph->radio_align_right);
1533         fl_activate_object (fd_form_paragraph->radio_align_left);
1534         fl_activate_object (fd_form_paragraph->radio_align_block);
1535         fl_activate_object (fd_form_paragraph->radio_align_center);
1536         fl_activate_object (fd_form_paragraph->input_space_above);
1537         fl_activate_object (fd_form_paragraph->input_space_below);
1538         fl_activate_object (fd_form_paragraph->choice_space_above);
1539         fl_activate_object (fd_form_paragraph->choice_space_below);
1540         fl_activate_object (fd_form_paragraph->check_space_above);
1541         fl_activate_object (fd_form_paragraph->check_space_below);
1542 }
1543
1544 bool UpdateLayoutParagraph()
1545 {
1546         if (!current_view->getScreen() || !current_view->available()) {
1547                 if (fd_form_paragraph->form_paragraph->visible)
1548                         fl_hide_form(fd_form_paragraph->form_paragraph);
1549                 return false;
1550         }
1551
1552         Buffer * buf = current_view->buffer();
1553
1554         fl_set_input(fd_form_paragraph->input_labelwidth,
1555                      buf->text->cursor.par->GetLabelWidthString().c_str());
1556         fl_set_button(fd_form_paragraph->radio_align_right, 0);
1557         fl_set_button(fd_form_paragraph->radio_align_left, 0);
1558         fl_set_button(fd_form_paragraph->radio_align_center, 0);
1559         fl_set_button(fd_form_paragraph->radio_align_block, 0);
1560
1561         int align = buf->text->cursor.par->GetAlign();
1562         if (align == LYX_ALIGN_LAYOUT)
1563                 align =         textclasslist.Style(buf->params.textclass,
1564                                        buf->text->cursor.par->GetLayout()).align;
1565
1566         switch (align) {
1567         case LYX_ALIGN_RIGHT:
1568                 fl_set_button(fd_form_paragraph->radio_align_right, 1);
1569                 break;
1570         case LYX_ALIGN_LEFT:
1571                 fl_set_button(fd_form_paragraph->radio_align_left, 1);
1572                 break;
1573         case LYX_ALIGN_CENTER:
1574                 fl_set_button(fd_form_paragraph->radio_align_center, 1);
1575                 break;
1576         default:
1577                 fl_set_button(fd_form_paragraph->radio_align_block, 1);
1578                 break;
1579         }
1580
1581         fl_set_button(fd_form_paragraph->check_lines_top,
1582                       buf->text->cursor.par->FirstPhysicalPar()->line_top);
1583         fl_set_button(fd_form_paragraph->check_lines_bottom,
1584                       buf->text->cursor.par->FirstPhysicalPar()->line_bottom);
1585         fl_set_button(fd_form_paragraph->check_pagebreaks_top,
1586                       buf->text->cursor.par->FirstPhysicalPar()->pagebreak_top);
1587         fl_set_button(fd_form_paragraph->check_pagebreaks_bottom,
1588                       buf->text->cursor.par->FirstPhysicalPar()->pagebreak_bottom);
1589         fl_set_button(fd_form_paragraph->check_noindent,
1590                       buf->text->cursor.par->FirstPhysicalPar()->noindent);
1591         fl_set_input (fd_form_paragraph->input_space_above, "");
1592
1593         switch (buf->text->cursor.par->FirstPhysicalPar()->added_space_top.kind()) {
1594         case VSpace::NONE:
1595                 fl_set_choice (fd_form_paragraph->choice_space_above,
1596                                1);
1597                 break;
1598         case VSpace::DEFSKIP:
1599                 fl_set_choice (fd_form_paragraph->choice_space_above,
1600                                2);
1601                 break;
1602         case VSpace::SMALLSKIP:
1603                 fl_set_choice (fd_form_paragraph->choice_space_above,
1604                                3);
1605                 break;
1606         case VSpace::MEDSKIP:
1607                 fl_set_choice (fd_form_paragraph->choice_space_above,
1608                                4);
1609                 break;
1610         case VSpace::BIGSKIP:
1611                 fl_set_choice (fd_form_paragraph->choice_space_above,
1612                                5);
1613                 break;
1614         case VSpace::VFILL:
1615                 fl_set_choice (fd_form_paragraph->choice_space_above,
1616                                6);
1617                 break;
1618         case VSpace::LENGTH:
1619                 fl_set_choice (fd_form_paragraph->choice_space_above,
1620                                7);
1621                 fl_set_input  (fd_form_paragraph->input_space_above,
1622                                buf->text->cursor.par->FirstPhysicalPar()->added_space_top.length().asString().c_str());
1623                 break;
1624         }
1625         fl_set_button (fd_form_paragraph->check_space_above,
1626                        buf->text->cursor.par->FirstPhysicalPar()->added_space_top.keep());
1627         fl_set_input (fd_form_paragraph->input_space_below, "");
1628         switch (buf->text->cursor.par->FirstPhysicalPar()->added_space_bottom.kind()) {
1629         case VSpace::NONE:
1630                 fl_set_choice (fd_form_paragraph->choice_space_below,
1631                                1);
1632                 break;
1633         case VSpace::DEFSKIP:
1634                 fl_set_choice (fd_form_paragraph->choice_space_below,
1635                                2);
1636                 break;
1637         case VSpace::SMALLSKIP:
1638                 fl_set_choice (fd_form_paragraph->choice_space_below,
1639                                3);
1640                 break;
1641         case VSpace::MEDSKIP:
1642                 fl_set_choice (fd_form_paragraph->choice_space_below,
1643                                4);
1644                 break;
1645         case VSpace::BIGSKIP:
1646                 fl_set_choice (fd_form_paragraph->choice_space_below,
1647                                5);
1648                 break;
1649         case VSpace::VFILL:
1650                 fl_set_choice (fd_form_paragraph->choice_space_below,
1651                                6);
1652                 break;
1653         case VSpace::LENGTH:
1654                 fl_set_choice (fd_form_paragraph->choice_space_below,
1655                                7);
1656                 fl_set_input  (fd_form_paragraph->input_space_below,
1657                                buf->text->cursor.par->FirstPhysicalPar()->added_space_bottom.length().asString().c_str());
1658                 break;
1659         }
1660         fl_set_button (fd_form_paragraph->check_space_below,
1661                        buf->text->cursor.par->FirstPhysicalPar()->added_space_bottom.keep());
1662
1663         fl_set_button(fd_form_paragraph->check_noindent,
1664                       buf->text->cursor.par->FirstPhysicalPar()->noindent);
1665
1666         if (current_view->buffer()->isReadonly()) {
1667                 DisableParagraphLayout();
1668         } else {
1669                 EnableParagraphLayout();
1670         }
1671         return true;
1672 }
1673
1674 void MenuLayoutParagraph()
1675 {
1676         if (UpdateLayoutParagraph()) {
1677                 if (fd_form_paragraph->form_paragraph->visible) {
1678                         fl_raise_form(fd_form_paragraph->form_paragraph);
1679                 } else {
1680                         fl_show_form(fd_form_paragraph->form_paragraph,
1681                                      FL_PLACE_MOUSE, FL_FULLBORDER,
1682                                      _("Paragraph Environment"));
1683                 }
1684         }
1685 }
1686
1687
1688 inline
1689 void DeactivateDocumentButtons ()
1690 {
1691         fl_deactivate_object (fd_form_document->button_ok);
1692         fl_deactivate_object (fd_form_document->button_apply);
1693         fl_set_object_lcol (fd_form_document->button_ok, FL_INACTIVE);
1694         fl_set_object_lcol (fd_form_document->button_apply, FL_INACTIVE);
1695 }
1696
1697
1698 inline
1699 void ActivateDocumentButtons ()
1700 {
1701         fl_activate_object (fd_form_document->button_ok);
1702         fl_activate_object (fd_form_document->button_apply);
1703         fl_set_object_lcol (fd_form_document->button_ok, FL_BLACK);
1704         fl_set_object_lcol (fd_form_document->button_apply, FL_BLACK);
1705 }
1706
1707 inline
1708 void DisableDocumentLayout ()
1709 {
1710         DeactivateDocumentButtons ();
1711         fl_deactivate_object (fd_form_document->group_radio_separation);
1712         fl_deactivate_object (fd_form_document->radio_indent);
1713         fl_deactivate_object (fd_form_document->radio_skip);
1714         fl_deactivate_object (fd_form_document->choice_class);
1715         fl_deactivate_object (fd_form_document->choice_pagestyle);
1716         fl_deactivate_object (fd_form_document->choice_fonts);
1717         fl_deactivate_object (fd_form_document->choice_fontsize);
1718         fl_deactivate_object (fd_form_document->input_float_placement);
1719         fl_deactivate_object (fd_form_document->choice_postscript_driver);
1720         fl_deactivate_object (fd_form_document->choice_inputenc);
1721         fl_deactivate_object (fd_form_document->group_radio_sides);
1722         fl_deactivate_object (fd_form_document->radio_sides_one);
1723         fl_deactivate_object (fd_form_document->radio_sides_two);
1724         fl_deactivate_object (fd_form_document->group_radio_columns);
1725         fl_deactivate_object (fd_form_document->radio_columns_one);
1726         fl_deactivate_object (fd_form_document->radio_columns_two);
1727         fl_deactivate_object (fd_form_document->input_extra);
1728         fl_deactivate_object (fd_form_document->choice_language);
1729         combo_language->deactivate();
1730         fl_deactivate_object (fd_form_document->input_default_skip);
1731         fl_deactivate_object (fd_form_document->choice_default_skip);
1732         fl_deactivate_object (fd_form_document->slider_secnumdepth);
1733         fl_deactivate_object (fd_form_document->slider_tocdepth);
1734         fl_deactivate_object (fd_form_document->choice_spacing);
1735         fl_deactivate_object (fd_form_document->input_spacing);
1736         fl_deactivate_object (fd_form_document->check_use_amsmath);
1737 }
1738
1739 inline
1740 void EnableDocumentLayout ()
1741 {
1742         ActivateDocumentButtons ();
1743         fl_activate_object (fd_form_document->group_radio_separation);
1744         fl_activate_object (fd_form_document->radio_indent);
1745         fl_activate_object (fd_form_document->radio_skip);
1746         fl_activate_object (fd_form_document->choice_class);
1747         fl_activate_object (fd_form_document->choice_pagestyle);
1748         fl_activate_object (fd_form_document->choice_fonts);
1749         fl_activate_object (fd_form_document->choice_fontsize);
1750         fl_activate_object (fd_form_document->input_float_placement);
1751         fl_activate_object (fd_form_document->choice_postscript_driver);
1752         fl_activate_object (fd_form_document->choice_inputenc);
1753         fl_activate_object (fd_form_document->group_radio_sides);
1754         fl_activate_object (fd_form_document->radio_sides_one);
1755         fl_activate_object (fd_form_document->radio_sides_two);
1756         fl_activate_object (fd_form_document->group_radio_columns);
1757         fl_activate_object (fd_form_document->radio_columns_one);
1758         fl_activate_object (fd_form_document->radio_columns_two);
1759         fl_activate_object (fd_form_document->input_extra);
1760         fl_activate_object (fd_form_document->choice_language);
1761         combo_language->activate();
1762         fl_activate_object (fd_form_document->input_default_skip);
1763         fl_activate_object (fd_form_document->choice_default_skip);
1764         fl_activate_object (fd_form_document->slider_secnumdepth);
1765         fl_activate_object (fd_form_document->slider_tocdepth);
1766         fl_activate_object (fd_form_document->choice_spacing);
1767         fl_activate_object (fd_form_document->input_spacing);
1768         fl_activate_object (fd_form_document->check_use_amsmath);
1769 }
1770
1771 bool UpdateLayoutDocument(BufferParams *params)
1772 {
1773         if (!current_view->getScreen() || !current_view->available()) {
1774                 if (fd_form_document->form_document->visible)
1775                         fl_hide_form(fd_form_document->form_document);
1776                 return false;
1777         }
1778
1779         if (params == 0)
1780                 params = &current_view->buffer()->params;
1781         LyXTextClass const & tclass = textclasslist.TextClass(params->textclass);
1782
1783         fl_set_choice_text(fd_form_document->choice_class,
1784                            textclasslist.DescOfClass(params->textclass).c_str());
1785         combo_language->select_text(params->language.c_str());
1786
1787         fl_set_choice_text(fd_form_document->choice_fonts,
1788                            params->fonts.c_str());
1789         fl_set_choice_text(fd_form_document->choice_inputenc,
1790                            params->inputenc.c_str());
1791         fl_set_choice_text(fd_form_document->choice_postscript_driver,
1792                            params->graphicsDriver.c_str());
1793
1794         // ale970405+lasgoutt970513
1795         fl_clear_choice(fd_form_document->choice_fontsize);
1796         fl_addto_choice(fd_form_document->choice_fontsize, "default");
1797         fl_addto_choice(fd_form_document->choice_fontsize,
1798                         tclass.opt_fontsize().c_str());
1799         fl_set_choice(fd_form_document->choice_fontsize,
1800                       tokenPos(tclass.opt_fontsize(), '|', params->fontsize) + 2);
1801
1802         // ale970405+lasgoutt970513
1803         fl_clear_choice(fd_form_document->choice_pagestyle);
1804         fl_addto_choice(fd_form_document->choice_pagestyle, "default");
1805         fl_addto_choice(fd_form_document->choice_pagestyle,
1806                         tclass.opt_pagestyle().c_str());
1807
1808         fl_set_choice(fd_form_document->choice_pagestyle,
1809                       tokenPos(tclass.opt_pagestyle(), '|', params->pagestyle) + 2);
1810
1811         fl_set_button(fd_form_document->radio_indent, 0);
1812         fl_set_button(fd_form_document->radio_skip, 0);
1813
1814
1815         fl_set_button(fd_form_document->check_use_amsmath, params->use_amsmath);
1816
1817         if (params->paragraph_separation == BufferParams::PARSEP_INDENT)
1818                 fl_set_button(fd_form_document->radio_indent, 1);
1819         else
1820                 fl_set_button(fd_form_document->radio_skip, 1);
1821
1822         switch (params->getDefSkip().kind()) {
1823         case VSpace::SMALLSKIP:
1824                 fl_set_choice (fd_form_document->choice_default_skip, 1);
1825                 break;
1826         case VSpace::MEDSKIP:
1827                 fl_set_choice (fd_form_document->choice_default_skip, 2);
1828                 break;
1829         case VSpace::BIGSKIP:
1830                 fl_set_choice (fd_form_document->choice_default_skip, 3);
1831                 break;
1832         case VSpace::LENGTH:
1833                 fl_set_choice (fd_form_document->choice_default_skip, 4);
1834                 fl_set_input (fd_form_document->input_default_skip,
1835                               params->getDefSkip().asLyXCommand().c_str());
1836                 break;
1837         default:
1838                 fl_set_choice (fd_form_document->choice_default_skip, 2);
1839                 break;
1840         }
1841
1842         fl_set_button(fd_form_document->radio_sides_one, 0);
1843         fl_set_button(fd_form_document->radio_sides_two, 0);
1844
1845         if (params->sides == 2)
1846                 fl_set_button(fd_form_document->radio_sides_two, 1);
1847         else
1848                 fl_set_button(fd_form_document->radio_sides_one, 1);
1849
1850         fl_set_button(fd_form_document->radio_columns_one, 0);
1851         fl_set_button(fd_form_document->radio_columns_two, 0);
1852
1853         if (params->columns == 2)
1854                 fl_set_button(fd_form_document->radio_columns_two, 1);
1855         else
1856                 fl_set_button(fd_form_document->radio_columns_one, 1);
1857
1858         fl_set_input(fd_form_document->input_spacing, "");
1859         switch (params->spacing.getSpace()) {
1860         case Spacing::Single:
1861                 {
1862                         // \singlespacing
1863                         fl_set_choice(fd_form_document->choice_spacing, 1);
1864                         break;
1865                 }
1866         case Spacing::Onehalf:
1867                 {
1868                         // \onehalfspacing
1869                         fl_set_choice(fd_form_document->choice_spacing, 2);
1870                         break;
1871                 }
1872         case Spacing::Double:
1873                 {
1874                         // \ doublespacing
1875                         fl_set_choice(fd_form_document->choice_spacing, 3);
1876                         break;
1877                 }
1878         case Spacing::Other:
1879                 {
1880                         fl_set_choice(fd_form_document->choice_spacing, 4);
1881                         char sval[20];
1882                         sprintf(sval, "%g", params->spacing.getValue());
1883                         fl_set_input(fd_form_document->input_spacing, sval);
1884                         break;
1885                 }
1886         }
1887
1888
1889         fl_set_counter_value(fd_form_document->slider_secnumdepth,
1890                              params->secnumdepth);
1891         fl_set_counter_value(fd_form_document->slider_tocdepth,
1892                              params->tocdepth);
1893         if (!params->float_placement.empty()) { // buffer local (Lgb)
1894                 fl_set_input(fd_form_document->input_float_placement,
1895                              params->float_placement.c_str());
1896         } else {
1897                 fl_set_input(fd_form_document->input_float_placement, "");
1898         }
1899         if (!params->options.empty())
1900                 fl_set_input(fd_form_document->input_extra,
1901                              params->options.c_str());
1902         else
1903                 fl_set_input(fd_form_document->input_extra, "");
1904
1905         if (current_view->buffer()->isSGML()) {
1906                 // bullets not used in SGML derived documents
1907                 fl_deactivate_object(fd_form_document->button_bullets);
1908                 fl_set_object_lcol(fd_form_document->button_bullets,
1909                                    FL_INACTIVE);
1910         } else {
1911                 fl_activate_object(fd_form_document->button_bullets);
1912                 fl_set_object_lcol(fd_form_document->button_bullets,
1913                                    FL_BLACK);
1914         }
1915
1916         if (current_view->buffer()->isReadonly()) {
1917                 DisableDocumentLayout();
1918         } else {
1919                 EnableDocumentLayout();
1920         }
1921
1922         return true;
1923 }
1924
1925 void MenuLayoutDocument()
1926 {
1927         if (UpdateLayoutDocument()) {
1928                 if (fd_form_document->form_document->visible) {
1929                         fl_raise_form(fd_form_document->form_document);
1930                 } else {
1931                         fl_show_form(fd_form_document->form_document,
1932                                      FL_PLACE_MOUSE, FL_FULLBORDER,
1933                                      _("Document Layout"));
1934                 }
1935         }
1936 }
1937
1938
1939 bool UpdateLayoutQuotes()
1940 {
1941         bool update = true;
1942         if (!current_view->getScreen()
1943             || !current_view->available()
1944             || current_view->buffer()->isReadonly())
1945                 update = false;
1946
1947         if (update) {
1948                 fl_set_choice(fd_form_quotes->choice_quotes_language,
1949                       current_view->buffer()->params.quotes_language + 1);
1950                 fl_set_button(fd_form_quotes->radio_single, 0);
1951                 fl_set_button(fd_form_quotes->radio_double, 0);
1952
1953                 if (current_view->buffer()->params.quotes_times == InsetQuotes::SingleQ)
1954                         fl_set_button(fd_form_quotes->radio_single, 1);
1955                 else
1956                         fl_set_button(fd_form_quotes->radio_double, 1);
1957         } else if (fd_form_quotes->form_quotes->visible) {
1958                 fl_hide_form(fd_form_quotes->form_quotes);
1959         }
1960         return update;
1961 }
1962
1963 void MenuLayoutQuotes()
1964 {
1965         if (UpdateLayoutQuotes()) {
1966                 if (fd_form_quotes->form_quotes->visible) {
1967                         fl_raise_form(fd_form_quotes->form_quotes);
1968                 } else {
1969                         fl_show_form(fd_form_quotes->form_quotes,
1970                                      FL_PLACE_MOUSE, FL_FULLBORDER,
1971                                      _("Quotes"));
1972                 }
1973         }
1974 }
1975
1976
1977 bool UpdateLayoutPreamble()
1978 {
1979         bool update = true;
1980         if (!current_view->getScreen() || ! current_view->available())
1981             update = false;
1982
1983         if (update) {
1984                 fl_set_input(fd_form_preamble->input_preamble,
1985                      current_view->buffer()->params.preamble.c_str());
1986
1987                 if (current_view->buffer()->isReadonly()) {
1988                   fl_deactivate_object(fd_form_preamble->input_preamble);
1989                   fl_deactivate_object(fd_form_preamble->button_ok);
1990                   fl_deactivate_object(fd_form_preamble->button_apply);
1991                   fl_set_object_lcol(fd_form_preamble->button_ok, FL_INACTIVE);
1992                   fl_set_object_lcol(fd_form_preamble->button_apply, FL_INACTIVE);
1993                 }
1994                 else {
1995                   fl_activate_object(fd_form_preamble->input_preamble);
1996                   fl_activate_object(fd_form_preamble->button_ok);
1997                   fl_activate_object(fd_form_preamble->button_apply);
1998                   fl_set_object_lcol(fd_form_preamble->button_ok, FL_BLACK);
1999                   fl_set_object_lcol(fd_form_preamble->button_apply, FL_BLACK);
2000                 }
2001         } else if (fd_form_preamble->form_preamble->visible) {
2002                 fl_hide_form(fd_form_preamble->form_preamble);
2003         }
2004         return update;
2005 }
2006
2007 void MenuLayoutPreamble()
2008 {
2009         static int ow = -1, oh;
2010
2011         if (UpdateLayoutPreamble()) {
2012                 if (fd_form_preamble->form_preamble->visible) {
2013                         fl_raise_form(fd_form_preamble->form_preamble);
2014                 } else {
2015                         fl_show_form(fd_form_preamble->form_preamble,
2016                                      FL_PLACE_MOUSE | FL_FREE_SIZE,
2017                                      FL_FULLBORDER,
2018                                      _("LaTeX Preamble"));
2019                         if (ow < 0) {
2020                                 ow = fd_form_preamble->form_preamble->w;
2021                                 oh = fd_form_preamble->form_preamble->h;
2022                         }
2023                         fl_set_form_minsize(fd_form_preamble->form_preamble,
2024                                             ow, oh);
2025                 }
2026         }
2027 }
2028
2029 void MenuLayoutSave()
2030 {
2031         if (!current_view->getScreen() || ! current_view->available())
2032             return;
2033
2034         if (AskQuestion(_("Do you want to save the current settings"),
2035                         _("for Character, Document, Paper and Quotes"),
2036                         _("as default for new documents?")))
2037                 current_view->buffer()->saveParamsAsDefaults();
2038 }
2039
2040
2041 void NoteCB()
2042 {
2043         InsetInfo * new_inset = new InsetInfo();
2044         current_view->buffer()->insertInset(new_inset);
2045         new_inset->Edit(0, 0);
2046 }
2047
2048
2049 void OpenStuff()
2050 {
2051         if (current_view->available()) {
2052                 minibuffer->Set(_("Open/Close..."));
2053                 current_view->getScreen()->HideCursor();
2054                 BeforeChange();
2055                 current_view->buffer()->update(-2);
2056                 current_view->buffer()->text->OpenStuff();
2057                 current_view->buffer()->update(0);
2058         }
2059 }
2060
2061 void ToggleFloat()
2062 {
2063         if (current_view->available()) {
2064                 minibuffer->Set(_("Open/Close..."));
2065                 current_view->getScreen()->HideCursor();
2066                 BeforeChange();
2067                 current_view->buffer()->update(-2);
2068                 current_view->buffer()->text->ToggleFootnote();
2069                 current_view->buffer()->update(0);
2070         }
2071 }
2072
2073
2074 void MenuUndo()
2075 {
2076 /*      if (current_view->buffer()->the_locking_inset) {
2077                 minibuffer->Set(_("Undo not yet supported in math mode"));
2078                 return;
2079         }*/
2080
2081         if (current_view->available()) {
2082                 minibuffer->Set(_("Undo"));
2083                 current_view->getScreen()->HideCursor();
2084                 BeforeChange();
2085                 current_view->buffer()->update(-2);
2086                 if (!current_view->buffer()->text->TextUndo())
2087                         minibuffer->Set(_("No further undo information"));
2088                 else
2089                         current_view->buffer()->update(-1);
2090         }
2091 }
2092
2093
2094 void MenuRedo()
2095 {
2096         if (current_view->buffer()->the_locking_inset) {
2097                 minibuffer->Set(_("Redo not yet supported in math mode"));
2098                 return;
2099         }
2100
2101         if (current_view->available()) {
2102                 minibuffer->Set(_("Redo"));
2103                 current_view->getScreen()->HideCursor();
2104                 BeforeChange();
2105                 current_view->buffer()->update(-2);
2106                 if (!current_view->buffer()->text->TextRedo())
2107                         minibuffer->Set(_("No further redo information"));
2108                 else
2109                         current_view->buffer()->update(-1);
2110         }
2111 }
2112
2113
2114 void HyphenationPoint()
2115 {
2116         if (current_view->available())  {
2117                 current_view->getScreen()->HideCursor();
2118                 current_view->buffer()->update(-2);
2119                 InsetSpecialChar * new_inset =
2120                         new InsetSpecialChar(InsetSpecialChar::HYPHENATION);
2121                 current_view->buffer()->insertInset(new_inset);
2122         }
2123 }
2124
2125
2126 void Ldots()
2127 {
2128         if (current_view->available())  {
2129                 current_view->getScreen()->HideCursor();
2130                 current_view->buffer()->update(-2);
2131                 InsetSpecialChar * new_inset =
2132                         new InsetSpecialChar(InsetSpecialChar::LDOTS);
2133                 current_view->buffer()->insertInset(new_inset);
2134         }
2135 }
2136
2137
2138 void EndOfSentenceDot()
2139 {
2140         if (current_view->available())  {
2141                 current_view->getScreen()->HideCursor();
2142                 current_view->buffer()->update(-2);
2143                 InsetSpecialChar * new_inset =
2144                         new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE);
2145                 current_view->buffer()->insertInset(new_inset);
2146         }
2147 }
2148
2149
2150 void MenuSeparator()
2151 {
2152         if (current_view->available())  {
2153                 current_view->getScreen()->HideCursor();
2154                 current_view->buffer()->update(-2);
2155                 InsetSpecialChar * new_inset =
2156                         new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR);
2157                 current_view->buffer()->insertInset(new_inset);
2158         }
2159 }
2160
2161
2162 void Newline()
2163 {
2164         if (current_view->available())  {
2165                 current_view->getScreen()->HideCursor();
2166                 current_view->buffer()->update(-2);
2167                 current_view->buffer()->text->InsertChar(LyXParagraph::META_NEWLINE);
2168                 current_view->buffer()->update(-1);
2169         }
2170 }
2171
2172
2173 void ProtectedBlank()
2174 {
2175         if (current_view->available())  {
2176                 current_view->getScreen()->HideCursor();
2177                 current_view->buffer()->update(-2);
2178                 current_view->buffer()->text->InsertChar(LyXParagraph::META_PROTECTED_SEPARATOR);
2179                 current_view->buffer()->update(-1);
2180         }
2181 }
2182
2183
2184 void HFill()
2185 {
2186         if (current_view->available())  {
2187                 current_view->getScreen()->HideCursor();
2188                 current_view->buffer()->update(-2);
2189                 current_view->buffer()->text->InsertChar(LyXParagraph::META_HFILL);
2190                 current_view->buffer()->update(-1);
2191         }
2192 }
2193
2194
2195 /* -------> These CB's use ToggleFree() as the (one and only?) font-changer.
2196                         They also show the current font state. */
2197
2198 static
2199 void ToggleAndShow(LyXFont const &);
2200
2201
2202 void FontSizeCB(string const & size)
2203 {
2204         LyXFont font(LyXFont::ALL_IGNORE);
2205         font.setGUISize(size);
2206         ToggleAndShow(font);
2207 }
2208
2209
2210 void EmphCB()
2211 {
2212         LyXFont font(LyXFont::ALL_IGNORE);
2213         font.setEmph(LyXFont::TOGGLE);
2214         ToggleAndShow(font);
2215 }
2216
2217
2218 void NounCB()
2219 {
2220         LyXFont font(LyXFont::ALL_IGNORE);
2221         font.setNoun(LyXFont::TOGGLE);
2222         ToggleAndShow(font);
2223 }
2224
2225
2226 void BoldCB()
2227 {
2228         LyXFont font(LyXFont::ALL_IGNORE);
2229         font.setSeries(LyXFont::BOLD_SERIES);
2230         ToggleAndShow(font);
2231 }
2232
2233
2234 void UnderlineCB()
2235 {
2236         LyXFont font(LyXFont::ALL_IGNORE);
2237         font.setUnderbar(LyXFont::TOGGLE);
2238         ToggleAndShow(font);
2239 }
2240
2241
2242 void CodeCB()
2243 {
2244         LyXFont font(LyXFont::ALL_IGNORE);
2245         font.setFamily(LyXFont::TYPEWRITER_FAMILY); // no good
2246         ToggleAndShow(font);
2247 }
2248
2249
2250 void SansCB()
2251 {
2252         LyXFont font(LyXFont::ALL_IGNORE);
2253         font.setFamily(LyXFont::SANS_FAMILY);
2254         ToggleAndShow(font);
2255 }
2256
2257
2258 void RomanCB()
2259 {
2260         LyXFont font(LyXFont::ALL_IGNORE);
2261         font.setFamily(LyXFont::ROMAN_FAMILY);
2262         ToggleAndShow(font);
2263 }
2264
2265
2266 void TexCB()
2267 {
2268         LyXFont font(LyXFont::ALL_IGNORE);
2269         font.setLatex (LyXFont::TOGGLE);
2270         ToggleAndShow(font);
2271 }
2272
2273
2274 void StyleResetCB()
2275 {
2276         LyXFont font(LyXFont::ALL_INHERIT);
2277         ToggleAndShow(font);
2278 }
2279
2280
2281 /* -------> Returns the current font and depth by printing a message. In the
2282  * future perhaps we could try to implement a callback to the button-bar.
2283  * That is, `light' the bold button when the font is currently bold, etc.
2284  */
2285 string CurrentState()
2286 {
2287         string state;
2288         if (current_view->available()) {
2289                 // I think we should only show changes from the default
2290                 // font. (Asger)
2291                 Buffer * buffer = current_view->buffer();
2292                 LyXFont font = buffer->text->real_current_font;
2293                 LyXFont defaultfont = textclasslist.TextClass(buffer->
2294                                                          params.textclass).defaultfont();
2295                 font.reduce(defaultfont);
2296                 state = _("Font: ") + font.stateText();
2297
2298                 int depth = buffer->text->GetDepth();
2299                 if (depth>0)
2300                         state += string(_(", Depth: ")) + tostr(depth);
2301         }
2302         return state;
2303 }
2304
2305
2306 /* -------> Does the actual toggle job of the XxxCB() calls above.
2307  * Also shows the current font state.
2308  */
2309 static
2310 void ToggleAndShow(LyXFont const & font)
2311 {
2312         if (current_view->available()) {
2313                 current_view->getScreen()->HideCursor();
2314                 current_view->buffer()->update(-2);
2315                 current_view->buffer()->text->ToggleFree(font, toggleall);
2316                 current_view->buffer()->update(1);
2317         }
2318         // removed since it overrides the ToggleFree Message about the style
2319         // Since Styles are more "High Level" than raw fonts I think the user
2320         // prefers it like this               Matthias
2321         // FontStateShowCB( 0, 0 );
2322 }
2323
2324
2325 extern "C" void MarginCB(FL_OBJECT *, long)
2326 {
2327         if (current_view->available()) {
2328                 minibuffer->Set(_("Inserting margin note..."));
2329                 current_view->getScreen()->HideCursor();
2330                 current_view->buffer()->update(-2);
2331                 current_view->buffer()->text->InsertFootnoteEnvironment(LyXParagraph::MARGIN);
2332                 current_view->buffer()->update(1);
2333         }
2334 }
2335
2336
2337 extern "C" void FigureCB(FL_OBJECT *, long)
2338 {
2339         if (fd_form_figure->form_figure->visible) {
2340                 fl_raise_form(fd_form_figure->form_figure);
2341         } else {
2342                 fl_show_form(fd_form_figure->form_figure,
2343                              FL_PLACE_MOUSE, FL_FULLBORDER,
2344                              _("Insert Figure"));
2345         }
2346 }
2347
2348
2349 extern "C" void TableCB(FL_OBJECT *, long)
2350 {
2351         if (fd_form_table->form_table->visible) {
2352                 fl_raise_form(fd_form_table->form_table);
2353         } else {
2354                 fl_show_form(fd_form_table->form_table,
2355                              FL_PLACE_MOUSE, FL_FULLBORDER,
2356                              _("Insert Table"));
2357         }
2358 }
2359
2360
2361 void CopyEnvironmentCB()
2362 {
2363         if (current_view->available()) {
2364                 current_view->buffer()->text->copyEnvironmentType();
2365                 /* clear the selection, even if mark_set */
2366                 current_view->getScreen()->ToggleSelection();
2367                 current_view->buffer()->text->ClearSelection();
2368                 current_view->buffer()->update(-2);
2369                 minibuffer->Set(_("Paragraph environment type copied"));
2370         }
2371 }
2372
2373
2374 void PasteEnvironmentCB()
2375 {
2376         if (current_view->available()) {
2377                 current_view->buffer()->text->pasteEnvironmentType();
2378                 minibuffer->Set(_("Paragraph environment type set"));
2379                 current_view->buffer()->update(1);
2380         }
2381 }
2382
2383
2384 void CopyCB()
2385 {
2386         if (current_view->available()) {
2387                 current_view->buffer()->text->CopySelection();
2388                 /* clear the selection, even if mark_set */
2389                 current_view->getScreen()->ToggleSelection();
2390                 current_view->buffer()->text->ClearSelection();
2391                 current_view->buffer()->update(-2);
2392                 minibuffer->Set(_("Copy"));
2393         }
2394 }
2395
2396
2397 void CutCB()
2398 {
2399         if (current_view->available()) {
2400                 current_view->getScreen()->HideCursor();
2401                 current_view->buffer()->update(-2);
2402                 current_view->buffer()->text->CutSelection();
2403                 current_view->buffer()->update(1);
2404                 minibuffer->Set(_("Cut"));
2405         }
2406 }
2407
2408
2409 void PasteCB()
2410 {
2411         if (!current_view->available()) return;
2412
2413         minibuffer->Set(_("Paste"));
2414         current_view->getScreen()->HideCursor();
2415         /* clear the selection */
2416         current_view->getScreen()->ToggleSelection();
2417         current_view->buffer()->text->ClearSelection();
2418         current_view->buffer()->update(-2);
2419
2420         /* paste */
2421         current_view->buffer()->text->PasteSelection();
2422         current_view->buffer()->update(1);
2423
2424         /* clear the selection */
2425         current_view->getScreen()->ToggleSelection();
2426         current_view->buffer()->text->ClearSelection();
2427         current_view->buffer()->update(-2);
2428 }
2429
2430
2431 extern "C" void MeltCB(FL_OBJECT *, long)
2432 {
2433         if (!current_view->available()) return;
2434
2435         minibuffer->Set(_("Melt"));
2436         current_view->getScreen()->HideCursor();
2437         BeforeChange();
2438         current_view->buffer()->update(-2);
2439         current_view->buffer()->text->MeltFootnoteEnvironment();
2440         current_view->buffer()->update(1);
2441 }
2442
2443
2444 // Change environment depth.
2445 // if decInc == 0, depth change taking mouse button number into account
2446 // if decInc == 1, increment depth
2447 // if decInc == -1, decrement depth
2448 extern "C" void DepthCB(FL_OBJECT *ob, long decInc)
2449 {
2450         int button = 1;
2451
2452         /* When decInc != 0, fake a mouse button. This allows us to
2453            implement depth-plus and depth-min commands. RVDK_PATCH_5. */
2454         /* check out wether ob is defined, too (Matthias) */
2455         if ( decInc < 0 )
2456                 button = 0;
2457         else if (!decInc && ob) {
2458                 button = fl_get_button_numb(ob);
2459         }
2460
2461         if (current_view->available()) {
2462                 current_view->getScreen()->HideCursor();
2463                 current_view->buffer()->update(-2);
2464                 if (button == 1)
2465                         current_view->buffer()->text->IncDepth();
2466                 else
2467                         current_view->buffer()->text->DecDepth();
2468                 current_view->buffer()->update(1);
2469                 minibuffer->Set(_("Changed environment depth"
2470                                   " (in possible range, maybe not)"));
2471         }
2472 }
2473
2474
2475 // This is both GUI and LyXFont dependent. Don't know where to put it. (Asger)
2476 // Well, it's mostly GUI dependent, so I guess it will stay here. (Asger)
2477 LyXFont UserFreeFont()
2478 {
2479         LyXFont font(LyXFont::ALL_IGNORE);
2480         int pos;
2481
2482         pos = fl_get_choice(fd_form_character->choice_family);
2483         switch(pos) {
2484         case 1: font.setFamily(LyXFont::IGNORE_FAMILY); break;
2485         case 2: font.setFamily(LyXFont::ROMAN_FAMILY); break;
2486         case 3: font.setFamily(LyXFont::SANS_FAMILY); break;
2487         case 4: font.setFamily(LyXFont::TYPEWRITER_FAMILY); break;
2488         case 5: font.setFamily(LyXFont::INHERIT_FAMILY); break;
2489         }
2490
2491         pos = fl_get_choice(fd_form_character->choice_series);
2492         switch(pos) {
2493         case 1: font.setSeries(LyXFont::IGNORE_SERIES); break;
2494         case 2: font.setSeries(LyXFont::MEDIUM_SERIES); break;
2495         case 3: font.setSeries(LyXFont::BOLD_SERIES); break;
2496         case 4: font.setSeries(LyXFont::INHERIT_SERIES); break;
2497         }
2498
2499         pos = fl_get_choice(fd_form_character->choice_shape);
2500         switch(pos) {
2501         case 1: font.setShape(LyXFont::IGNORE_SHAPE); break;
2502         case 2: font.setShape(LyXFont::UP_SHAPE); break;
2503         case 3: font.setShape(LyXFont::ITALIC_SHAPE); break;
2504         case 4: font.setShape(LyXFont::SLANTED_SHAPE); break;
2505         case 5: font.setShape(LyXFont::SMALLCAPS_SHAPE); break;
2506         case 6: font.setShape(LyXFont::INHERIT_SHAPE); break;
2507         }
2508
2509         pos = fl_get_choice(fd_form_character->choice_size);
2510         switch(pos) {
2511         case 1: font.setSize(LyXFont::IGNORE_SIZE); break;
2512         case 2: font.setSize(LyXFont::SIZE_TINY); break;
2513         case 3: font.setSize(LyXFont::SIZE_SCRIPT); break;
2514         case 4: font.setSize(LyXFont::SIZE_FOOTNOTE); break;
2515         case 5: font.setSize(LyXFont::SIZE_SMALL); break;
2516         case 6: font.setSize(LyXFont::SIZE_NORMAL); break;
2517         case 7: font.setSize(LyXFont::SIZE_LARGE); break;
2518         case 8: font.setSize(LyXFont::SIZE_LARGER); break;
2519         case 9: font.setSize(LyXFont::SIZE_LARGEST); break;
2520         case 10: font.setSize(LyXFont::SIZE_HUGE); break;
2521         case 11: font.setSize(LyXFont::SIZE_HUGER); break;
2522         case 12: font.setSize(LyXFont::INCREASE_SIZE); break;
2523         case 13: font.setSize(LyXFont::DECREASE_SIZE); break;
2524         case 14: font.setSize(LyXFont::INHERIT_SIZE); break;
2525         }
2526
2527         pos = fl_get_choice(fd_form_character->choice_bar);
2528         switch(pos) {
2529         case 1: font.setEmph(LyXFont::IGNORE);
2530                 font.setUnderbar(LyXFont::IGNORE);
2531                 font.setNoun(LyXFont::IGNORE);
2532                 font.setLatex(LyXFont::IGNORE);
2533                 break;
2534         case 2: font.setEmph(LyXFont::TOGGLE); break;
2535         case 3: font.setUnderbar(LyXFont::TOGGLE); break;
2536         case 4: font.setNoun(LyXFont::TOGGLE); break;
2537         case 5: font.setLatex(LyXFont::TOGGLE); break;
2538         case 6: font.setEmph(LyXFont::INHERIT);
2539                 font.setUnderbar(LyXFont::INHERIT);
2540                 font.setNoun(LyXFont::INHERIT);
2541                 font.setLatex(LyXFont::INHERIT);
2542                 break;
2543         }
2544
2545         pos = fl_get_choice(fd_form_character->choice_color);
2546         switch(pos) {
2547         case 1: font.setColor(LyXFont::IGNORE_COLOR); break;
2548         case 2: font.setColor(LyXFont::NONE); break;
2549         case 3: font.setColor(LyXFont::BLACK); break;
2550         case 4: font.setColor(LyXFont::WHITE); break;
2551         case 5: font.setColor(LyXFont::RED); break;
2552         case 6: font.setColor(LyXFont::GREEN); break;
2553         case 7: font.setColor(LyXFont::BLUE); break;
2554         case 8: font.setColor(LyXFont::CYAN); break;
2555         case 9: font.setColor(LyXFont::MAGENTA); break;
2556         case 10: font.setColor(LyXFont::YELLOW); break;
2557         case 11: font.setColor(LyXFont::INHERIT_COLOR); break;
2558         }
2559
2560         return font;
2561 }
2562
2563
2564 void FreeCB()
2565 {
2566         ToggleAndShow(UserFreeFont());
2567 }
2568
2569
2570 /* callbacks for form form_title */
2571 extern "C" void TimerCB(FL_OBJECT *, long)
2572 {
2573         // only if the form still exists
2574         if (fd_form_title->form_title != 0) {
2575                 if (fd_form_title->form_title->visible) {
2576                         fl_hide_form(fd_form_title->form_title);
2577                 }
2578                 fl_free_form(fd_form_title->form_title);
2579                 fd_form_title->form_title = 0;
2580         }
2581 }
2582
2583
2584 /* callbacks for form form_paragraph */
2585
2586 extern "C" void ParagraphVSpaceCB(FL_OBJECT* obj, long )
2587 {
2588         // "Synchronize" the choices and input fields, making it
2589         // impossible to commit senseless data.
2590
2591         const FD_form_paragraph* fp = fd_form_paragraph;
2592
2593         if (obj == fp->choice_space_above) {
2594                 if (fl_get_choice (fp->choice_space_above) != 7) {
2595                         fl_set_input (fp->input_space_above, "");
2596                         ActivateParagraphButtons();
2597                 }
2598         } else if (obj == fp->choice_space_below) {
2599                 if (fl_get_choice (fp->choice_space_below) != 7) {
2600                         fl_set_input (fp->input_space_below, "");
2601                         ActivateParagraphButtons();
2602                 }
2603         } else if (obj == fp->input_space_above) {
2604                 string input = fl_get_input (fp->input_space_above);
2605
2606                 if (input.empty()) {
2607                         fl_set_choice (fp->choice_space_above, 1);
2608                         ActivateParagraphButtons();
2609                 }
2610                 else if (isValidGlueLength (input)) {
2611                         fl_set_choice (fp->choice_space_above, 7);
2612                         ActivateParagraphButtons();
2613                 }
2614                 else {
2615                         fl_set_choice (fp->choice_space_above, 7);
2616                         DeactivateParagraphButtons();
2617                 }
2618         } else if (obj == fp->input_space_below) {
2619                 string input = fl_get_input (fp->input_space_below);
2620
2621                 if (input.empty()) {
2622                         fl_set_choice (fp->choice_space_below, 1);
2623                         ActivateParagraphButtons();
2624                 }
2625                 else if (isValidGlueLength (input)) {
2626                         fl_set_choice (fp->choice_space_below, 7);
2627                         ActivateParagraphButtons();
2628                 }
2629                 else {
2630                         fl_set_choice (fp->choice_space_below, 7);
2631                         DeactivateParagraphButtons();
2632                 }
2633         }
2634 }
2635
2636
2637 extern "C" void ParagraphApplyCB(FL_OBJECT *, long)
2638 {
2639         if (!current_view->available())
2640                 return;
2641
2642         VSpace space_top, space_bottom;
2643         LyXAlignment align;
2644         string labelwidthstring;
2645         bool noindent;
2646
2647         // If a vspace kind is "Length" but there's no text in
2648         // the input field, reset the kind to "None".
2649         if (fl_get_choice (fd_form_paragraph->choice_space_above) == 7
2650             && !*(fl_get_input (fd_form_paragraph->input_space_above))) {
2651                 fl_set_choice (fd_form_paragraph->choice_space_above, 1);
2652         }
2653         if (fl_get_choice (fd_form_paragraph->choice_space_below) == 7
2654             && !*(fl_get_input (fd_form_paragraph->input_space_below))) {
2655                 fl_set_choice (fd_form_paragraph->choice_space_below, 1);
2656         }
2657
2658         bool line_top = fl_get_button(fd_form_paragraph->check_lines_top);
2659         bool line_bottom = fl_get_button(fd_form_paragraph->check_lines_bottom);
2660         bool pagebreak_top = fl_get_button(fd_form_paragraph->check_pagebreaks_top);
2661         bool pagebreak_bottom = fl_get_button(fd_form_paragraph->check_pagebreaks_bottom);
2662         switch (fl_get_choice (fd_form_paragraph->choice_space_above)) {
2663         case 1: space_top = VSpace(VSpace::NONE); break;
2664         case 2: space_top = VSpace(VSpace::DEFSKIP); break;
2665         case 3: space_top = VSpace(VSpace::SMALLSKIP); break;
2666         case 4: space_top = VSpace(VSpace::MEDSKIP); break;
2667         case 5: space_top = VSpace(VSpace::BIGSKIP); break;
2668         case 6: space_top = VSpace(VSpace::VFILL); break;
2669         case 7: space_top = VSpace(LyXGlueLength (fl_get_input (fd_form_paragraph->input_space_above))); break;
2670         }
2671         if (fl_get_button (fd_form_paragraph->check_space_above))
2672           space_top.setKeep (true);
2673         switch (fl_get_choice (fd_form_paragraph->choice_space_below)) {
2674         case 1: space_bottom = VSpace(VSpace::NONE); break;
2675         case 2: space_bottom = VSpace(VSpace::DEFSKIP); break;
2676         case 3: space_bottom = VSpace(VSpace::SMALLSKIP); break;
2677         case 4: space_bottom = VSpace(VSpace::MEDSKIP); break;
2678         case 5: space_bottom = VSpace(VSpace::BIGSKIP); break;
2679         case 6: space_bottom = VSpace(VSpace::VFILL); break;
2680         case 7: space_bottom = VSpace(LyXGlueLength (fl_get_input (fd_form_paragraph->input_space_below))); break;
2681         }
2682         if (fl_get_button (fd_form_paragraph->check_space_below))
2683           space_bottom.setKeep (true);
2684
2685         if (fl_get_button(fd_form_paragraph->radio_align_left))
2686                 align = LYX_ALIGN_LEFT;
2687         else if (fl_get_button(fd_form_paragraph->radio_align_right))
2688                 align = LYX_ALIGN_RIGHT;
2689         else if (fl_get_button(fd_form_paragraph->radio_align_center))
2690                 align = LYX_ALIGN_CENTER;
2691         else
2692                 align = LYX_ALIGN_BLOCK;
2693
2694         labelwidthstring = fl_get_input(fd_form_paragraph->input_labelwidth);
2695         noindent = fl_get_button(fd_form_paragraph->check_noindent);
2696
2697         current_view->buffer()->text->SetParagraph(line_top,
2698                                                           line_bottom,
2699                                                           pagebreak_top,
2700                                                           pagebreak_bottom,
2701                                                           space_top,
2702                                                           space_bottom,
2703                                                           align,
2704                                                           labelwidthstring,
2705                                                           noindent);
2706         current_view->buffer()->update(1);
2707         minibuffer->Set(_("Paragraph layout set"));
2708 }
2709
2710
2711 extern "C" void ParagraphCancelCB(FL_OBJECT *, long)
2712 {
2713         fl_hide_form(fd_form_paragraph->form_paragraph);
2714 }
2715
2716
2717 extern "C" void ParagraphOKCB(FL_OBJECT *ob, long data)
2718 {
2719         ParagraphApplyCB(ob, data);
2720         ParagraphCancelCB(ob, data);
2721 }
2722
2723
2724 /* callbacks for form form_character */
2725
2726 extern "C" void CharacterApplyCB(FL_OBJECT *, long)
2727 {
2728         // we set toggleall locally here, since it should be true for
2729         // all other uses of ToggleAndShow() (JMarc)
2730         toggleall = fl_get_button(fd_form_character->check_toggle_all);
2731         ToggleAndShow( UserFreeFont());
2732         toggleall = true;
2733 }
2734
2735
2736 extern "C" void CharacterCloseCB(FL_OBJECT *, long)
2737 {
2738         fl_hide_form(fd_form_character->form_character);
2739 }
2740
2741
2742 extern "C" void CharacterOKCB(FL_OBJECT *ob, long data)
2743 {
2744         CharacterApplyCB(ob, data);
2745         CharacterCloseCB(ob, data);
2746 }
2747
2748
2749 /* callbacks for form form_document */
2750
2751 void UpdateDocumentButtons(BufferParams const &params)
2752 {
2753         fl_set_choice(fd_form_document->choice_pagestyle, 1);
2754
2755         if (params.sides == 2)
2756                 fl_set_button(fd_form_document->radio_sides_two, 1);
2757         else
2758                 fl_set_button(fd_form_document->radio_sides_one, 1);
2759
2760         if (params.columns == 2)
2761                 fl_set_button(fd_form_document->radio_columns_two, 1);
2762         else
2763                 fl_set_button(fd_form_document->radio_columns_one, 1);
2764
2765         fl_set_input(fd_form_document->input_extra, params.options.c_str());
2766         fl_set_counter_value(fd_form_document->slider_secnumdepth,
2767                              params.secnumdepth);
2768         fl_set_counter_value(fd_form_document->slider_tocdepth,
2769                              params.tocdepth);
2770
2771 }
2772
2773 extern "C" void ChoiceClassCB(FL_OBJECT *ob, long)
2774 {
2775         ProhibitInput();
2776         if (textclasslist.Load(fl_get_choice(ob)-1)) {
2777                 if (AskQuestion(_("Should I set some parameters to"),
2778                                 fl_get_choice_text(ob),
2779                                 _("the defaults of this document class?"))) {
2780                         BufferParams params = BufferParams();
2781                         params.textclass = fl_get_choice(ob)-1;
2782                         params.useClassDefaults();
2783                         UpdateLayoutDocument(&params);
2784                         UpdateDocumentButtons(params);
2785                 }
2786         } else {
2787                 // unable to load new style
2788                 WriteAlert(_("Conversion Errors!"),
2789                            _("Unable to switch to new document class."),
2790                            _("Reverting to original document class."));
2791                 fl_set_choice(fd_form_document->choice_class,
2792                               GetCurrentTextClass() + 1);
2793         }
2794         AllowInput();
2795 }
2796
2797
2798 extern "C" void DocumentDefskipCB(FL_OBJECT *obj, long)
2799 {
2800         // "Synchronize" the choice and the input field, so that it
2801         // is impossible to commit senseless data.
2802         const FD_form_document* fd = fd_form_document;
2803
2804         if (obj == fd->choice_default_skip) {
2805                 if (fl_get_choice (fd->choice_default_skip) != 4) {
2806                         fl_set_input (fd->input_default_skip, "");
2807                         ActivateDocumentButtons();
2808                 }
2809         } else if (obj == fd->input_default_skip) {
2810
2811                 const char* input = fl_get_input (fd->input_default_skip);
2812
2813                 if (!*input) {
2814                         fl_set_choice (fd->choice_default_skip, 2);
2815                         ActivateDocumentButtons();
2816                 } else if (isValidGlueLength (input)) {
2817                         fl_set_choice (fd->choice_default_skip, 4);
2818                         ActivateDocumentButtons();
2819                 } else {
2820                         fl_set_choice (fd->choice_default_skip, 4);
2821                         DeactivateDocumentButtons();
2822                 }
2823         }
2824 }
2825
2826
2827 extern "C" void DocumentSpacingCB(FL_OBJECT *obj, long)
2828 {
2829         // "Synchronize" the choice and the input field, so that it
2830         // is impossible to commit senseless data.
2831         const FD_form_document* fd = fd_form_document;
2832
2833         if (obj == fd->choice_spacing
2834             && fl_get_choice (fd->choice_spacing) != 4) {
2835                 fl_set_input(fd->input_spacing, "");
2836         } else if (obj == fd->input_spacing) {
2837
2838                 const char* input = fl_get_input (fd->input_spacing);
2839
2840                 if (!*input) {
2841                         fl_set_choice (fd->choice_spacing, 1);
2842                 } else {
2843                         fl_set_choice (fd->choice_spacing, 4);
2844                 }
2845         }
2846 }
2847
2848
2849 extern "C" void DocumentApplyCB(FL_OBJECT *, long)
2850 {
2851         bool redo = false;
2852         BufferParams *params = &(current_view->buffer()->params);
2853         current_view->buffer()->params.language =
2854                 combo_language->getline();
2855
2856         // If default skip is a "Length" but there's no text in the
2857         // input field, reset the kind to "Medskip", which is the default.
2858         if (fl_get_choice (fd_form_document->choice_default_skip) == 4
2859             && !*(fl_get_input (fd_form_document->input_default_skip))) {
2860                 fl_set_choice (fd_form_document->choice_default_skip, 2);
2861         }
2862
2863         /* this shouldn't be done automatically IMO. For example I write german
2864          * documents with an american keyboard very often. Matthias */
2865
2866         /* ChangeKeymap(buffer->parameters.language, TRUE, false,
2867            fl_get_choice(fd_form_document->choice_language)); */
2868         params->fonts =
2869                 fl_get_choice_text(fd_form_document->choice_fonts);
2870         params->inputenc =
2871                 fl_get_choice_text(fd_form_document->choice_inputenc);
2872         params->fontsize =
2873                 fl_get_choice_text(fd_form_document->choice_fontsize);
2874         params->pagestyle =
2875                 fl_get_choice_text(fd_form_document->choice_pagestyle);
2876         params->graphicsDriver =
2877                 fl_get_choice_text(fd_form_document->choice_postscript_driver);
2878         params->use_amsmath =
2879                 fl_get_button(fd_form_document->check_use_amsmath);
2880
2881         if (!current_view->available())
2882                 return;
2883
2884         LyXTextClassList::ClassList::size_type new_class = fl_get_choice(fd_form_document->choice_class) - 1;
2885         if (params->textclass != new_class) {
2886                 // try to load new_class
2887                 if (textclasslist.Load(new_class)) {
2888                         // successfully loaded
2889                         redo = true;
2890                         minibuffer->Set(_("Converting document to new document class..."));
2891                         int ret = current_view->buffer()->
2892                                 text->
2893                                 SwitchLayoutsBetweenClasses(current_view->buffer()->
2894                                                             params.textclass,
2895                                                             new_class,
2896                                                             current_view->buffer()->
2897                                                             paragraph);
2898
2899                         if (ret){
2900                                 string s;
2901                                 if (ret == 1)
2902                                         s = _("One paragraph couldn't be converted");
2903                                 else {
2904                                         s += tostr(ret);
2905                                         s += _(" paragraphs couldn't be converted");
2906                                 }
2907                                 WriteAlert(_("Conversion Errors!"), s,
2908                                            _("into chosen document class"));
2909                         }
2910
2911                         params->textclass = new_class;
2912                 } else {
2913                         // problem changing class -- warn user and retain old style
2914                         WriteAlert(_("Conversion Errors!"),
2915                                    _("Unable to switch to new document class."),
2916                                    _("Reverting to original document class."));
2917                         fl_set_choice(fd_form_document->choice_class, params->textclass + 1);
2918                 }
2919         }
2920
2921         char tmpsep = params->paragraph_separation;
2922         if (fl_get_button(fd_form_document->radio_indent))
2923                 params->paragraph_separation = BufferParams::PARSEP_INDENT;
2924         else
2925                 params->paragraph_separation = BufferParams::PARSEP_SKIP;
2926         if (tmpsep != params->paragraph_separation)
2927                 redo = true;
2928
2929         VSpace tmpdefskip = params->getDefSkip();
2930         switch (fl_get_choice (fd_form_document->choice_default_skip)) {
2931         case 1: params->setDefSkip(VSpace(VSpace::SMALLSKIP)); break;
2932         case 2: params->setDefSkip(VSpace(VSpace::MEDSKIP)); break;
2933         case 3: params->setDefSkip(VSpace(VSpace::BIGSKIP)); break;
2934         case 4: params->setDefSkip(
2935                 VSpace (LyXGlueLength (fl_get_input
2936                                        (fd_form_document->input_default_skip))));
2937         break;
2938         // DocumentDefskipCB assures that this never happens
2939         default: params->setDefSkip(VSpace(VSpace::MEDSKIP)); break;
2940         }
2941         if (!(tmpdefskip == params->getDefSkip()))
2942                 redo = true;
2943
2944         if (fl_get_button(fd_form_document->radio_columns_two))
2945                 params->columns = 2;
2946         else
2947                 params->columns = 1;
2948         if (fl_get_button(fd_form_document->radio_sides_two))
2949                 params->sides = LyXTextClass::TwoSides;
2950         else
2951                 params->sides = LyXTextClass::OneSide;
2952
2953         Spacing tmpSpacing = params->spacing;
2954         switch(fl_get_choice(fd_form_document->choice_spacing)) {
2955         case 1:
2956                 lyxerr.debug() << "Spacing: SINGLE" << endl;
2957                 params->spacing.set(Spacing::Single);
2958                 break;
2959         case 2:
2960                 lyxerr.debug() << "Spacing: ONEHALF" << endl;
2961                 params->spacing.set(Spacing::Onehalf);
2962                 break;
2963         case 3:
2964                 lyxerr.debug() << "Spacing: DOUBLE" << endl;
2965                 params->spacing.set(Spacing::Double);
2966                 break;
2967         case 4:
2968                 lyxerr.debug() << "Spacing: OTHER" << endl;
2969                 params->spacing.set(Spacing::Other,
2970                                     fl_get_input(fd_form_document->input_spacing));
2971                 break;
2972         }
2973         if (tmpSpacing != params->spacing)
2974                 redo = true;
2975
2976         signed char tmpchar =
2977                 static_cast<signed char>(fl_get_counter_value(fd_form_document->slider_secnumdepth));
2978         if (params->secnumdepth != tmpchar)
2979                 redo = true;
2980         params->secnumdepth = tmpchar;
2981
2982         params->tocdepth =
2983                 static_cast<int>(fl_get_counter_value(fd_form_document->slider_tocdepth));
2984
2985         params->float_placement =
2986                 fl_get_input(fd_form_document->input_float_placement);
2987
2988         // More checking should be done to ensure the string doesn't have
2989         // spaces or illegal placement characters in it. (thornley)
2990
2991         if (redo)
2992                 current_view->redoCurrentBuffer();
2993
2994         minibuffer->Set(_("Document layout set"));
2995         current_view->buffer()->markDirty();
2996
2997         params->options =
2998                 fl_get_input(fd_form_document->input_extra);
2999
3000 }
3001
3002
3003 extern "C" void DocumentCancelCB(FL_OBJECT *, long)
3004 {
3005         fl_hide_form(fd_form_document->form_document);
3006 }
3007
3008
3009 extern "C" void DocumentOKCB(FL_OBJECT *ob, long data)
3010 {
3011         DocumentCancelCB(ob, data);
3012         DocumentApplyCB(ob, data);
3013 }
3014
3015
3016 extern "C" void DocumentBulletsCB(FL_OBJECT *, long)
3017 {
3018         bulletForm();
3019         // bullet callbacks etc. in bullet_panel.C -- ARRae
3020 }
3021
3022
3023 void GotoNote()
3024 {
3025         if (!current_view->getScreen())
3026                 return;
3027
3028         current_view->getScreen()->HideCursor();
3029         BeforeChange();
3030         current_view->buffer()->update(-2);
3031         LyXCursor tmp;
3032
3033         if (!current_view->buffer()->text->GotoNextNote()) {
3034                 if (current_view->buffer()->text->cursor.pos
3035                     || current_view->buffer()->text->cursor.par !=
3036                     current_view->buffer()->text->FirstParagraph())
3037                         {
3038                                 tmp = current_view->buffer()->text->cursor;
3039                                 current_view->buffer()->text->cursor.par =
3040                                         current_view->buffer()->text->FirstParagraph();
3041                                 current_view->buffer()->text->cursor.pos = 0;
3042                                 if (!current_view->buffer()->text->GotoNextNote()) {
3043                                         current_view->buffer()->text->cursor = tmp;
3044                                         minibuffer->Set(_("No more notes"));
3045                                         LyXBell();
3046                                 }
3047                         } else {
3048                                 minibuffer->Set(_("No more notes"));
3049                                 LyXBell();
3050                         }
3051         }
3052         current_view->buffer()->update(0);
3053         current_view->buffer()->text->sel_cursor =
3054                 current_view->buffer()->text->cursor;
3055 }
3056
3057
3058 void InsertCorrectQuote()
3059 {
3060         Buffer * cbuffer = current_view->buffer();
3061         char c;
3062
3063         if  (cbuffer->text->cursor.pos )
3064                 c = cbuffer->text->cursor.par->GetChar(cbuffer->text->cursor.pos - 1);
3065         else
3066                 c = ' ';
3067
3068         cbuffer->insertInset(new InsetQuotes(c, cbuffer->params));
3069 }
3070
3071
3072 /* callbacks for form form_quotes */
3073
3074 extern "C" void QuotesApplyCB(FL_OBJECT *, long)
3075 {
3076         if (!current_view->available())
3077                 return;
3078
3079         minibuffer->Set(_("Quotes type set"));
3080         //current_view->buffer()->params.quotes_language =
3081         //      fl_get_choice(fd_form_quotes->choice_quotes_language) - 1;
3082         InsetQuotes::quote_language lga = InsetQuotes::EnglishQ;
3083         switch(fl_get_choice(fd_form_quotes->choice_quotes_language) - 1) {
3084         case 0:
3085                 lga = InsetQuotes::EnglishQ;
3086                 break;
3087         case 1:
3088                 lga = InsetQuotes::SwedishQ;
3089                 break;
3090         case 2:
3091                 lga = InsetQuotes::GermanQ;
3092                 break;
3093         case 3:
3094                 lga = InsetQuotes::PolishQ;
3095                 break;
3096         case 4:
3097                 lga = InsetQuotes::FrenchQ;
3098                 break;
3099         case 5:
3100                 lga = InsetQuotes::DanishQ;
3101                 break;
3102         }
3103         current_view->buffer()->params.quotes_language = lga;
3104         if (fl_get_button(fd_form_quotes->radio_single))
3105                 current_view->buffer()->
3106                         params.quotes_times = InsetQuotes::SingleQ;
3107         else
3108                 current_view->buffer()->
3109                         params.quotes_times = InsetQuotes::DoubleQ;
3110 }
3111
3112
3113 extern "C" void QuotesCancelCB(FL_OBJECT *, long)
3114 {
3115         fl_hide_form(fd_form_quotes->form_quotes);
3116 }
3117
3118
3119 extern "C" void QuotesOKCB(FL_OBJECT *ob, long data)
3120 {
3121         QuotesApplyCB(ob, data);
3122         QuotesCancelCB(ob, data);
3123 }
3124
3125
3126
3127 /* callbacks for form form_preamble */
3128
3129 extern "C" void PreambleCancelCB(FL_OBJECT *, long)
3130 {
3131         fl_hide_form(fd_form_preamble->form_preamble);
3132 }
3133
3134
3135 extern "C" void PreambleApplyCB(FL_OBJECT *, long)
3136 {
3137         if (!current_view->available())
3138                 return;
3139
3140         current_view->buffer()->params.preamble =
3141                 fl_get_input(fd_form_preamble->input_preamble);
3142         current_view->buffer()->markDirty();
3143         minibuffer->Set(_("LaTeX preamble set"));
3144 }
3145
3146
3147 extern "C" void PreambleOKCB(FL_OBJECT *ob, long data)
3148 {
3149         PreambleApplyCB(ob, data);
3150         PreambleCancelCB(ob, data);
3151 }
3152
3153
3154 /* callbacks for form form_table */
3155
3156 extern "C" void TableApplyCB(FL_OBJECT *, long)
3157 {
3158         int xsize, ysize;
3159         if (!current_view->getScreen())
3160                 return;
3161
3162         // check for tables in tables
3163         if (current_view->buffer()->text->cursor.par->table){
3164                 WriteAlert(_("Impossible Operation!"),
3165                            _("Cannot insert table in table."),
3166                            _("Sorry."));
3167                 return;
3168         }
3169
3170         minibuffer->Set(_("Inserting table..."));
3171
3172         ysize = (int)(fl_get_slider_value(fd_form_table->slider_columns) + 0.5);
3173         xsize = (int)(fl_get_slider_value(fd_form_table->slider_rows) + 0.5);
3174
3175
3176         current_view->getScreen()->HideCursor();
3177         BeforeChange();
3178         current_view->buffer()->update(-2);
3179
3180         current_view->buffer()->text->SetCursorParUndo();
3181         current_view->buffer()->text->FreezeUndo();
3182
3183         current_view->buffer()->text->BreakParagraph();
3184         current_view->buffer()->update(-1);
3185
3186         if (current_view->buffer()->text->cursor.par->Last()) {
3187                 current_view->buffer()->text->CursorLeft();
3188
3189                 current_view->buffer()->text->BreakParagraph();
3190                 current_view->buffer()->update(-1);
3191         }
3192
3193         current_view->buffer()->text->current_font.setLatex(LyXFont::OFF);
3194         //if (!fl_get_button(fd_form_table->check_latex)){
3195         // insert the new wysiwy table
3196         current_view->buffer()->text->SetLayout(0); // standard layout
3197         if (current_view->buffer()->text->cursor.par->footnoteflag ==
3198             LyXParagraph::NO_FOOTNOTE) {
3199                 current_view->buffer()->
3200                         text->SetParagraph(0, 0,
3201                                            0, 0,
3202                                            VSpace (0.3 * current_view->buffer()->
3203                                                    params.spacing.getValue(),
3204                                                    LyXLength::CM),
3205                                            VSpace (0.3 * current_view->buffer()->
3206                                                    params.spacing.getValue(),
3207                                                    LyXLength::CM),
3208                                            LYX_ALIGN_CENTER,
3209                                            string(),
3210                                            0);
3211         }
3212         else
3213                 current_view->buffer()->text->SetParagraph(0, 0,
3214                                                                   0, 0,
3215                                                                   VSpace(VSpace::NONE),
3216                                                                   VSpace(VSpace::NONE),
3217                                            LYX_ALIGN_CENTER,
3218                                            string(),
3219                                            0);
3220
3221         current_view->buffer()->text->cursor.par->table = new LyXTable(xsize, ysize);
3222         int i;
3223         for (i = 0; i<xsize * ysize - 1; i++)
3224                 current_view->buffer()->text->cursor.par->InsertChar(0, LyXParagraph::META_NEWLINE);
3225         current_view->buffer()->text->RedoParagraph();
3226
3227         current_view->buffer()->text->UnFreezeUndo();
3228
3229         current_view->buffer()->update(1);
3230         minibuffer->Set(_("Table inserted"));
3231 }
3232
3233
3234 extern "C" void TableCancelCB(FL_OBJECT *, long)
3235 {
3236         fl_hide_form(fd_form_table->form_table);
3237 }
3238
3239
3240 extern "C" void TableOKCB(FL_OBJECT *ob, long data)
3241 {
3242         TableApplyCB(ob, data);
3243         TableCancelCB(ob, data);
3244 }
3245
3246
3247 /* callbacks for form form_print */
3248
3249 extern "C" void PrintCancelCB(FL_OBJECT *, long)
3250 {
3251         fl_hide_form(fd_form_print->form_print);
3252 }
3253
3254 static bool stringOnlyContains (string const & LStr, char const * cset)
3255 {
3256         char const * cstr = LStr.c_str() ;
3257
3258         return strspn(cstr, cset) == strlen(cstr) ;
3259 }
3260
3261 extern "C" void PrintApplyCB(FL_OBJECT *, long)
3262 {
3263         if (!current_view->available())
3264                 return;
3265         Buffer *buffer = current_view->buffer();
3266         string path = OnlyPath(buffer->getFileName());
3267
3268         string pageflag;
3269         if (fl_get_button(fd_form_print->radio_even_pages))
3270                 pageflag = lyxrc->print_evenpage_flag + ' ';
3271         else if (fl_get_button(fd_form_print->radio_odd_pages))
3272                 pageflag = lyxrc->print_oddpage_flag + ' ';
3273
3274 // Changes by Stephan Witt (stephan.witt@beusen.de), 19-Jan-99
3275 // User may give a page (range) list
3276 // User may print multiple (unsorted) copies
3277         string pages = subst(fl_get_input(fd_form_print->input_pages), ';',',');
3278         pages = subst(pages, '+',',');
3279         pages = frontStrip(strip(pages)) ;
3280         while (!pages.empty()) { // a page range was given
3281                 string piece ;
3282                 pages = split (pages, piece, ',') ;
3283                 piece = strip(piece) ;
3284                 piece = frontStrip(piece) ;
3285                 if ( !stringOnlyContains (piece, "0123456789-") ) {
3286                         WriteAlert(_("ERROR!  Unable to print!"),
3287                                 _("Check 'range of pages'!"));
3288                         return;
3289                 }
3290                 if (piece.find('-') == string::npos) { // not found
3291                         pageflag += lyxrc->print_pagerange_flag + piece + '-' + piece + ' ' ;
3292                 } else if (suffixIs(piece, "-") ) { // missing last page
3293                         pageflag += lyxrc->print_pagerange_flag + piece + "1000 ";
3294                 } else if (prefixIs(piece, "-") ) { // missing first page
3295                         pageflag += lyxrc->print_pagerange_flag + '1' + piece + ' ' ;
3296                 } else {
3297                         pageflag += lyxrc->print_pagerange_flag + piece + ' ' ;
3298                 }
3299         }
3300
3301         string copies = frontStrip(strip(fl_get_input(fd_form_print->input_copies)));
3302         if (!copies.empty()) { // a number of copies was given
3303                 if ( !stringOnlyContains (copies, "0123456789") ) {
3304                         WriteAlert(_("ERROR!  Unable to print!"),
3305                                 _("Check 'number of copies'!"));
3306                         return;
3307                 }
3308                 if (fl_get_button(fd_form_print->do_unsorted))
3309                         pageflag += lyxrc->print_copies_flag;
3310                 else
3311                         pageflag += lyxrc->print_collcopies_flag;
3312                 pageflag += " " + copies + ' ' ;
3313         }
3314
3315         string reverseflag;
3316         if (fl_get_button(fd_form_print->radio_order_reverse))
3317                 reverseflag = lyxrc->print_reverse_flag + ' ';
3318
3319         string orientationflag;
3320         if (buffer->params.orientation == BufferParams::ORIENTATION_LANDSCAPE)
3321                 orientationflag = lyxrc->print_landscape_flag + ' ';
3322
3323         string ps_file = SpaceLess(fl_get_input(fd_form_print->input_file));
3324         string printer = strip(fl_get_input(fd_form_print->input_printer));
3325
3326         string printerflag;
3327         if (lyxrc->print_adapt_output // printer name should be passed to dvips
3328             && ! printer.empty()) // a printer name has been given
3329                 printerflag = lyxrc->print_to_printer + printer + ' ';
3330
3331         string extraflags;
3332         if (!lyxrc->print_extra_options.empty())
3333                 extraflags = lyxrc->print_extra_options + ' ';
3334
3335         string command = lyxrc->print_command + ' '
3336                 + printerflag + pageflag + reverseflag
3337                 + orientationflag + extraflags;
3338
3339         char real_papersize = buffer->params.papersize;
3340         if (real_papersize == BufferParams::PAPER_DEFAULT)
3341                 real_papersize = lyxrc->default_papersize;
3342         string
3343             paper;
3344
3345         switch (real_papersize) {
3346         case BufferParams::PAPER_USLETTER:
3347                 paper = "letter";
3348                 break;
3349         case BufferParams::PAPER_A3PAPER:
3350                 paper = "a3";
3351                 break;
3352         case BufferParams::PAPER_A4PAPER:
3353                 paper = "a4";
3354                 break;
3355         case BufferParams::PAPER_A5PAPER:
3356                 paper = "a5";
3357                 break;
3358         case BufferParams::PAPER_B5PAPER:
3359                 paper = "b5";
3360                 break;
3361         case BufferParams::PAPER_EXECUTIVEPAPER:
3362                 paper = "foolscap";
3363                 break;
3364         case BufferParams::PAPER_LEGALPAPER:
3365                 paper = "legal";
3366                 break;
3367         default: /* If nothing else fits, keep an empty value... */
3368                 break;
3369         }
3370
3371         if (buffer->params.use_geometry
3372             && buffer->params.papersize2 == BufferParams::VM_PAPER_CUSTOM
3373             && !lyxrc->print_paper_dimension_flag.empty()
3374             && !buffer->params.paperwidth.empty()
3375             && !buffer->params.paperheight.empty()) {
3376                 // using a custom papersize
3377                 command += ' ';
3378                 command += lyxrc->print_paper_dimension_flag + ' ';
3379                 command += buffer->params.paperwidth + ',';
3380                 command += buffer->params.paperheight + ' ';
3381         } else if (!lyxrc->print_paper_flag.empty()
3382                    && !paper.empty()
3383                    && (real_papersize != BufferParams::PAPER_USLETTER ||
3384                        buffer->params.orientation == BufferParams::ORIENTATION_PORTRAIT)) {
3385                 command += " " + lyxrc->print_paper_flag + " " + paper + " ";
3386         }
3387         if (fl_get_button(fd_form_print->radio_file))
3388                 command += lyxrc->print_to_file + '\"'
3389                         + MakeAbsPath(ps_file, path)
3390                         + '\"';
3391         else if (!lyxrc->print_spool_command.empty())
3392                 command += lyxrc->print_to_file
3393                         + '\"' + ps_file + '\"';
3394
3395         // push directorypath, if necessary
3396         if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)){
3397                 path = buffer->tmppath;
3398         }
3399         Path p(path);
3400
3401         bool result;
3402         if (!lyxrc->print_spool_command.empty() &&
3403             !fl_get_button(fd_form_print->radio_file)) {
3404                 string command2 = lyxrc->print_spool_command + ' ';
3405                 if (!printer.empty())
3406                         command2 += lyxrc->print_spool_printerprefix
3407                                     + printer;
3408                 // First run dvips and, if succesful, then spool command
3409                 if ((result = RunScript(buffer, true, command))) {
3410                         result = RunScript(buffer, false, command2, ps_file);
3411                 }
3412         } else
3413                 result = RunScript(buffer, false, command);
3414
3415         if (!result)
3416                 WriteAlert(_("Error:"),
3417                            _("Unable to print"),
3418                            _("Check that your parameters are correct"));
3419 }
3420
3421
3422 extern "C" void PrintOKCB(FL_OBJECT *ob, long data)
3423 {
3424         PrintCancelCB(ob, data);
3425         PrintApplyCB(ob, data);
3426 }
3427
3428
3429 /* callbacks for form form_figure */
3430
3431 extern "C" void FigureApplyCB(FL_OBJECT *, long)
3432 {
3433         if (!current_view->available())
3434                 return;
3435
3436         Buffer * buffer = current_view->buffer();
3437         if(buffer->isReadonly()) // paranoia
3438                 return;
3439
3440         minibuffer->Set(_("Inserting figure..."));
3441         if (fl_get_button(fd_form_figure->radio_inline)
3442             || buffer->text->cursor.par->table) {
3443                 InsetFig * new_inset = new InsetFig(100, 20, buffer);
3444                 buffer->insertInset(new_inset);
3445                 minibuffer->Set(_("Figure inserted"));
3446                 new_inset->Edit(0, 0);
3447                 return;
3448         }
3449
3450         current_view->getScreen()->HideCursor();
3451         buffer->update(-2);
3452         BeforeChange();
3453
3454         buffer->text->SetCursorParUndo();
3455         buffer->text->FreezeUndo();
3456
3457         buffer->text->BreakParagraph();
3458         buffer->update(-1);
3459
3460         if (buffer->text->cursor.par->Last()) {
3461                 buffer->text->CursorLeft();
3462
3463                 buffer->text->BreakParagraph();
3464                 buffer->update(-1);
3465         }
3466
3467         // The standard layout should always be numer 0;
3468         buffer->text->SetLayout(0);
3469
3470         if (buffer->text->cursor.par->footnoteflag ==
3471             LyXParagraph::NO_FOOTNOTE) {
3472                 buffer->text->SetParagraph(0, 0,
3473                                            0, 0,
3474                                            VSpace (0.3 * buffer->params.spacing.getValue(),
3475                                                    LyXLength::CM),
3476                                            VSpace (0.3 *
3477                                                    buffer->params.spacing.getValue(),
3478                                                    LyXLength::CM),
3479                                            LYX_ALIGN_CENTER, string(), 0);
3480         } else
3481                 buffer->text->SetParagraph(0, 0,
3482                                            0, 0,
3483                                            VSpace(VSpace::NONE),
3484                                            VSpace(VSpace::NONE),
3485                                            LYX_ALIGN_CENTER,
3486                                            string(),
3487                                            0);
3488
3489         buffer->update(-1);
3490
3491         Inset * new_inset = new InsetFig(100, 100, buffer);
3492         buffer->insertInset(new_inset);
3493         new_inset->Edit(0, 0);
3494         buffer->update(0);
3495         minibuffer->Set(_("Figure inserted"));
3496         buffer->text->UnFreezeUndo();
3497 }
3498
3499
3500 extern "C" void FigureCancelCB(FL_OBJECT *, long)
3501 {
3502         fl_hide_form(fd_form_figure->form_figure);
3503 }
3504
3505
3506 extern "C" void FigureOKCB(FL_OBJECT *ob, long data)
3507 {
3508         FigureApplyCB(ob, data);
3509         FigureCancelCB(ob, data);
3510 }
3511
3512 extern "C" void ScreenApplyCB(FL_OBJECT *, long)
3513 {
3514         lyxrc->roman_font_name = fl_get_input(fd_form_screen->input_roman);
3515         lyxrc->sans_font_name = fl_get_input(fd_form_screen->input_sans);
3516         lyxrc->typewriter_font_name = fl_get_input(fd_form_screen->input_typewriter);
3517         lyxrc->font_norm = fl_get_input(fd_form_screen->input_font_norm);
3518         lyxrc->zoom = atoi(fl_get_input(fd_form_screen->intinput_size));
3519         fontloader.update();
3520
3521         // All buffers will need resize
3522         bufferlist.resize();
3523
3524         minibuffer->Set(_("Screen options set"));
3525 }
3526
3527
3528 extern "C" void ScreenCancelCB(FL_OBJECT *, long)
3529 {
3530         fl_hide_form(fd_form_screen->form_screen);
3531 }
3532
3533
3534 extern "C" void ScreenOKCB(FL_OBJECT *ob, long data)
3535 {
3536         ScreenCancelCB(ob, data);
3537         ScreenApplyCB(ob, data);
3538 }
3539
3540
3541 void LaTeXOptions()
3542 {
3543         if (!current_view->available())
3544                 return;
3545
3546         fl_set_button(fd_latex_options->accents,
3547                       (int)current_view->buffer()->params.allowAccents);
3548
3549         if (fd_latex_options->LaTeXOptions->visible) {
3550                 fl_raise_form(fd_latex_options->LaTeXOptions);
3551         } else {
3552                 fl_show_form(fd_latex_options->LaTeXOptions,
3553                              FL_PLACE_MOUSE, FL_FULLBORDER,
3554                              _("LaTeX Options"));
3555         }
3556 }
3557
3558
3559 // This function runs "configure" and then rereads lyx.defaults to
3560 // reconfigure the automatic settings.
3561 void Reconfigure()
3562 {
3563         minibuffer->Set(_("Running configure..."));
3564
3565         // Run configure in user lyx directory
3566         Path p(user_lyxdir);
3567         Systemcalls one(Systemcalls::System,
3568                           AddName(system_lyxdir, "configure"));
3569         p.pop();
3570         minibuffer->Set(_("Reloading configuration..."));
3571         lyxrc->Read(LibFileSearch(string(), "lyxrc.defaults"));
3572         WriteAlert(_("The system has been reconfigured."),
3573                    _("You need to restart LyX to make use of any"),
3574                    _("updated document class specifications."));
3575 }
3576
3577
3578 /* these functions are for the spellchecker */
3579 char* NextWord(float &value)
3580 {
3581         if (!current_view->available()){
3582                 value = 1;
3583                 return 0;
3584         }
3585
3586         char* string =  current_view->buffer()->text->SelectNextWord(value);
3587
3588         return string;
3589 }
3590
3591
3592 void SelectLastWord()
3593 {
3594         if (!current_view->available())
3595                 return;
3596
3597         current_view->getScreen()->HideCursor();
3598         BeforeChange();
3599         current_view->buffer()->text->SelectSelectedWord();
3600         current_view->getScreen()->ToggleSelection(false);
3601         current_view->buffer()->update(0);
3602 }
3603
3604
3605 void EndOfSpellCheck()
3606 {
3607         if (!current_view->available())
3608                 return;
3609
3610         current_view->getScreen()->HideCursor();
3611         BeforeChange();
3612         current_view->buffer()->text->SelectSelectedWord();
3613         current_view->buffer()->text->ClearSelection();
3614         current_view->buffer()->update(0);
3615 }
3616
3617
3618 void ReplaceWord(string const & replacestring)
3619 {
3620         if (!current_view->getScreen())
3621                 return;
3622
3623         current_view->getScreen()->HideCursor();
3624         current_view->buffer()->update(-2);
3625
3626         /* clear the selection (if there is any) */
3627         current_view->getScreen()->ToggleSelection(false);
3628         current_view->buffer()->text->
3629                 ReplaceSelectionWithString(replacestring.c_str());
3630
3631         current_view->buffer()->text->SetSelectionOverString(replacestring.c_str());
3632
3633         // Go back so that replacement string is also spellchecked
3634         for (string::size_type i = 0; i < replacestring.length() + 1; ++i) {
3635                 current_view->buffer()->text->CursorLeftIntern();
3636         }
3637         current_view->buffer()->update(1);
3638 }
3639 // End of spellchecker stuff
3640
3641
3642
3643 //
3644 // Table of Contents
3645 //
3646
3647 struct TocList {
3648         int counter[6];
3649         bool appendix;
3650         TocList *next;
3651 };
3652
3653
3654 static TocList* toclist = 0;
3655
3656
3657 extern "C" void TocSelectCB(FL_OBJECT *ob, long)
3658 {
3659         if (!current_view->available())
3660                 return;
3661
3662         TocList* tmptoclist = toclist;
3663         int i = fl_get_browser(ob);
3664         int a = 0;
3665
3666         for (a = 1; a<i && tmptoclist->next; a++){
3667                 tmptoclist = tmptoclist->next;
3668         }
3669
3670         if (!tmptoclist)
3671                 return;
3672
3673
3674         LyXParagraph *par = current_view->buffer()->paragraph;
3675         while (par && (par->GetFirstCounter(0) != tmptoclist->counter[0] ||
3676                        par->GetFirstCounter(1) != tmptoclist->counter[1] ||
3677                        par->GetFirstCounter(2) != tmptoclist->counter[2] ||
3678                        par->GetFirstCounter(3) != tmptoclist->counter[3] ||
3679                        par->GetFirstCounter(4) != tmptoclist->counter[4] ||
3680                        par->GetFirstCounter(5) != tmptoclist->counter[5] ||
3681                        par->appendix != tmptoclist->appendix)) {
3682                 par = par->LastPhysicalPar()->Next();
3683         }
3684
3685         if (par) {
3686                 BeforeChange();
3687                 current_view->buffer()->text->SetCursor(par, 0);
3688                 current_view->buffer()->text->sel_cursor =
3689                         current_view->buffer()->text->cursor;
3690                 current_view->buffer()->update(0);
3691         }
3692         else {
3693                 WriteAlert(_("Error"),
3694                            _("Couldn't find this label"),
3695                            _("in current document."));
3696         }
3697
3698 }
3699
3700
3701 extern "C" void TocCancelCB(FL_OBJECT *, long)
3702 {
3703         fl_hide_form(fd_form_toc->form_toc);
3704 }
3705
3706
3707 extern "C" void TocUpdateCB(FL_OBJECT *, long)
3708 {
3709         static LyXParagraph * stapar = 0;
3710         TocList * tmptoclist = 0;
3711
3712         /* deleted the toclist */
3713         if (toclist){
3714                 while (toclist){
3715                         tmptoclist = toclist->next;
3716                         delete toclist;
3717                         toclist = tmptoclist;
3718                 }
3719         }
3720         toclist = 0;
3721         tmptoclist = toclist;
3722
3723
3724         fl_clear_browser(fd_form_toc->browser_toc);
3725         if (!current_view->available()) {
3726                 fl_add_browser_line(fd_form_toc->browser_toc, _("*** No Document ***"));
3727                 return;
3728         }
3729         fl_hide_object(fd_form_toc->browser_toc);
3730         /* get the table of contents */
3731         LyXParagraph * par = current_view->buffer()->paragraph;
3732         char labeltype;
3733         char * line = new char[200];
3734         int pos = 0;
3735         unsigned char c;
3736         int topline = 0;
3737
3738         if (stapar == par)
3739                 topline = fl_get_browser_topline(fd_form_toc->browser_toc);
3740         stapar = par;
3741
3742         while (par) {
3743                 labeltype = textclasslist.Style(current_view->buffer()->params.textclass,
3744                                            par->GetLayout()).labeltype;
3745
3746                 if (labeltype >= LABEL_COUNTER_CHAPTER
3747                     && labeltype <= LABEL_COUNTER_CHAPTER +
3748                     current_view->buffer()->params.tocdepth) {
3749                         /* insert this into the table of contents */
3750                         /* first indent a little bit */
3751
3752                         for (pos = 0;
3753                              pos < (labeltype -
3754                                     textclasslist.TextClass(current_view->buffer()->
3755                                                        params.textclass).maxcounter()) * 4 + 2;
3756                              pos++)
3757                                 line[pos] = ' ';
3758
3759                         // Then the labestring
3760                         if (!par->labelstring.empty()) {
3761                                 string::size_type i = 0;
3762                                 while (pos < 199 && i < par->labelstring.length()) {
3763                                         line[pos] = par->labelstring[i];
3764                                         i++;
3765                                         pos++;
3766                                 }
3767                         }
3768
3769                         line[pos] = ' ';
3770                         pos++;
3771
3772                         /* now the contents */
3773                         LyXParagraph::size_type i = 0;
3774                         while (pos < 199 && i < par->size()) {
3775                                 c = par->GetChar(i);
3776                                 if (isprint(c) || c >= 128) {
3777                                         line[pos] = c;
3778                                         pos++;
3779                                 }
3780                                 i++;
3781                         }
3782                         line[pos] = '\0';
3783                         fl_add_browser_line(fd_form_toc->browser_toc, line);
3784
3785                         /* make a toclist entry */
3786                         if (!tmptoclist){
3787                                 tmptoclist = new TocList;
3788                                 toclist = tmptoclist;
3789                         } else {
3790                                 tmptoclist->next = new TocList;
3791                                 tmptoclist = tmptoclist->next;
3792                         }
3793
3794                         tmptoclist->next = 0;
3795                         int a = 0;
3796                         for (a = 0; a<6; a++){
3797                                 tmptoclist->counter[a] = par->GetFirstCounter(a);
3798                         }
3799                         tmptoclist->appendix = par->appendix;
3800                 }
3801                 par = par->LastPhysicalPar()->Next();
3802
3803         }
3804         delete[] line;
3805         fl_set_browser_topline(fd_form_toc->browser_toc, topline);
3806         fl_show_object(fd_form_toc->browser_toc);
3807 }
3808
3809
3810 /* callbacks for form form_ref */
3811 extern "C" void RefSelectCB(FL_OBJECT *, long data)
3812 {
3813         if (!current_view->available())
3814                 return;
3815
3816         string s =
3817                 fl_get_browser_line(fd_form_ref->browser_ref,
3818                                     fl_get_browser(fd_form_ref->browser_ref));
3819         string u = frontStrip(strip(fl_get_input(fd_form_ref->ref_name)));
3820
3821         if (s.empty())
3822                 return;
3823
3824         if (data == 2) {
3825                 current_view->owner()->getLyXFunc()->Dispatch(LFUN_REFGOTO, s.c_str());
3826                 return;
3827         }
3828
3829         string t;
3830         if (data == 0)
3831                 t += "\\ref";
3832         else
3833                 t += "\\pageref";
3834
3835         if(current_view->buffer()->isSGML())
3836                 t += "[" + u + "]" + "{" + s + "}";
3837         else
3838                 t += "{" + s + "}";
3839
3840         Inset * new_inset =
3841                 new InsetRef(t, current_view->buffer());
3842         current_view->buffer()->insertInset(new_inset);
3843 }
3844
3845
3846 extern "C" void RefUpdateCB(FL_OBJECT *, long)
3847 {
3848         if (!current_view->available()) {
3849                 fl_clear_browser(fd_form_ref->browser_ref);
3850                 return;
3851         }
3852
3853         FL_OBJECT * brow = fd_form_ref->browser_ref;
3854
3855         // Get the current line, in order to restore it later
3856         char const * const btmp = fl_get_browser_line(brow,
3857                                                      fl_get_browser(brow));
3858         string currentstr = btmp ? btmp : "";
3859         //string currentstr = fl_get_browser_line(brow,
3860         //                                      fl_get_browser(brow));
3861
3862         fl_clear_browser(brow);
3863
3864         string refs = current_view->buffer()->getReferenceList('\n');
3865         int topline = 1;
3866
3867 #if FL_REVISION > 85
3868         fl_addto_browser_chars(brow, refs.c_str());
3869         int total_lines = fl_get_browser_maxline(brow);
3870         for (int i = 1; i <= total_lines ; i++) {
3871                 if (fl_get_browser_line(brow, i) == currentstr) {
3872                         topline = i;
3873                         break;
3874                 }
3875         }
3876         fl_set_browser_topline(brow, topline);
3877 #else
3878         // Keep the old ugly code for xforms 0.81 compatibility
3879         string curr_ref;
3880         int ref_num = 0;
3881
3882         while(true) {
3883                 curr_ref = refs.token('\n', ref_num);
3884                 if (curr_ref.empty())
3885                         break;
3886                 fl_add_browser_line(brow, curr_ref.c_str());
3887                 ref_num++;
3888         }
3889 #endif
3890
3891         if (!fl_get_browser_maxline(brow)) {
3892                 fl_add_browser_line(brow,
3893                                     _("*** No labels found in document ***"));
3894                 fl_deactivate_object(brow);
3895         } else {
3896                 fl_select_browser_line(brow, topline);
3897                 fl_activate_object(brow);
3898         }
3899         if (current_view->buffer()->isReadonly()) {
3900                 // would be better to de/activate insert buttons
3901                 // but that's more work... besides this works. ARRae
3902                 fl_hide_form(fd_form_ref->form_ref);
3903         }
3904         if (!current_view->buffer()->isSGML()) {
3905                 fl_deactivate_object(fd_form_ref->ref_name);
3906                 fl_set_object_lcol(fd_form_ref->ref_name, FL_INACTIVE);
3907         }
3908         else {
3909                 fl_activate_object(fd_form_ref->ref_name);
3910                 fl_set_object_lcol(fd_form_ref->ref_name, FL_BLACK);
3911         }
3912 }
3913
3914
3915 extern "C" void RefHideCB(FL_OBJECT *, long)
3916 {
3917         fl_hide_form(fd_form_ref->form_ref);
3918 }
3919
3920
3921 void UpdateInset(Inset* inset, bool mark_dirty)
3922 {
3923         if (!inset)
3924                 return;
3925
3926         /* very first check for locking insets*/
3927         if (current_view->buffer()->the_locking_inset == inset){
3928                 if (current_view->buffer()->text->UpdateInset(inset)){
3929                         current_view->update();
3930                         if (mark_dirty){
3931                                 if (current_view->buffer()->isLyxClean())
3932                                         minibuffer->setTimer(4);
3933                                 current_view->buffer()->markDirty();
3934                         }
3935                         current_view->updateScrollbar();
3936                         return;
3937                 }
3938         }
3939
3940         /* first check the current buffer */
3941         if (current_view->available()){
3942                 current_view->getScreen()->HideCursor();
3943                 current_view->buffer()->update(-3);
3944                 if (current_view->buffer()->text->UpdateInset(inset)){
3945                         if (mark_dirty)
3946                                 current_view->buffer()->update(1);
3947                         else
3948                                 current_view->buffer()->update(3);
3949                         return;
3950                 }
3951         }
3952
3953         // check all buffers
3954         bufferlist.updateInset(inset, mark_dirty);
3955
3956 }
3957
3958
3959 /* these functions return 1 if an error occured,
3960    otherwise 0 */
3961 int LockInset(UpdatableInset* inset)
3962 {
3963         if (!current_view->buffer()->the_locking_inset && inset){
3964                 current_view->buffer()->the_locking_inset = inset;
3965                 return 0;
3966         }
3967         return 1;
3968 }
3969
3970
3971 void ShowLockedInsetCursor(long x, long y, int asc, int desc)
3972 {
3973         if (current_view->buffer()->the_locking_inset &&
3974             current_view->getScreen()){
3975                 y += current_view->buffer()->text->cursor.y;
3976                 current_view->getScreen()->ShowManualCursor(x, y,
3977                                                             asc, desc);
3978         }
3979 }
3980
3981
3982 void HideLockedInsetCursor(long x, long y, int asc, int desc)
3983 {
3984         if (current_view->buffer()->the_locking_inset &&
3985             current_view->getScreen()){
3986                 y += current_view->buffer()->text->cursor.y;
3987                 current_view->getScreen()->HideManualCursor(x, y,
3988                                                             asc, desc);
3989         }
3990 }
3991
3992
3993 void FitLockedInsetCursor(long x, long y, int asc, int desc)
3994 {
3995         if (current_view->buffer()->the_locking_inset &&
3996             current_view->getScreen()){
3997                 y += current_view->buffer()->text->cursor.y;
3998                 if (current_view->getScreen()->FitManualCursor(x, y, asc, desc))
3999                         current_view->updateScrollbar();
4000         }
4001 }
4002
4003
4004 int UnlockInset(UpdatableInset * inset)
4005 {
4006         if (inset &&
4007             current_view->buffer()->the_locking_inset == inset){
4008                 inset->InsetUnlock();
4009                 current_view->buffer()->the_locking_inset = 0;
4010                 current_view->buffer()->text->FinishUndo();
4011                 return 0;
4012         }
4013         return bufferlist.unlockInset(inset);
4014 }
4015
4016
4017 void LockedInsetStoreUndo(Undo::undo_kind kind)
4018 {
4019         if (!current_view->buffer()->the_locking_inset)
4020                 return; // shouldn't happen
4021         if (kind == Undo::EDIT) // in this case insets would not be stored!
4022                 kind = Undo::FINISH;
4023         current_view->buffer()->text->SetUndo(kind,
4024                               current_view->buffer()->text->cursor.par->
4025                               ParFromPos(current_view->buffer()->text->cursor.pos)->previous,
4026                               current_view->buffer()->text->cursor.par->
4027                               ParFromPos(current_view->buffer()->text->cursor.pos)->next);
4028 }
4029
4030
4031 void PutInsetIntoInsetUpdateList(Inset * inset)
4032 {
4033         if (inset) {
4034                 InsetUpdateStruct * tmp = new InsetUpdateStruct();
4035                 tmp->inset = inset;
4036                 tmp->next = InsetUpdateList;
4037                 InsetUpdateList = tmp;
4038         }
4039 }
4040
4041
4042 void UpdateInsetUpdateList()
4043 {
4044         InsetUpdateStruct * tmp = InsetUpdateList;
4045         while (tmp) {
4046                 UpdateInset(tmp->inset, false); // "false" because no document change
4047                 tmp = tmp->next;
4048         }
4049
4050         // delete the update list
4051         while (InsetUpdateList) {
4052                 tmp = InsetUpdateList;
4053                 InsetUpdateList = InsetUpdateList->next;
4054                 delete tmp;
4055         }
4056         InsetUpdateList = 0;
4057 }
4058
4059 #ifdef WITH_WARNINGS
4060 #warning UGLY!!
4061 #endif
4062 // I know we shouldn't put anything in here but this seems the fastest
4063 // way to do this (and the cleanest for now). This function just inserts
4064 // a newline in the string and the inserts 'depth'-spaces so that the
4065 // code is indented in the right way!!!
4066 void addNewlineAndDepth(string & file, int const depth)
4067 {
4068        file += '\n';
4069        file.append(depth, ' ');
4070 }
4071
4072