Quellcode-Bibliothek

^© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: figure.h Sprache: C

Original von: Lyx^©

/* This file is part of
* ======================================================
*
*           LyX, The Document Processor
*
*     Copyright (C) 1995 Matthias Ettrich,
*           Copyright (C) 1995-1998 The LyX Team.
*
*======================================================*/

#include <config.h>

#include <ctype.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>

#include "LString.h"
#include "lyx_main.h"
#include FORMS_H_LOCATION
#include "lyx.h"
#include "layout_forms.h"
#include "bullet_forms.h"
#include "print_form.h"
#include "form1.h"
#include "spellchecker.h"
#include "version.h"
#include "lyx_cb.h"
#include "credits.h"
#include "insetref.h"
#include "insetquotes.h"
#include "insetlatex.h"
#include "insetlabel.h"
#include "insetinfo.h"
#include "insetspecialchar.h"
#include "figinset.h"
#include "lyxfunc.h"
#include "latexoptions.h"
#include "lyxfont.h"
#include "minibuffer.h"
#include "combox.h"
#include "bufferlist.h"
#include "filetools.h"
#include "pathstack.h"
#include "filedlg.h"
#include "lyx_gui_misc.h"
#include "LyXView.h" // only because of form_main
#include "lastfiles.h"
#include "FileInfo.h"
#include "lyxscreen.h"
#include "error.h"
#include "syscall.h"
#include "lyxlib.h"
#include "lyxserver.h"
#include "FontLoader.h"
#include "lyxrc.h"
#include "lyxtext.h"
#include "gettext.h"

// $Id: lyx_cb.C,v 1.15 1998/10/21 09:09:49 lasgoutt Exp $

#if !defined(lint) && !defined(WITH_WARNINGS)
static char vcid[] = "$Id: lyx_cb.C,v 1.15 1998/10/21 09:09:49 lasgoutt Exp $";
#endif /* lint */

extern MiniBuffer *minibuffer;
extern Combox *combo_language;
extern BufferList bufferlist;
extern void show_symbols_form();
extern FD_form_main *fd_form_main;
extern FD_form_title *fd_form_title;
extern FD_form_paragraph *fd_form_paragraph;
extern FD_form_character *fd_form_character;
extern FD_form_document *fd_form_document;
extern FD_form_quotes *fd_form_quotes;
extern FD_form_preamble *fd_form_preamble;
extern FD_form_table *fd_form_table;
extern FD_form_print *fd_form_print;
extern FD_form_figure *fd_form_figure;
extern FD_form_screen *fd_form_screen;
extern FD_form_toc *fd_form_toc;
extern FD_form_ref *fd_form_ref;
extern FD_LaTeXOptions *fd_latex_options;
extern FD_form_bullet *fd_form_bullet;

extern BufferView *current_view; // called too many times in this file...

extern void DeleteSimpleCutBuffer(); /* for the cleanup when exiting */

extern int send_fax(LString const &fname, LString const &sendcmd);

extern LyXServer *lyxserver;
extern FontLoader fontloader;

// this should be static, but I need it in buffer.C
bool quitting; // flag, that we are quitting the program
extern bool finished; // all cleanup done just let it run through now.

char ascii_type; /* for selection notify callbacks */

bool scrolling = false;

char updatetimer = 0;

/* whether the work area should get callbacks */
bool input_prohibited = false;

/* the selection possible is needed, that only motion events are
* used, where the bottom press event was on the drawing area too */
bool selection_possible = false;

void InsertCorrectQuote();

/*
   This is the inset locking stuff needed for mathed --------------------

   an inset can simple call LockInset in it's edit call and *ONLY* in it's
   edit call.
   Inset::Edit() can only be called by the main lyx module.

   Then the inset may modify the menu's and/or iconbars.

   Unlocking is either done by LyX or the inset itself with a UnlockInset-call

   During the lock, all button and keyboard events will be modified
   and send to the inset through the following inset-features. Note that
   Inset::InsetUnlock will be called from inside UnlockInset. It is meant
   to contain the code for restoring the menus and things like this.


   virtual void InsetButtonPress(int x, int y, int button);
   virtual void InsetButtonRelease(int x, int y, int button);
   virtual void InsetKeyPress(XKeyEvent *ev);
   virtual void InsetMotionNotify(int x, int y, int state);
   virtual void InsetUnlock();

   If a inset wishes any redraw and/or update it just has to call
   UpdateInset(this).
   It's is completly irrelevant, where the inset is. UpdateInset will
   find it in any paragraph in any buffer.
   Of course the_locking_inset and the insets in the current paragraph/buffer
   are checked first, so no performance problem should occur.

   Hope that's ok for the beginning, Alejandro,
   sorry that I needed so much time,

                  Matthias
   */

void UpdateInset(Inset* inset, bool mark_dirty = true);
/* these functions return 1 if an error occured,
   otherwise 0 */
// Now they work only for updatable insets. [Alejandro 080596]
int LockInset(UpdatableInset* inset);
void ToggleLockedInsetCursor(long x, long y, int asc, int desc);
void FitLockedInsetCursor(long x, long y, int asc, int desc);
int UnlockInset(UpdatableInset* inset);
void LockedInsetStoreUndo(Undo::undo_kind kind);

/* this is for asyncron updating. UpdateInsetUpdateList will be called
   automatically from LyX. Just insert the Inset into the Updatelist */
void UpdateInsetUpdateList();
void PutInsetIntoInsetUpdateList(Inset* inset);

InsetUpdateStruct *InsetUpdateList = NULL;

/*
  -----------------------------------------------------------------------
*/

/* some function prototypes */

void GotoNote();
void OpenStuff();
void ToggleFloat();
void MenuUndo();
void MenuRedo();
void HyphenationPoint();
void HFill();
void Newline();
void ProtectedBlank();
void CopyCB();
int RunLinuxDoc(int, LString const &);
void MenuWrite(Buffer* buf);
void MenuWriteAs(Buffer *buffer);
void MenuReload(Buffer *buf);
void MenuLayoutSave();

unsigned char GetCurrentTextClass()
// Who are we asking?
// Shouldn't this question be directed to the buffer?
// Indeed it should. Asger.
{
return current_view->currentBuffer()->params.textclass;
}

// How should this actually work? Should it prohibit input in all BufferViews,
// or just in the current one? If "just the current one", then it should be
// placed in BufferView. If "all BufferViews" then LyXGUI (I think) should
// run "ProhibitInput" on all LyXViews which will run prohibitInput on all
// BufferViews. Or is it perhaps just the (input in) BufferViews in the
// current LyxView that should be prohibited (Lgb) (This applies to
// "AllowInput" as well.)
void ProhibitInput()
{
input_prohibited = true;
if (current_view->getScreen())
  current_view->getScreen()->HideCursor();

static Cursor cursor;
static bool cursor_undefined = true;

if (cursor_undefined){
  cursor = XCreateFontCursor(fl_display, XC_watch);
  XFlush(fl_display);
  cursor_undefined = false;
}

/* set the cursor to the watch for all forms and the canvas */
XDefineCursor(fl_display, fd_form_main->form_main->window, cursor);
if (fd_form_paragraph->form_paragraph->visible)
  XDefineCursor(fl_display,
         fd_form_paragraph->form_paragraph->window,
         cursor);
if (fd_form_character->form_character->visible)
  XDefineCursor(fl_display,
         fd_form_character->form_character->window,
         cursor);

XFlush(fl_display);
fl_deactivate_all_forms();
}

// Should find a way to move this into BufferView.C
void SetXtermCursor(Window win)
{
static Cursor cursor;
static char cursor_undefined = 1;
if (cursor_undefined){
  cursor = XCreateFontCursor(fl_display, XC_xterm);
  XFlush(fl_display);
  cursor_undefined = 0;
}
XDefineCursor(fl_display, win, cursor);
XFlush(fl_display);
}

void AllowInput()
{
input_prohibited = false;

/* reset the cursor from the watch for all forms and the canvas */

XUndefineCursor(fl_display, fd_form_main->form_main->window);
if (fd_form_paragraph->form_paragraph->visible)
  XUndefineCursor(fl_display,
    fd_form_paragraph->form_paragraph->window);
if (fd_form_character->form_character->visible)
  XUndefineCursor(fl_display,
    fd_form_character->form_character->window);
if (current_view->getWorkArea()->belowmouse)
  SetXtermCursor(fd_form_main->form_main->window);

XFlush(fl_display);
fl_activate_all_forms();
}

void FreeUpdateTimer()
{
/* a real free timer would be better but I don't know
* how to do this with xforms */
updatetimer = 0;
}

void SetUpdateTimer(float time)
{
fl_set_timer(fd_form_main->timer_update, time);
updatetimer = 1;
}

void BeforeChange()
{
current_view->getScreen()->ToggleSelection();
current_view->currentBuffer()->text->ClearSelection();
FreeUpdateTimer();
}

void SmallUpdate(signed char f)
{
current_view->getScreen()->SmallUpdate();
if (current_view->getScreen()->TopCursorVisible()
     != current_view->getScreen()->first){
  current_view->currentBuffer()->update(f);
  return;
}

current_view->fitCursor();
current_view->updateScrollbar();

if (!current_view->currentBuffer()->text->selection)
  current_view->currentBuffer()->text->sel_cursor =
   current_view->currentBuffer()->text->cursor;

if (f==1 || f==-1) {
  if (current_view->currentBuffer()->isLyxClean()) {
   current_view->currentBuffer()->markDirty();
   minibuffer->setTimer(4);
  }
  else {
   current_view->currentBuffer()->markDirty();
  }
}
}

//
// Menu callbacks
//

//
// File menu
//

// should be moved to lyxfunc.C
void MenuWrite(Buffer* buf)
{
XFlush(fl_display);
if (!bufferlist.write(buf)) {
  LString fname = buf->getFileName();
  LString s = MakeAbsPath(fname);
  if (AskQuestion(_("Save failed. Rename and try again?"),
     MakeDisplayPath(s,50),
     _("(If not, document is not saved.)"))) {
   MenuWriteAs(buf);
  }
} else {
  lastfiles->newFile(buf->getFileName());
}
}

// should be moved to BufferView.C
void MenuWriteAs(Buffer *buffer)
{
if (!buffer->text) return;

LString fname = buffer->getFileName();
LString oldname = fname;
LyXFileDlg fileDlg;

ProhibitInput();
fileDlg.SetButton(0, _("Documents"), lyxrc->document_path);
fileDlg.SetButton(1, _("Templates"), lyxrc->template_path);

if (!IsLyXFilename(fname))
  fname += ".lyx";

fname = fileDlg.Select(_("Enter Filename to Save Document as"),
          OnlyPath(fname),
          "*.lyx",
          OnlyFilename(fname));
AllowInput();

if (fname.empty()) {
  minibuffer->Set(_("Canceled."));
  return;
}

// Make sure the absolute filename ends with appropriate suffix
LString s= MakeAbsPath(fname);
if (!IsLyXFilename(s))
  s += ".lyx";

// Same name as we have already?
if (s == oldname) {
  if (!AskQuestion(_("Same name as document already has:"),
     MakeDisplayPath(s,50),
     _("Save anyway?")))
   return;
  // Falls through to name change and save
}
// No, but do we have another file with this name open?
else if (bufferlist.exists(s)) {
  if (AskQuestion(_("Another document with same name open!"),
    MakeDisplayPath(s,50),
    _("Replace with current document?")))
   {
    bufferlist.close(bufferlist.getBuffer(s));

    // Ok, change the name of the buffer, but don't save!
    buffer->setFileName(s);
    buffer->markDirty();

    minibuffer->Set(_("Document renamed to '"),
      MakeDisplayPath(s),
      _("', but not saved..."));
   }
  return;
} // Check whether the file exists
else {
  FileInfo myfile(s);
  if (myfile.isOK() && !AskQuestion(_("Document already exists:"),
        MakeDisplayPath(s,50),
        _("Replace file?")))
   return;
}

// Ok, change the name of the buffer
buffer->setFileName(s);
buffer->markDirty();
// And save
// Small bug: If the save fails, we have irreversible changed the name
// of the document.
MenuWrite(buffer);
}

#if 0
extern bool gsworking();
#endif

int MenuRunLaTeX(Buffer *buffer)
{
int ret;

#if 0
if (gsworking()) {
  WriteAlert(_("Sorry, can't do this while pictures are being rendered."),
      _("Please wait a few seconds for this to finish and try again."),
      _("(or kill runaway gs processes by hand and try again.)"));
  return 1;
}
extern pid_t isp_pid; // from spellchecker.C
if(isp_pid != -1)
{
   WriteAlert(_("Can't do this while the spellchecker is running."),
     _("Stop the spellchecker first."));
   return 1;
}
#endif

if (buffer->isLinuxDoc())
  ret = RunLinuxDoc(1, buffer->getFileName());
else
  ret = buffer->runLaTeX();

if (ret > 0) {
  LString s;
  LString t;
  if (ret == 1) {
   s = _("One error detected");
   t = _("You should try to fix it.");
  } else {
   s += ret;
   s += _(" errors detected.");
   t = _("You should try to fix them.");
  }
  WriteAlert(_("There were errors during the LaTeX run."), s, t);
}
return ret;
}

int MenuRunChktex(Buffer *buffer)
{
int ret;

if (buffer->isLinuxDoc()) {
  WriteAlert(_("Chktex does not work with LinuxDoc."));
  return 0;
} else
  ret = buffer->runChktex();

if (ret >= 0) {
  LString s;
  LString t;
  if (ret == 0) {
   s = _("No warnings found.");
  } else if (ret == 1) {
   s = _("One warning found.");
   t = _("Use 'Edit->Go to Error' to find it.");
  } else {
   s += ret;
   s += _(" warnings found.");
   t = _("Use 'Edit->Go to Error' to find them.");
  }
  WriteAlert(_("Chktex run successfully"), s, t);
} else {
  WriteAlert(_("Error!"),_("It seems chktex does not work."));
}
return ret;
}

int MakeDVIOutput(Buffer *buffer)
{
if (!(buffer->text))
  return 1;

int ret = 0;

LString path = OnlyPath(buffer->getFileName());
if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) {
  path = buffer->tmppath;
}
if (!buffer->isDviClean()) {
  PathPush(path);
  ret = MenuRunLaTeX(buffer);
  PathPop();
}
return ret;
}

/* wait == false means don't wait for termination */
/* wait == true means wait for termination       */
// The bool should be placed last on the argument line. (Lgb)
// Returns false if we fail.
bool RunScript(Buffer *buffer, bool wait,
        LString const & command, LString const & orgname = LString(),
        bool need_shell=true)
{
LString path;
LString cmd;
LString name= orgname;
int result;

if (MakeDVIOutput(buffer) > 0)
  return false;
/* get DVI-Filename */
if (name.empty())
  name = ChangeExtension(buffer->getFileName(),
           ".dvi", true);

path = OnlyPath(name);
if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) {
  path = buffer->tmppath;
}
PathPush(path);

cmd = command + ' ' + SpaceLess(name);
Systemcalls one;

if (need_shell) {
#ifndef __EMX__
  if (!wait)
   cmd += " &";
#else
  // OS/2 cmd.exe has another use for '&'
  if (!wait) {
   LString sh = getenv ("EMXSHELL");
   if (sh.empty())
    sh = getenv ("COMSPEC");
   if (sh.contains("cmd.exe"))
    cmd = "start /min/n " + cmd;
   else
    cmd += " &";
  }
#endif
  // It seems that, if wait is false, we never get back
  // the return code of the command. This means that all
  // the code I added in PrintApplyCB is currently
  // useless...
#ifdef WITH_WARNINGS
#warning What should we do here?
#endif
  minibuffer->Set(_("Executing command:"), cmd);
  result = one.Startscript(Systemcalls::System, cmd);
} else {
  minibuffer->Set(_("Executing command:"), cmd);
  result = one.Startscript(wait ? Systemcalls::Wait
     : Systemcalls::DontWait, cmd);
}
PathPop();
return (result==0);
}

// Returns false if we fail
bool MenuRunDvips(Buffer *buffer, bool wait=false)
{
if (!buffer->text)
  return false;

ProhibitInput();

// Generate dvi file
        if (MakeDVIOutput(buffer) > 0) {
             AllowInput();
  return false;
        }
// Generate postscript file
LString ps = ChangeExtension (buffer->getFileName(),
          ".ps_tmp", true);

LString paper;

char real_papersize = buffer->params.papersize;
if (real_papersize == PAPER_DEFAULT)
  real_papersize = lyxrc->default_papersize;

switch (real_papersize) {
case PAPER_USLETTER:
  paper = "letter";
  break;
case PAPER_A3PAPER:
  paper = "a3";
  break;
case PAPER_A4PAPER:
  paper = "a4";
  break;
case PAPER_A5PAPER:
  paper = "a5";
  break;
case PAPER_B5PAPER:
  paper = "b5";
  break;
case PAPER_EXECUTIVEPAPER:
  paper = "foolscap";
  break;
case PAPER_LEGALPAPER:
  paper = "legal";
  break;
default: /* If nothing else fits, keep an empty value... */
  break;
}

// Make postscript file.
LString command = "dvips -o " + SpaceLess(ps);
// dvips won't accept -t letter -t landscape.  In all other
// cases, include the paper size explicitly.
if (!paper.empty()
     && (real_papersize != PAPER_USLETTER ||
  buffer->params.orientation == ORIENTATION_PORTRAIT))
   command += " -t " + paper;
if (buffer->params.orientation == ORIENTATION_LANDSCAPE)
  command += " -t landscape";
// push directorypath, if necessary
        LString path = OnlyPath(buffer->getFileName());
        if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)){
  path = buffer->tmppath;
        }
        PathPush(path);
bool ret = RunScript(buffer, wait, command);
AllowInput();
        PathPop();
return ret;
}

// Returns false if we fail
bool MenuPreviewPS(Buffer *buffer)
{
if (!buffer->text)
  return false;

// Generate postscript file
if (!MenuRunDvips(buffer, true)) {
  return false;
}

// Start postscript viewer
ProhibitInput();
LString ps = ChangeExtension (buffer->getFileName(),
          ".ps_tmp", true);
// push directorypath, if necessary
        LString path = OnlyPath(buffer->getFileName());
        if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)){
  path = buffer->tmppath;
        }
        PathPush(path);
bool ret = RunScript(buffer, false, lyxrc->view_ps_command, ps);
        PathPop();
AllowInput();
return ret;
}

void MenuFax(Buffer *buffer)
{
if (!buffer->text)
  return;

// Generate postscript file
if (!MenuRunDvips(buffer, true)) {
  return;
}

// Send fax
LString ps = ChangeExtension (buffer->getFileName(), ".ps_tmp", true);
LString path = OnlyPath (buffer->getFileName());
if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) {
  path = buffer->tmppath;
}
PathPush(path);
if (!lyxrc->fax_program.empty()) {
  LString help2 = lyxrc->fax_program;
                help2.subst("$$FName",ps);
                help2 += " &";
                Systemcalls one(Systemcalls::System, help2);
} else
  send_fax(ps,lyxrc->fax_command);
PathPop();
}

// Returns false if we fail
bool MenuPreview(Buffer *buffer)
{
if (!buffer->text)
  return false;

LString paper;

char real_papersize = buffer->params.papersize;
if (real_papersize == PAPER_DEFAULT)
  real_papersize = lyxrc->default_papersize;

switch (real_papersize) {
case PAPER_USLETTER:
  paper = "us";
  break;
case PAPER_A3PAPER:
  paper = "a3";
  break;
case PAPER_A4PAPER:
  paper = "a4";
  break;
case PAPER_A5PAPER:
  paper = "a5";
  break;
case PAPER_B5PAPER:
  paper = "b5";
  break;
case PAPER_EXECUTIVEPAPER:
  paper = "foolscap";
  break;
case PAPER_LEGALPAPER:
  paper = "legal";
  break;
default: /* If nothing else fits, keep the empty value */
  break;
}

if (paper.empty()) {
  if (buffer->params.orientation == ORIENTATION_LANDSCAPE)
   // we HAVE to give a size when the page is in
   // landscape, so use USletter.
   paper = " -paper usr";
} else {
  paper = " -paper " + paper;
  if (buffer->params.orientation == ORIENTATION_LANDSCAPE)
   paper+='r';
}

// push directorypath, if necessary
        LString path = OnlyPath(buffer->getFileName());
        if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)){
  path = buffer->tmppath;
        }
        PathPush(path);
// Run dvi-viewer
LString command = lyxrc->view_dvi_command + paper ;
bool ret = RunScript(buffer, false, command);
        PathPop();
return ret;
}

void MenuMakeLaTeX(Buffer *buffer)
{
if (buffer->text) {
  // Get LaTeX-Filename
  LString s = SpaceLess(ChangeExtension(
      buffer->getFileName(),
      ".tex", false));

  FilePtr myfile(s, FilePtr::read);
  if (myfile() &&
      !AskQuestion(_("File already exists:"),
    MakeDisplayPath(s,50),
    _("Do you want to overwrite the file?"))) {
   minibuffer->Set(_("Canceled"));
   return;
  }

  if (buffer->isLinuxDoc())
   RunLinuxDoc(0, buffer->getFileName());
  else
   buffer->makeLaTeXFile(s, LString(), true);
  minibuffer->Set(_("Nice LaTeX file saved as"),
    MakeDisplayPath(s));
  buffer->markDviDirty();
}
}

void MenuMakeLinuxDoc(Buffer *buffer)
{
if (buffer->text) {

  if (!buffer->isLinuxDoc()) {
   WriteAlert(_("Error!"), _("Document class must be linuxdoc."));
   return;
  }

  // Get LinuxDoc-Filename
  LString s = ChangeExtension (buffer->getFileName(),
          ".sgml", false);

  FilePtr myfile(s, FilePtr::read);
  if (myfile() &&
      !AskQuestion(_("File already exists:"),
    MakeDisplayPath(s,50),
    _("Do you want to overwrite the file?"))) {
   minibuffer->Set(_("Canceled"));
   return;
  }

  minibuffer->Set(_("Building LinuxDoc SGML file `"),
    MakeDisplayPath(s), "'...");

  buffer->makeLinuxDocFile(s, 65);
                buffer->redraw();
  minibuffer->Set(_("LinuxDoc SGML file save as"),
    MakeDisplayPath(s));
}
}

void MenuMakeAscii(Buffer *buffer)
{
if (buffer->text) {
  /* get LaTeX-Filename */
  LString s = ChangeExtension (buffer->getFileName(),
          ".txt", false);

  FilePtr myfile(s, FilePtr::read);
  if (myfile() &&
      !AskQuestion(_("File already exists:"),
    MakeDisplayPath(s,50),
    _("Do you want to overwrite the file?"))) {
   minibuffer->Set(_("Canceled"));
   return;
  }

  buffer->writeFileAscii(s, lyxrc->ascii_linelen);

  minibuffer->Set(_("Ascii file saved as"), MakeDisplayPath(s));
}
}

void MenuPrint(Buffer *buffer)
{
LString input_file;

if (!buffer->text)
  return;

input_file = ChangeExtension(buffer->getFileName(),
         lyxrc->print_file_extension,
         true);
fl_set_input(fd_form_print->input_file, input_file.c_str());

if (fd_form_print->form_print->visible) {
  fl_raise_form(fd_form_print->form_print);
}
else {
  fl_show_form(fd_form_print->form_print,
        FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
        _("Print"));
}
}

void QuitLyX()
{
lyxerr.debug("Running QuitLyX.");

if (!bufferlist.QwriteAll())
  return;

lastfiles->writeFile(lyxrc->lastfiles);

// Set a flag that we do quitting from the program,
// so no refreshes are necessary.
quitting = true;

// close buffers first
bufferlist.closeAll();

// do any other cleanup procedures now
lyxerr.debug("Deleting tmp dir " + system_tempdir);

DestroyLyXTmpDir(system_tempdir);

finished = true;
}

void AutoSave()
// should probably be moved into BufferList (Lgb)
// Perfect target for a thread...
{
if (!current_view->getScreen() || !current_view->available())
  return;

if (current_view->currentBuffer()->isBakClean()
     || current_view->currentBuffer()->isReadonly()) {
  // We don't save now, but we'll try again later
  current_view->getOwner()->resetAutosaveTimer();
  return;
}

minibuffer->Set(_("Autosaving current document..."));

// create autosave filename
LString fname = OnlyPath(current_view->currentBuffer()->getFileName());
fname += "#";
fname += OnlyFilename(current_view->currentBuffer()->getFileName());
fname += "#";

// tmp_ret will be located (usually) in /tmp
// will that be a problem?
LString tmp_ret = tmpnam(NULL);

pid_t pid = fork(); // If you want to debug the autosave
// you should set pid to -1, and comment out the
// fork.
if (pid == 0 || pid == -1) {
  // pid = -1 signifies that lyx was unable
  // to fork. But we will do the save
  // anyway.
  bool failed = false;
  if (!tmp_ret.empty()) {
   current_view->currentBuffer()->writeFile(tmp_ret, 1);
   // assume successful write of tmp_ret
   if (rename(tmp_ret.c_str(), fname.c_str()) == -1) {
    failed = true;
    // most likely couldn't move between filesystems
    // unless write of tmp_ret failed
    // so remove tmp file (if it exists)
    remove(tmp_ret.c_str());
   }
  } else {
   failed = true;
  }

  if (failed) {
   // failed to write/rename tmp_ret so try writing direct
   if (!current_view->currentBuffer()->writeFile(fname,
              1)) {
    // It is dangerous to do this in the child,
    // but safe in the parent, so...
    if (pid == -1)
     minibuffer->Set(_("Autosave Failed!"));
   }
  }
  if (pid == 0) { // we are the child so...
   _exit(0);
  }
}

current_view->currentBuffer()->markBakClean();
current_view->getOwner()->resetAutosaveTimer();
}

//
// (c) CHT Software Service GmbH
// Uwe C. Schroeder
//
// create new file with template
// SERVERCMD !
//
Buffer * NewLyxFile(LString const & filename)
{
// Split argument by :
LString tmpname = filename;
LString name;
tmpname.split(name, ':');
#ifdef __EMX__ // Fix me! lyx_cb.C may not be low level enough to allow this.
if (name.length() == 1 && isalpha((unsigned char) name[0]) &&
     (tmpname.prefixIs("/") || tmpname.prefixIs("\\"))) {
  name += ':';
  name += tmpname.token(':');
  tmpname.split(':');
}
#endif
lyxerr.debug("Arg is " + filename);
lyxerr.debug("Name is " + name);
lyxerr.debug("Template is " + tmpname);

// find a free buffer
Buffer *tmpbuf = bufferlist.newFile(name,tmpname);
if (tmpbuf)
  lastfiles->newFile(tmpbuf->getFileName());
return tmpbuf;
}

// Insert ascii file (if filename is empty, prompt for one)
void InsertAsciiFile(LString const & f, bool asParagraph)
{
LString fname = f;
LyXParagraph *tmppar;
LyXFileDlg fileDlg;

if (!current_view->getScreen()) return;

if (fname.empty()) {
  ProhibitInput();
  fname = fileDlg.Select(_("File to Insert"),
           current_view->getOwner()->currentBuffer()->filepath,
           "*");
    AllowInput();
  if (fname.empty()) return;
}

FileInfo fi(fname);
FilePtr myfile(fname, FilePtr::read);

if (!fi.exist() || !fi.readable() || !myfile()) {
  WriteFSAlert(_("Error! Cannot open specified file:"),
        MakeDisplayPath(fname,50));
  return;
}

tmppar = new LyXParagraph();
tmppar->readSimpleWholeFile(myfile);

// set the end of the string
tmppar->InsertChar(tmppar->last-1,'\0');

// insert the string
current_view->getScreen()->HideCursor();

// clear the selection
BeforeChange();
if (!asParagraph)
  current_view->currentBuffer()->text->InsertStringA(tmppar->text);
else
  current_view->currentBuffer()->text->InsertStringB(tmppar->text);
delete tmppar;
current_view->currentBuffer()->update(1);
}

void MenuShowTableOfContents()
{
TocUpdateCB(NULL, 0);
if (fd_form_toc->form_toc->visible) {
  fl_raise_form(fd_form_toc->form_toc);
} else {
  fl_show_form(fd_form_toc->form_toc,
        FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
        _("Table Of Contents"));
}
}

void MenuInsertLabel(const char *arg)
{
LString label = arg;
ProhibitInput();
//LString label = fl_show_input(_("Enter new label to insert:"),"");
if (label.empty())
  label = askForText(_("Enter new label to insert:"),"");
label.strip();
label.frontStrip();
if (!label.empty()) {
  InsetLabel *new_inset = new InsetLabel;
  new_inset->setContents(label);
  current_view->currentBuffer()->insertInset(new_inset);
}
AllowInput();
}

void MenuInsertRef()
{
RefUpdateCB(NULL, 0);
if (fd_form_ref->form_ref->visible) {
  fl_raise_form(fd_form_ref->form_ref);
} else {
  fl_show_form(fd_form_ref->form_ref,
        FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
        _("Insert Reference"));
}
}

void MenuPasteSelection(char at)
{
if (!current_view->getScreen())
  return;

ascii_type = at;

Atom data_prop = XInternAtom(fl_display,
         "LyX_Primary",
         false);
if (data_prop == None)
  return;
XConvertSelection(fl_display,
     XA_PRIMARY, XA_STRING, data_prop,
     fd_form_main->form_main->window, 0);
XFlush(fl_display);
}

void FootCB(FL_OBJECT*, long)
{
if (!current_view->available())
  return;

minibuffer->Set(_("Inserting Footnote..."));
current_view->getScreen()->HideCursor();
current_view->currentBuffer()->update(-2);
current_view->currentBuffer()->text->InsertFootnoteEnvironment(LyXParagraph::FOOTNOTE);
current_view->currentBuffer()->update(1);
}

void LayoutsCB(int sel, void *)
{
LString tmp;
tmp += sel;
current_view->getOwner()->getLyXFunc()->Dispatch(LFUN_LAYOUTNO,
        tmp.c_str());
}

/*
* SGML support:
* (flag == -1) import SGML file
* (flag == 0) make TeX output
* (flag == 1) make dvi output
*/
int RunLinuxDoc(int flag, LString const & filename)
{
LString name;
LString s2;
LString path;
LString add_flags;

int errorcode = 0;

/* generate a path-less extension name */
name = ChangeExtension (filename, ".sgml", true);
path = OnlyPath (filename);
if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) {
  path = current_view->currentBuffer()->tmppath;
}
PathPush (path);

if (flag != -1) {
  if (!current_view->available())
   return 0;
  current_view->currentBuffer()->makeLinuxDocFile(name,0);
  LYX_PAPER_SIZE ps = (LYX_PAPER_SIZE) current_view->currentBuffer()->params.papersize;
  switch (ps) {
  case PAPER_A4PAPER:  add_flags = "-p a4";     break;
  case PAPER_USLETTER: add_flags = "-p letter"; break;
  default: /* nothing to be done yet ;-) */     break;
  }
}

ProhibitInput();

Systemcalls one;
switch (flag) {
case -1: /* Import file */
  minibuffer->Set(_("Importing LinuxDoc SGML file `"),
    MakeDisplayPath(filename), "'...");
  s2 = "sgml2lyx " + lyxrc->sgml_extra_options + ' '
   + name;
  if (one.Startscript(Systemcalls::System, s2))
   errorcode = 1;
  break;
case 0: /* TeX output asked */
  minibuffer->Set(_("Converting LinuxDoc SGML to TeX file..."));
  s2 = "sgml2latex " + add_flags + " -o tex "
   + lyxrc->sgml_extra_options + ' ' + name;
  if (one.Startscript(Systemcalls::System, s2))
   errorcode = 1;
  break;
case 1: /* dvi output asked */
  minibuffer->Set(_("Converting LinuxDoc SGML to dvi file..."));
  s2 = "sgml2latex " + add_flags + " -o dvi "
   + lyxrc->sgml_extra_options + ' ' + name;
  if (one.Startscript(Systemcalls::System, s2)) {
   errorcode = 1;
  } else
   current_view->currentBuffer()->markDviClean();
  break;
default: /* unknown output */
  break;
}

PathPop();
AllowInput();

        current_view->currentBuffer()->redraw();
return errorcode;
}

void AllFloats(char flag, char figmar)
{
if (!current_view->available())
  return;

LyXCursor cursor = current_view->currentBuffer()->text->cursor;

if (!flag && cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE
     && ((figmar
   && cursor.par->footnotekind != LyXParagraph::FOOTNOTE
   && cursor.par->footnotekind != LyXParagraph::MARGIN)
  || (!figmar
      && cursor.par->footnotekind != LyXParagraph::FIG
      && cursor.par->footnotekind != LyXParagraph::TAB
       && cursor.par->footnotekind != LyXParagraph::WIDE_FIG
       && cursor.par->footnotekind != LyXParagraph::WIDE_TAB
      && cursor.par->footnotekind != LyXParagraph::ALGORITHM)))
  ToggleFloat();
else
  BeforeChange();

LyXCursor tmpcursor = cursor;
cursor.par = tmpcursor.par->ParFromPos(tmpcursor.pos);
cursor.pos = tmpcursor.par->PositionInParFromPos(tmpcursor.pos);

LyXParagraph *par = current_view->currentBuffer()->paragraph;
while (par) {
  if (flag) {
   if (par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE
       && (
        (figmar
         &&
         par->footnotekind != LyXParagraph::FOOTNOTE
         &&
         par->footnotekind !=  LyXParagraph::MARGIN
         )
        ||
        (!figmar
         &&
         par->footnotekind != LyXParagraph::FIG
         &&
         par->footnotekind != LyXParagraph::TAB
         &&
          par->footnotekind != LyXParagraph::WIDE_FIG
          &&
          par->footnotekind != LyXParagraph::WIDE_TAB
          &&
         par->footnotekind != LyXParagraph::ALGORITHM
         )
        )
    ){
    if (par->previous
        && par->previous->footnoteflag !=
        LyXParagraph::CLOSED_FOOTNOTE){ /* should be */
     current_view->currentBuffer()->text->SetCursorIntern(par->previous,
              0);
     current_view->currentBuffer()->text->OpenFootnote();
    }
   }
  }
  else  {
   if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
       && (
        (figmar
         &&
         par->footnotekind != LyXParagraph::FOOTNOTE
         &&
         par->footnotekind !=  LyXParagraph::MARGIN
         )
        ||
        (!figmar
         &&
         par->footnotekind != LyXParagraph::FIG
         &&
         par->footnotekind != LyXParagraph::TAB
         &&
          par->footnotekind != LyXParagraph::WIDE_FIG
          &&
          par->footnotekind != LyXParagraph::WIDE_TAB
          &&
         par->footnotekind != LyXParagraph::ALGORITHM
         )
        )
    ){
    current_view->currentBuffer()->text->SetCursorIntern(par, 0);
    current_view->currentBuffer()->text->CloseFootnote();
   }
  }
  par = par->next;
}

current_view->currentBuffer()->text->SetCursorIntern(cursor.par, cursor.pos);
current_view->redraw();
current_view->fitCursor();
current_view->updateScrollbar();
}

void MenuLayoutCharacter()
{
if (fd_form_character->form_character->visible) {
  fl_raise_form(fd_form_character->form_character);
} else {
  fl_show_form(fd_form_character->form_character,
        FL_PLACE_MOUSE | FL_FREE_SIZE,FL_FULLBORDER,
        _("Character Style"));
}
}

inline void DeactivateParagraphButtons ()
{
fl_deactivate_object (fd_form_paragraph->button_ok);
fl_deactivate_object (fd_form_paragraph->button_apply);
fl_set_object_lcol (fd_form_paragraph->button_ok, FL_INACTIVE);
fl_set_object_lcol (fd_form_paragraph->button_apply, FL_INACTIVE);
}

inline void ActivateParagraphButtons ()
{
fl_activate_object (fd_form_paragraph->button_ok);
fl_activate_object (fd_form_paragraph->button_apply);
fl_set_object_lcol (fd_form_paragraph->button_ok, FL_BLACK);
fl_set_object_lcol (fd_form_paragraph->button_apply, FL_BLACK);
}

inline void DisableParagraphLayout ()
{
        DeactivateParagraphButtons();
fl_deactivate_object (fd_form_paragraph->input_labelwidth);
fl_deactivate_object (fd_form_paragraph->check_lines_top);
fl_deactivate_object (fd_form_paragraph->check_lines_bottom);
fl_deactivate_object (fd_form_paragraph->check_pagebreaks_top);
fl_deactivate_object (fd_form_paragraph->check_pagebreaks_bottom);
fl_deactivate_object (fd_form_paragraph->check_noindent);
fl_deactivate_object (fd_form_paragraph->group_radio_alignment);
fl_deactivate_object (fd_form_paragraph->radio_align_right);
fl_deactivate_object (fd_form_paragraph->radio_align_left);
fl_deactivate_object (fd_form_paragraph->radio_align_block);
fl_deactivate_object (fd_form_paragraph->radio_align_center);
fl_deactivate_object (fd_form_paragraph->input_space_above);
fl_deactivate_object (fd_form_paragraph->input_space_below);
fl_deactivate_object (fd_form_paragraph->choice_space_above);
fl_deactivate_object (fd_form_paragraph->choice_space_below);
fl_deactivate_object (fd_form_paragraph->check_space_above);
fl_deactivate_object (fd_form_paragraph->check_space_below);
}

inline void EnableParagraphLayout ()
{
        ActivateParagraphButtons();
fl_activate_object (fd_form_paragraph->input_labelwidth);
fl_activate_object (fd_form_paragraph->check_lines_top);
fl_activate_object (fd_form_paragraph->check_lines_bottom);
fl_activate_object (fd_form_paragraph->check_pagebreaks_top);
fl_activate_object (fd_form_paragraph->check_pagebreaks_bottom);
fl_activate_object (fd_form_paragraph->check_noindent);
fl_activate_object (fd_form_paragraph->group_radio_alignment);
fl_activate_object (fd_form_paragraph->radio_align_right);
fl_activate_object (fd_form_paragraph->radio_align_left);
fl_activate_object (fd_form_paragraph->radio_align_block);
fl_activate_object (fd_form_paragraph->radio_align_center);
fl_activate_object (fd_form_paragraph->input_space_above);
fl_activate_object (fd_form_paragraph->input_space_below);
fl_activate_object (fd_form_paragraph->choice_space_above);
fl_activate_object (fd_form_paragraph->choice_space_below);
fl_activate_object (fd_form_paragraph->check_space_above);
fl_activate_object (fd_form_paragraph->check_space_below);
}

bool UpdateLayoutParagraph()
{
if (!current_view->getScreen() || !current_view->available()) {
  if (fd_form_paragraph->form_paragraph->visible)
   fl_hide_form(fd_form_paragraph->form_paragraph);
  return false;
}

Buffer * buf = current_view->currentBuffer();

fl_set_input(fd_form_paragraph->input_labelwidth,
       buf->text->cursor.par->GetLabelWidthString().c_str());
fl_set_button(fd_form_paragraph->radio_align_right, 0);
fl_set_button(fd_form_paragraph->radio_align_left, 0);
fl_set_button(fd_form_paragraph->radio_align_center, 0);
fl_set_button(fd_form_paragraph->radio_align_block, 0);

int align = buf->text->cursor.par->GetAlign();
if (align == LYX_ALIGN_LAYOUT)
  align = lyxstyle.Style(buf->params.textclass,
           buf->text->cursor.par->GetLayout())->align;

switch (align) {
case LYX_ALIGN_RIGHT:
  fl_set_button(fd_form_paragraph->radio_align_right, 1);
  break;
case LYX_ALIGN_LEFT:
  fl_set_button(fd_form_paragraph->radio_align_left, 1);
  break;
case LYX_ALIGN_CENTER:
  fl_set_button(fd_form_paragraph->radio_align_center, 1);
  break;
default:
  fl_set_button(fd_form_paragraph->radio_align_block, 1);
  break;
}

fl_set_button(fd_form_paragraph->check_lines_top,
        buf->text->cursor.par->FirstPhysicalPar()->line_top);
fl_set_button(fd_form_paragraph->check_lines_bottom,
        buf->text->cursor.par->FirstPhysicalPar()->line_bottom);
fl_set_button(fd_form_paragraph->check_pagebreaks_top,
        buf->text->cursor.par->FirstPhysicalPar()->pagebreak_top);
fl_set_button(fd_form_paragraph->check_pagebreaks_bottom,
        buf->text->cursor.par->FirstPhysicalPar()->pagebreak_bottom);
fl_set_button(fd_form_paragraph->check_noindent,
        buf->text->cursor.par->FirstPhysicalPar()->noindent);
fl_set_input (fd_form_paragraph->input_space_above, "");

switch (buf->text->cursor.par->FirstPhysicalPar()->added_space_top.kind()) {
case VSpace::NONE:
  fl_set_choice (fd_form_paragraph->choice_space_above,
          1);
  break;
case VSpace::DEFSKIP:
  fl_set_choice (fd_form_paragraph->choice_space_above,
          2);
  break;
case VSpace::SMALLSKIP:
  fl_set_choice (fd_form_paragraph->choice_space_above,
          3);
  break;
case VSpace::MEDSKIP:
  fl_set_choice (fd_form_paragraph->choice_space_above,
          4);
  break;
case VSpace::BIGSKIP:
  fl_set_choice (fd_form_paragraph->choice_space_above,
          5);
  break;
case VSpace::VFILL:
  fl_set_choice (fd_form_paragraph->choice_space_above,
          6);
  break;
case VSpace::LENGTH:
  fl_set_choice (fd_form_paragraph->choice_space_above,
          7);
  fl_set_input  (fd_form_paragraph->input_space_above,
          buf->text->cursor.par->FirstPhysicalPar()->added_space_top.length().asString().c_str());
  break;
}
fl_set_button (fd_form_paragraph->check_space_above,
         buf->text->cursor.par->FirstPhysicalPar()->added_space_top.keep());
fl_set_input (fd_form_paragraph->input_space_below, "");
switch (buf->text->cursor.par->FirstPhysicalPar()->added_space_bottom.kind()) {
case VSpace::NONE:
  fl_set_choice (fd_form_paragraph->choice_space_below,
          1);
  break;
case VSpace::DEFSKIP:
  fl_set_choice (fd_form_paragraph->choice_space_below,
          2);
  break;
case VSpace::SMALLSKIP:
  fl_set_choice (fd_form_paragraph->choice_space_below,
          3);
  break;
case VSpace::MEDSKIP:
  fl_set_choice (fd_form_paragraph->choice_space_below,
          4);
  break;
case VSpace::BIGSKIP:
  fl_set_choice (fd_form_paragraph->choice_space_below,
          5);
  break;
case VSpace::VFILL:
  fl_set_choice (fd_form_paragraph->choice_space_below,
          6);
  break;
case VSpace::LENGTH:
  fl_set_choice (fd_form_paragraph->choice_space_below,
          7);
  fl_set_input  (fd_form_paragraph->input_space_below,
          buf->text->cursor.par->FirstPhysicalPar()->added_space_bottom.length().asString().c_str());
  break;
}
fl_set_button (fd_form_paragraph->check_space_below,
         buf->text->cursor.par->FirstPhysicalPar()->added_space_bottom.keep());

fl_set_button(fd_form_paragraph->check_noindent,
        buf->text->cursor.par->FirstPhysicalPar()->noindent);

if (current_view->currentBuffer()->isReadonly()) {
  DisableParagraphLayout();
} else {
  EnableParagraphLayout();
}
return true;
}

void MenuLayoutParagraph()
{
if (UpdateLayoutParagraph()) {
  if (fd_form_paragraph->form_paragraph->visible) {
   fl_raise_form(fd_form_paragraph->form_paragraph);
  } else {
   fl_show_form(fd_form_paragraph->form_paragraph,
         FL_PLACE_MOUSE | FL_FREE_SIZE,FL_FULLBORDER,
         _("Paragraph Environment"));
  }
}
}

inline
void DeactivateDocumentButtons ()
{
fl_deactivate_object (fd_form_document->button_ok);
fl_deactivate_object (fd_form_document->button_apply);
fl_set_object_lcol (fd_form_document->button_ok, FL_INACTIVE);
fl_set_object_lcol (fd_form_document->button_apply, FL_INACTIVE);
}

inline
void ActivateDocumentButtons ()
{
fl_activate_object (fd_form_document->button_ok);
fl_activate_object (fd_form_document->button_apply);
fl_set_object_lcol (fd_form_document->button_ok, FL_BLACK);
fl_set_object_lcol (fd_form_document->button_apply, FL_BLACK);
}

inline
void DisableDocumentLayout ()
{
        DeactivateDocumentButtons ();
fl_deactivate_object (fd_form_document->group_radio_separation);
fl_deactivate_object (fd_form_document->radio_indent);
fl_deactivate_object (fd_form_document->radio_skip);
fl_deactivate_object (fd_form_document->choice_class);
fl_deactivate_object (fd_form_document->choice_pagestyle);
fl_deactivate_object (fd_form_document->choice_fonts);
fl_deactivate_object (fd_form_document->choice_fontsize);
fl_deactivate_object (fd_form_document->input_float_placement);
fl_deactivate_object (fd_form_document->choice_postscript_driver);
fl_deactivate_object (fd_form_document->choice_inputenc);
fl_deactivate_object (fd_form_document->group_radio_sides);
fl_deactivate_object (fd_form_document->radio_sides_one);
fl_deactivate_object (fd_form_document->radio_sides_two);
fl_deactivate_object (fd_form_document->group_radio_columns);
fl_deactivate_object (fd_form_document->radio_columns_one);
fl_deactivate_object (fd_form_document->radio_columns_two);
fl_deactivate_object (fd_form_document->input_extra);
fl_deactivate_object (fd_form_document->choice_language);
combo_language->deactivate();
fl_deactivate_object (fd_form_document->input_default_skip);
fl_deactivate_object (fd_form_document->choice_default_skip);
fl_deactivate_object (fd_form_document->slider_secnumdepth);
fl_deactivate_object (fd_form_document->slider_tocdepth);
fl_deactivate_object (fd_form_document->choice_spacing);
fl_deactivate_object (fd_form_document->input_spacing);
fl_deactivate_object (fd_form_document->check_use_amsmath);
}

inline
void EnableDocumentLayout ()
{
        ActivateDocumentButtons ();
fl_activate_object (fd_form_document->group_radio_separation);
fl_activate_object (fd_form_document->radio_indent);
fl_activate_object (fd_form_document->radio_skip);
fl_activate_object (fd_form_document->choice_class);
fl_activate_object (fd_form_document->choice_pagestyle);
fl_activate_object (fd_form_document->choice_fonts);
fl_activate_object (fd_form_document->choice_fontsize);
fl_activate_object (fd_form_document->input_float_placement);
fl_activate_object (fd_form_document->choice_postscript_driver);
fl_activate_object (fd_form_document->choice_inputenc);
fl_activate_object (fd_form_document->group_radio_sides);
fl_activate_object (fd_form_document->radio_sides_one);
fl_activate_object (fd_form_document->radio_sides_two);
fl_activate_object (fd_form_document->group_radio_columns);
fl_activate_object (fd_form_document->radio_columns_one);
fl_activate_object (fd_form_document->radio_columns_two);
fl_activate_object (fd_form_document->input_extra);
fl_activate_object (fd_form_document->choice_language);
combo_language->activate();
fl_activate_object (fd_form_document->input_default_skip);
fl_activate_object (fd_form_document->choice_default_skip);
fl_activate_object (fd_form_document->slider_secnumdepth);
fl_activate_object (fd_form_document->slider_tocdepth);
fl_activate_object (fd_form_document->choice_spacing);
fl_activate_object (fd_form_document->input_spacing);
fl_activate_object (fd_form_document->check_use_amsmath);
}

bool UpdateLayoutDocument(BufferParams *params)
{
if (!current_view->getScreen() || !current_view->available()) {
  if (fd_form_document->form_document->visible)
   fl_hide_form(fd_form_document->form_document);
  return false;
}

if (params == NULL)
  params = ¤t_view->currentBuffer()->params;
LyXTextClass *tclass = lyxstyle.TextClass(params->textclass);

fl_set_choice_text(fd_form_document->choice_class,
      lyxstyle.DescOfClass(params->textclass).c_str());
combo_language->select_text(params->language.c_str());

fl_set_choice_text(fd_form_document->choice_fonts,
      params->fonts.c_str());
fl_set_choice_text(fd_form_document->choice_inputenc,
      params->inputenc.c_str());
fl_set_choice_text(fd_form_document->choice_postscript_driver,
      params->graphicsDriver.c_str());

// ale970405+lasgoutt970513
fl_clear_choice(fd_form_document->choice_fontsize);
fl_addto_choice(fd_form_document->choice_fontsize, "default");
fl_addto_choice(fd_form_document->choice_fontsize,
   tclass->opt_fontsize.c_str());
fl_set_choice(fd_form_document->choice_fontsize,
        tclass->opt_fontsize.tokenPos('|', params->fontsize) + 2);

// ale970405+lasgoutt970513
fl_clear_choice(fd_form_document->choice_pagestyle);
fl_addto_choice(fd_form_document->choice_pagestyle, "default");
fl_addto_choice(fd_form_document->choice_pagestyle,
   tclass->opt_pagestyle.c_str());

fl_set_choice(fd_form_document->choice_pagestyle,
        tclass->opt_pagestyle.tokenPos('|', params->pagestyle) + 2);

fl_set_button(fd_form_document->radio_indent, 0);
fl_set_button(fd_form_document->radio_skip, 0);


fl_set_button(fd_form_document->check_use_amsmath, params->use_amsmath);

if (params->paragraph_separation == LYX_PARSEP_INDENT)
  fl_set_button(fd_form_document->radio_indent, 1);
else
  fl_set_button(fd_form_document->radio_skip, 1);

switch (params->getDefSkip().kind()) {
case VSpace::SMALLSKIP:
  fl_set_choice (fd_form_document->choice_default_skip, 1);
  break;
case VSpace::MEDSKIP:
  fl_set_choice (fd_form_document->choice_default_skip, 2);
  break;
case VSpace::BIGSKIP:
  fl_set_choice (fd_form_document->choice_default_skip, 3);
  break;
case VSpace::LENGTH:
  fl_set_choice (fd_form_document->choice_default_skip, 4);
  fl_set_input (fd_form_document->input_default_skip,
         params->getDefSkip().asLyXCommand().c_str());
  break;
default:
  fl_set_choice (fd_form_document->choice_default_skip, 2);
  break;
}

fl_set_button(fd_form_document->radio_sides_one, 0);
fl_set_button(fd_form_document->radio_sides_two, 0);

if (params->sides == 2)
  fl_set_button(fd_form_document->radio_sides_two, 1);
else
  fl_set_button(fd_form_document->radio_sides_one, 1);

fl_set_button(fd_form_document->radio_columns_one, 0);
fl_set_button(fd_form_document->radio_columns_two, 0);

if (params->columns == 2)
  fl_set_button(fd_form_document->radio_columns_two, 1);
else
  fl_set_button(fd_form_document->radio_columns_one, 1);

fl_set_input(fd_form_document->input_spacing, "");
switch (params->spacing.getSpace()) {
case Spacing::Single:
  {
   // \singlespacing
   fl_set_choice(fd_form_document->choice_spacing, 1);
   break;
  }
case Spacing::Onehalf:
  {
   // \onehalfspacing
   fl_set_choice(fd_form_document->choice_spacing, 2);
   break;
  }
case Spacing::Double:
  {
   // \ doublespacing
   fl_set_choice(fd_form_document->choice_spacing, 3);
   break;
  }
case Spacing::Other:
  {
   fl_set_choice(fd_form_document->choice_spacing, 4);
   char sval[20];
   sprintf(sval,"%g",params->spacing.getValue());
   fl_set_input(fd_form_document->input_spacing, sval);
   break;
  }
}

fl_set_counter_value(fd_form_document->slider_secnumdepth,
        params->secnumdepth);
fl_set_counter_value(fd_form_document->slider_tocdepth,
        params->tocdepth);
if (!params->float_placement.empty()) { // buffer local (Lgb)
  fl_set_input(fd_form_document->input_float_placement,
        params->float_placement.c_str());
} else {
  fl_set_input(fd_form_document->input_float_placement, LString("").c_str());
}
if (!params->options.empty())
  fl_set_input(fd_form_document->input_extra,
        params->options.c_str());
else
  fl_set_input(fd_form_document->input_extra,
        LString("").c_str());

if (current_view->currentBuffer()->isLinuxDoc()) {
  // bullets not used in LinuxDoc
  fl_deactivate_object(fd_form_document->button_bullets);
  fl_set_object_lcol(fd_form_document->button_bullets,
       FL_INACTIVE);
} else {
  fl_activate_object(fd_form_document->button_bullets);
  fl_set_object_lcol(fd_form_document->button_bullets,
       FL_BLACK);
}

if (current_view->currentBuffer()->isReadonly()) {
  DisableDocumentLayout();
} else {
  EnableDocumentLayout();
}

return true;
}

void MenuLayoutDocument()
{
if (UpdateLayoutDocument()) {
  if (fd_form_document->form_document->visible) {
   fl_raise_form(fd_form_document->form_document);
  } else {
   fl_show_form(fd_form_document->form_document,
         FL_PLACE_MOUSE | FL_FREE_SIZE,
         FL_FULLBORDER,
         _("Document Layout"));
  }
}
}

bool UpdateLayoutQuotes()
{
bool update = true;
if (!current_view->getScreen()
     || !current_view->available()
     || current_view->currentBuffer()->isReadonly())
  update = false;

if (update) {
  fl_set_choice(fd_form_quotes->choice_quotes_language,
        current_view->currentBuffer()->params.quotes_language + 1);
  fl_set_button(fd_form_quotes->radio_single, 0);
  fl_set_button(fd_form_quotes->radio_double, 0);

  if (current_view->currentBuffer()->params.quotes_times == InsetQuotes::SingleQ)
   fl_set_button(fd_form_quotes->radio_single, 1);
  else
   fl_set_button(fd_form_quotes->radio_double, 1);
} else if (fd_form_quotes->form_quotes->visible) {
  fl_hide_form(fd_form_quotes->form_quotes);
}
return update;
}

void MenuLayoutQuotes()
{
if (UpdateLayoutQuotes()) {
  if (fd_form_quotes->form_quotes->visible) {
   fl_raise_form(fd_form_quotes->form_quotes);
  } else {
   fl_show_form(fd_form_quotes->form_quotes,
         FL_PLACE_MOUSE | FL_FREE_SIZE,
         FL_FULLBORDER,
         _("Quotes"));
  }
}
}

bool UpdateLayoutPreamble()
{
bool update = true;
if (!current_view->getScreen() || ! current_view->available())
     update = false;

if (update) {
  fl_set_input(fd_form_preamble->input_preamble,
       current_view->currentBuffer()->params.preamble.c_str());

  if (current_view->currentBuffer()->isReadonly()) {
    fl_deactivate_object(fd_form_preamble->input_preamble);
    fl_deactivate_object(fd_form_preamble->button_ok);
    fl_deactivate_object(fd_form_preamble->button_apply);
    fl_set_object_lcol(fd_form_preamble->button_ok, FL_INACTIVE);
    fl_set_object_lcol(fd_form_preamble->button_apply, FL_INACTIVE);
  }
  else {
    fl_activate_object(fd_form_preamble->input_preamble);
    fl_activate_object(fd_form_preamble->button_ok);
    fl_activate_object(fd_form_preamble->button_apply);
    fl_set_object_lcol(fd_form_preamble->button_ok, FL_BLACK);
    fl_set_object_lcol(fd_form_preamble->button_apply, FL_BLACK);
  }
} else if (fd_form_preamble->form_preamble->visible) {
  fl_hide_form(fd_form_preamble->form_preamble);
}
return update;
}

void MenuLayoutPreamble()
{
if (UpdateLayoutPreamble()) {
  if (fd_form_preamble->form_preamble->visible) {
   fl_raise_form(fd_form_preamble->form_preamble);
  } else {
   fl_show_form(fd_form_preamble->form_preamble,
         FL_PLACE_MOUSE | FL_FREE_SIZE,
         FL_FULLBORDER,
         _("LaTeX Preamble"));
  }
}
}

void MenuLayoutSave()
{
if (!current_view->getScreen() || ! current_view->available())
     return;

if (AskQuestion(_("Do you want to save the current settings"),
   _("for Character, Document, Paper and Quotes"),
   _("as default for new documents?")))
  current_view->currentBuffer()->saveParamsAsDefaults();
}

/* callbacks added for LinuxDoc support (Pascal André) :
*   - marks and cross references TeX macros
*/

void NoteCB()
{
InsetInfo *new_inset = new InsetInfo();
current_view->currentBuffer()->insertInset(new_inset);
new_inset->Edit(0,0);
//current_view->currentBuffer()->update(-1);
}

void OpenStuff()
{
if (current_view->available()) {
  minibuffer->Set(_("Open/Close..."));
  current_view->getScreen()->HideCursor();
  BeforeChange();
  current_view->currentBuffer()->update(-2);
  current_view->currentBuffer()->text->OpenStuff();
  current_view->currentBuffer()->update(0);
}
}

void ToggleFloat()
{
if (current_view->available()) {
  minibuffer->Set(_("Open/Close..."));
  current_view->getScreen()->HideCursor();
  BeforeChange();
  current_view->currentBuffer()->update(-2);
  current_view->currentBuffer()->text->ToggleFootnote();
  current_view->currentBuffer()->update(0);
}
}

void MenuUndo()
{
/* if (current_view->currentBuffer()->the_locking_inset) {
minibuffer->Set(_("Undo not yet supported in math mode"));
return;
}*/

if (current_view->available()) {
  minibuffer->Set(_("Undo"));
  current_view->getScreen()->HideCursor();
  BeforeChange();
  current_view->currentBuffer()->update(-2);
  if (!current_view->currentBuffer()->text->TextUndo())
   minibuffer->Set(_("No further undo information"));
  else
   current_view->currentBuffer()->update(-1);
}
}

void MenuRedo()
{
if (current_view->currentBuffer()->the_locking_inset) {
  minibuffer->Set(_("Redo not yet supported in math mode"));
  return;
}

if (current_view->available()) {
  minibuffer->Set(_("Redo"));
  current_view->getScreen()->HideCursor();
  BeforeChange();
  current_view->currentBuffer()->update(-2);
  if (!current_view->currentBuffer()->text->TextRedo())
   minibuffer->Set(_("No further redo information"));
  else
   current_view->currentBuffer()->update(-1);
}
}

void HyphenationPoint()
{
if (current_view->available())  {
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  InsetSpecialChar *new_inset =
   new InsetSpecialChar(InsetSpecialChar::HYPHENATION);
  current_view->currentBuffer()->insertInset(new_inset);
  //current_view->currentBuffer()->update(-1);
}
}

void Ldots()
{
if (current_view->available())  {
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  InsetSpecialChar *new_inset =
   new InsetSpecialChar(InsetSpecialChar::LDOTS);
  current_view->currentBuffer()->insertInset(new_inset);
}
}

void EndOfSentenceDot()
{
if (current_view->available())  {
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  InsetSpecialChar *new_inset =
   new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE);
  current_view->currentBuffer()->insertInset(new_inset);
}
}

void Newline()
{
if (current_view->available())  {
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  current_view->currentBuffer()->text->InsertChar(LYX_META_NEWLINE);
  current_view->currentBuffer()->update(-1);
}
}

void ProtectedBlank()
{
if (current_view->available())  {
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  current_view->currentBuffer()->text->InsertChar(LYX_META_PROTECTED_SEPARATOR);
  current_view->currentBuffer()->update(-1);
}
}

void HFill()
{
if (current_view->available())  {
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  current_view->currentBuffer()->text->InsertChar(LYX_META_HFILL);
  current_view->currentBuffer()->update(-1);
}
}

/* -------> These CB's use ToggleFree() as the (one and only?) font-changer.
They also show the current font state. */

static
void ToggleAndShow(LyXFont const &);

void FontSizeCB(LString const & size)
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setGUISize(size);
ToggleAndShow(font);
}

void EmphCB()
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setEmph(LyXFont::TOGGLE);
ToggleAndShow(font);
}

void NounCB()
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setNoun(LyXFont::TOGGLE);
ToggleAndShow(font);
}

void BoldCB()
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setSeries(LyXFont::BOLD_SERIES);
ToggleAndShow(font);
}

void UnderlineCB()
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setUnderbar(LyXFont::TOGGLE);
ToggleAndShow(font);
}

void CodeCB()
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setFamily(LyXFont::TYPEWRITER_FAMILY); // no good
ToggleAndShow(font);
}

void SansCB()
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setFamily(LyXFont::SANS_FAMILY);
ToggleAndShow(font);
}

void RomanCB()
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setFamily(LyXFont::ROMAN_FAMILY);
ToggleAndShow(font);
}

void TexCB()
{
LyXFont font(LyXFont::ALL_IGNORE);
font.setLatex (LyXFont::TOGGLE);
ToggleAndShow(font);
}

void StyleResetCB()
{
LyXFont font(LyXFont::ALL_INHERIT);
ToggleAndShow(font);
}

/* -------> Returns the current font and depth by printing a message. In the
* future perhaps we could try to implement a callback to the button-bar.
* That is, `light' the bold button when the font is currently bold, etc.
*/
LString CurrentState()
{
LString state;
if (current_view->available()) {
  // I think we should only show changes from the default
  // font. (Asger)
  Buffer * buffer = current_view->currentBuffer();
  LyXFont font = buffer->text->real_current_font;
  LyXFont defaultfont = lyxstyle.TextClass(buffer->
        params.textclass)->defaultfont;
  font.reduce(defaultfont);
  state = _("Font: ") + font.stateText();

  int depth = buffer->text->GetDepth();
  if (depth>0)
   state += LString(_(", Depth: ")) + depth;
}
return state;
}

/* -------> Does the actual toggle job of the XxxCB() calls above.
* Also shows the current font state.
*/
static
void ToggleAndShow(LyXFont const & font)
{
if (current_view->available()) {
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  bool toggleall = fl_get_button(fd_form_character->check_toggle_all);
    current_view->currentBuffer()->text->ToggleFree(font, toggleall);
  current_view->currentBuffer()->update(1);
}
// removed since it overrides the ToggleFree Message about the style
// Since Styles are more "High Level" than raw fonts I think the user
// prefers it like this               Matthias
// FontStateShowCB( 0, 0 );
}

void MarginCB(FL_OBJECT *, long)
{
if (current_view->available()) {
  minibuffer->Set(_("Inserting margin note..."));
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  current_view->currentBuffer()->text->InsertFootnoteEnvironment(LyXParagraph::MARGIN);
  current_view->currentBuffer()->update(1);
}
}

void FigureCB(FL_OBJECT *, long)
{
if (fd_form_figure->form_figure->visible) {
  fl_raise_form(fd_form_figure->form_figure);
} else {
  fl_show_form(fd_form_figure->form_figure,
        FL_PLACE_MOUSE, FL_FULLBORDER,
        _("Insert Figure"));
}
}

void TableCB(FL_OBJECT *, long)
{
if (fd_form_table->form_table->visible) {
  fl_raise_form(fd_form_table->form_table);
} else {
  fl_show_form(fd_form_table->form_table,
        FL_PLACE_MOUSE | FL_FREE_SIZE, FL_FULLBORDER,
        _("Insert Table"));
}
}

void CopyEnvironmentCB()
{
if (current_view->available()) {
  current_view->currentBuffer()->text->copyEnvironmentType();
  /* clear the selection, even if mark_set */
  current_view->getScreen()->ToggleSelection();
  current_view->currentBuffer()->text->ClearSelection();
  current_view->currentBuffer()->update(-2);
  minibuffer->Set(_("Paragraph environment type copied"));
}
}

void PasteEnvironmentCB()
{
if (current_view->available()) {
  current_view->currentBuffer()->text->pasteEnvironmentType();
  minibuffer->Set(_("Paragraph environment type set"));
  current_view->currentBuffer()->update(1);
}
}

void CopyCB()
{
if (current_view->available()) {
  current_view->currentBuffer()->text->CopySelection();
  /* clear the selection, even if mark_set */
  current_view->getScreen()->ToggleSelection();
  current_view->currentBuffer()->text->ClearSelection();
  current_view->currentBuffer()->update(-2);
  minibuffer->Set(_("Copy"));
}
}

void CutCB()
{
if (current_view->available()) {
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  current_view->currentBuffer()->text->CutSelection();
  current_view->currentBuffer()->update(1);
  minibuffer->Set(_("Cut"));
}
}

void PasteCB()
{
if (!current_view->available()) return;

minibuffer->Set(_("Paste"));
current_view->getScreen()->HideCursor();
/* clear the selection */
current_view->getScreen()->ToggleSelection();
current_view->currentBuffer()->text->ClearSelection();
current_view->currentBuffer()->update(-2);

/* paste */
current_view->currentBuffer()->text->PasteSelection();
current_view->currentBuffer()->update(1);

/* clear the selection */
current_view->getScreen()->ToggleSelection();
current_view->currentBuffer()->text->ClearSelection();
current_view->currentBuffer()->update(-2);
}

void MeltCB(FL_OBJECT *, long)
{
if (!current_view->available()) return;

minibuffer->Set(_("Melt"));
current_view->getScreen()->HideCursor();
BeforeChange();
current_view->currentBuffer()->update(-2);
current_view->currentBuffer()->text->MeltFootnoteEnvironment();
current_view->currentBuffer()->update(1);
}

// Change environment depth.
// if decInc == 0, depth change taking mouse button number into account
// if decInc == 1, increment depth
// if decInc == -1, decrement depth
void DepthCB(FL_OBJECT *ob, long decInc)
{
int button = 1;

/* When decInc != 0, fake a mouse button. This allows us to
   implement depth-plus and depth-min commands. RVDK_PATCH_5. */
/* check out wether ob is defined, too (Matthias) */
if ( decInc < 0 )
  button = 0;
else if (!decInc && ob) {
  button = fl_get_button_numb(ob);
}

if (current_view->available()) {
  current_view->getScreen()->HideCursor();
  current_view->currentBuffer()->update(-2);
  if (button == 1)
   current_view->currentBuffer()->text->IncDepth();
  else
   current_view->currentBuffer()->text->DecDepth();
  current_view->currentBuffer()->update(1);
  minibuffer->Set(_("Changed environment depth"
      " (in possible range, maybe not)"));
}
}

// This is both GUI and LyXFont dependent. Don't know where to put it. (Asger)
// Well, it's mostly GUI dependent, so I guess it will stay here. (Asger)
LyXFont UserFreeFont()
{
LyXFont font(LyXFont::ALL_IGNORE);
int pos;

pos = fl_get_choice(fd_form_character->choice_family);
switch(pos) {
case 1: font.setFamily(LyXFont::IGNORE_FAMILY); break;
case 2: font.setFamily(LyXFont::ROMAN_FAMILY); break;
case 3: font.setFamily(LyXFont::SANS_FAMILY); break;
case 4: font.setFamily(LyXFont::TYPEWRITER_FAMILY); break;
case 5: font.setFamily(LyXFont::INHERIT_FAMILY); break;
}

pos = fl_get_choice(fd_form_character->choice_series);
switch(pos) {
case 1: font.setSeries(LyXFont::IGNORE_SERIES); break;
case 2: font.setSeries(LyXFont::MEDIUM_SERIES); break;
case 3: font.setSeries(LyXFont::BOLD_SERIES); break;
case 4: font.setSeries(LyXFont::INHERIT_SERIES); break;
}

pos = fl_get_choice(fd_form_character->choice_shape);
switch(pos) {
case 1: font.setShape(LyXFont::IGNORE_SHAPE); break;
case 2: font.setShape(LyXFont::UP_SHAPE); break;
case 3: font.setShape(LyXFont::ITALIC_SHAPE); break;
case 4: font.setShape(LyXFont::SLANTED_SHAPE); break;
case 5: font.setShape(LyXFont::SMALLCAPS_SHAPE); break;
case 6: font.setShape(LyXFont::INHERIT_SHAPE); break;
}

pos = fl_get_choice(fd_form_character->choice_size);
switch(pos) {
case 1: font.setSize(LyXFont::IGNORE_SIZE); break;
case 2: font.setSize(LyXFont::SIZE_TINY); break;
case 3: font.setSize(LyXFont::SIZE_SCRIPT); break;
case 4: font.setSize(LyXFont::SIZE_FOOTNOTE); break;
case 5: font.setSize(LyXFont::SIZE_SMALL); break;
case 6: font.setSize(LyXFont::SIZE_NORMAL); break;
case 7: font.setSize(LyXFont::SIZE_LARGE); break;
case 8: font.setSize(LyXFont::SIZE_LARGER); break;
case 9: font.setSize(LyXFont::SIZE_LARGEST); break;
case 10: font.setSize(LyXFont::SIZE_HUGE); break;
case 11: font.setSize(LyXFont::SIZE_HUGER); break;
case 12: font.setSize(LyXFont::INCREASE_SIZE); break;
case 13: font.setSize(LyXFont::DECREASE_SIZE); break;
case 14: font.setSize(LyXFont::INHERIT_SIZE); break;
}

pos = fl_get_choice(fd_form_character->choice_bar);
switch(pos) {
case 1: font.setEmph(LyXFont::IGNORE);
  font.setUnderbar(LyXFont::IGNORE);
  font.setNoun(LyXFont::IGNORE);
  font.setLatex(LyXFont::IGNORE);
  break;
case 2: font.setEmph(LyXFont::TOGGLE); break;
case 3: font.setUnderbar(LyXFont::TOGGLE); break;
case 4: font.setNoun(LyXFont::TOGGLE); break;
case 5: font.setLatex(LyXFont::TOGGLE); break;
case 6: font.setEmph(LyXFont::INHERIT);
  font.setUnderbar(LyXFont::INHERIT);
  font.setNoun(LyXFont::INHERIT);
  font.setLatex(LyXFont::INHERIT);
  break;
}

pos = fl_get_choice(fd_form_character->choice_color);
switch(pos) {
case 1: font.setColor(LyXFont::IGNORE_COLOR); break;
case 2: font.setColor(LyXFont::NONE); break;
case 3: font.setColor(LyXFont::BLACK); break;
case 4: font.setColor(LyXFont::WHITE); break;
case 5: font.setColor(LyXFont::RED); break;
case 6: font.setColor(LyXFont::GREEN); break;
case 7: font.setColor(LyXFont::BLUE); break;
case 8: font.setColor(LyXFont::CYAN); break;
--> --------------------

--> maximum size reached

--> --------------------

¤ Dauer der Verarbeitung: 0.100 Sekunden (vorverarbeitet) ¤

Download des Quellennavigators
Download des sprechenden Kalenders
in der Quellcodebibliothek suchen

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.