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