]> git.lyx.org Git - lyx.git/blobdiff - src/lyxfunc.C
Various fixes, removed "default" language, inserted new lyxrc tag
[lyx.git] / src / lyxfunc.C
index 9a2c0783e4eaa8ea0cbdfa41ae151e5eaedf258a..abda8b84dd46b20279170baecd893418c1716679 100644 (file)
 
 #include <config.h>
 
-#ifdef HAVE_SSTREAM
-#include <sstream>
-using std::istringstream;
-#else
-#include <strstream>
-#endif
+#include "Lsstream.h"
 
 #include <time.h>
 #include <locale.h>
@@ -28,10 +23,12 @@ using std::istringstream;
 #pragma implementation
 #endif
 
+#include "version.h"
 #include "lyxlookup.h"
 #include "kbmap.h"
 #include "lyxfunc.h"
 #include "bufferlist.h"
+#include "ColorHandler.h"
 #include "lyxserver.h"
 #include "lyx.h"
 #include "intl.h"
@@ -41,21 +38,25 @@ using std::istringstream;
 #include "insets/inseturl.h"
 #include "insets/insetlatexaccent.h"
 #include "insets/insettoc.h"
-#include "insets/insetlof.h"
-#include "insets/insetloa.h"
-#include "insets/insetlot.h"
 #include "insets/insetref.h"
 #include "insets/insetparent.h"
 #include "insets/insetindex.h"
 #include "insets/insetinclude.h"
 #include "insets/insetbib.h"
+#include "insets/insetcite.h"
 #include "insets/insettext.h"
-//#include "insets/insetnumber.h"
 #include "insets/insetert.h"
+#include "insets/insetexternal.h"
 #include "insets/insetgraphics.h"
 #include "insets/insetfoot.h"
+#include "insets/insetmarginal.h"
+#include "insets/insetminipage.h"
+#include "insets/insetfloat.h"
+#include "insets/insetlist.h"
+#include "insets/insettabular.h"
+#include "insets/insettheorem.h"
+#include "insets/insetcaption.h"
 #include "mathed/formulamacro.h"
-#include "toolbar.h"
 #include "spellchecker.h" // RVDK_PATCH_5
 #include "minibuffer.h"
 #include "vspace.h"
@@ -77,8 +78,14 @@ using std::istringstream;
 #include "layout.h"
 #include "WorkArea.h"
 #include "lyxfr1.h"
-#include "menus.h"
 #include "bufferview_funcs.h"
+#include "frontends/Dialogs.h"
+#include "frontends/Toolbar.h"
+#include "frontends/Menubar.h"
+#include "FloatList.h"
+#include "exporter.h"
+#include "FontLoader.h"
+#include "TextCache.h"
 
 using std::pair;
 using std::endl;
@@ -86,48 +93,36 @@ using std::endl;
 extern bool cursor_follows_scrollbar;
 
 extern void InsertAsciiFile(BufferView *, string const &, bool);
-extern void math_insert_symbol(char const *);
-extern Bool math_insert_greek(char const); // why "Bool"?
+extern void math_insert_symbol(string const &);
+extern bool math_insert_greek(char);
 extern BufferList bufferlist;
 extern LyXServer * lyxserver;
-extern short greek_kb_flag;
-extern FD_form_toc * fd_form_toc;
+extern int greek_kb_flag;
 extern bool selection_possible;
 
 extern kb_keymap * toplevel_keymap;
 
-extern void MenuWrite(Buffer *);
-extern void MenuWriteAs(Buffer *);
+extern bool MenuWrite(Buffer *);
+extern bool MenuWriteAs(Buffer *);
 extern int  MenuRunLaTeX(Buffer *);
 extern int  MenuBuildProg(Buffer *);
 extern int  MenuRunChktex(Buffer *);
-extern bool CreatePostscript(Buffer *, bool);
 extern void MenuPrint(Buffer *);
 extern void MenuSendto();
 extern void QuitLyX();
 extern void MenuFax(Buffer *);
-extern void MenuExport(Buffer *, string const &);
-extern void MenuPasteSelection(char at);
+extern void show_symbols_form(LyXFunc *);
+
 extern LyXAction lyxaction;
 // (alkis)
 extern tex_accent_struct get_accent(kb_action action);
 
 extern void AutoSave(BufferView *);
-extern void SetUpdateTimer(float timer = 0.3);
-extern void FreeUpdateTimer();
-extern bool PreviewDVI(Buffer *);
-extern bool PreviewPostscript(Buffer *);
-extern void MenuInsertLabel(char const *);
-extern void MenuInsertRef();
+extern void MenuInsertLabel(string const &);
 extern void MenuLayoutCharacter();
 extern void MenuLayoutParagraph();
-extern void MenuLayoutDocument();
-extern void MenuLayoutPaper();
-extern void MenuLayoutTable(int flag);
-extern void MenuLayoutQuotes();
 extern void MenuLayoutPreamble();
 extern void MenuLayoutSave();
-extern void bulletForm();
 
 extern Buffer * NewLyxFile(string const &);
 extern void LoadLyXFile(string const &);
@@ -164,28 +159,144 @@ void LyXFunc::moveCursorUpdate(bool selecting)
        if (selecting || owner->view()->text->mark_set) {
                owner->view()->text->SetSelection();
                owner->view()->toggleToggle();
-               owner->view()->update(0);
-       } else {
-               owner->view()->update(-2); // this IS necessary
-               // (Matthias) 
        }
-
+       owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
        owner->view()->showCursor();
        
        /* ---> Everytime the cursor is moved, show the current font state. */
        // should this too me moved out of this func?
-       //owner->getMiniBuffer()->Set(CurrentState());
+       //owner->showState();
        owner->view()->setState();
 }
 
 
+int LyXFunc::processKeySym(KeySym keysym, unsigned int state) 
+{
+       string argument;
+       
+       if (lyxerr.debugging(Debug::KEY)) {
+               char * tmp = XKeysymToString(keysym);
+               string stm = (tmp ? tmp : "");
+               lyxerr << "KeySym is "
+                      << stm
+                      << "["
+                      << keysym << "]"
+                      << endl;
+       }
+       // Do nothing if we have nothing (JMarc)
+       if (keysym == NoSymbol) {
+               lyxerr[Debug::KEY] << "Empty kbd action (probably composing)"
+                                  << endl;
+               //return 0;
+               return FL_PREEMPT;
+       }
+       
+       // this function should be used always [asierra060396]
+       UpdatableInset * tli = owner->view()->the_locking_inset;
+       if (owner->view()->available() && tli && (keysym == XK_Escape)) {
+               if (tli == tli->GetLockingInset()) {
+                       owner->view()->unlockInset(tli);
+                       owner->view()->text->CursorRight(owner->view());
+                       moveCursorUpdate(false);
+                       owner->showState();
+               } else {
+                       tli->UnlockInsetInInset(owner->view(),
+                                               tli->GetLockingInset(),true);
+               }
+               //return 0;
+               return FL_PREEMPT;
+       }
+
+       // Can we be sure that this will work for all X-Windows
+       // implementations? (Lgb)
+       // This code snippet makes lyx ignore some keys. Perhaps
+       // all of them should be explictly mentioned?
+       if((keysym >= XK_Shift_L && keysym <= XK_Hyper_R)
+          || keysym == XK_Mode_switch || keysym == 0x0)
+               return 0;
+
+       // Do a one-deep top-level lookup for
+       // cancel and meta-fake keys. RVDK_PATCH_5
+       cancel_meta_seq.reset();
+
+       int action = cancel_meta_seq.addkey(keysym, state
+                                           &(ShiftMask|ControlMask
+                                             |Mod1Mask)); 
+
+       // When not cancel or meta-fake, do the normal lookup. 
+       // Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards.
+       // Mostly, meta_fake_bit = 0. RVDK_PATCH_5.
+       if ( (action != LFUN_CANCEL) && (action != LFUN_META_FAKE) ) {
+
+               // remove Caps Lock and Mod2 as a modifiers
+               action = keyseq.addkey(keysym,
+                                      (state | meta_fake_bit)
+                                      &(ShiftMask|ControlMask
+                                        |Mod1Mask));      
+       }
+       // Dont remove this unless you know what you are doing.
+       meta_fake_bit = 0;
+               
+       if (action == 0) action = LFUN_PREFIX;
+
+       if (lyxerr.debugging(Debug::KEY)) {
+               string buf;
+               keyseq.print(buf);
+               lyxerr << "Key ["
+                      << action << "]["
+                      << buf << "]"
+                      << endl;
+       }
+
+       // already here we know if it any point in going further
+       // why not return already here if action == -1 and
+       // num_bytes == 0? (Lgb)
+
+       if(keyseq.length > 1 || keyseq.length < -1) {
+               string buf;
+               keyseq.print(buf);
+               owner->getMiniBuffer()->Set(buf);
+       }
+
+       if (action == -1) {
+               if (keyseq.length < -1) { // unknown key sequence...
+                       string buf;
+                       LyXBell();
+                       keyseq.print(buf);
+                       owner->getMiniBuffer()->Set(_("Unknown sequence:"), buf);
+                       return 0;
+               }
+       
+               char isochar = keyseq.getiso();
+               if (!(state & ControlMask) &&
+                   !(state & Mod1Mask) &&
+                   (isochar && keysym < 0xF000)) {
+                       argument += isochar;
+               }
+               if (argument.empty()) {
+                       lyxerr.debug() << "Empty argument!" << endl;
+                       // This can`t possibly be of any use
+                       // so we`ll skip the dispatch.
+                       return 0;
+               }
+       }
+
+        bool tmp_sc = show_sc;
+       show_sc = false;
+       Dispatch(action, argument);
+       show_sc = tmp_sc;
+       
+       return 0;
+} 
+
+
+#if 0
 int LyXFunc::processKeyEvent(XEvent * ev)
 {
        char s_r[10];
+       KeySym keysym_return = 0;
        string argument;
        XKeyEvent * keyevent = &ev->xkey;
-       KeySym keysym_return;
-
        int num_bytes = LyXLookupString(ev, s_r, 10, &keysym_return);
        s_r[num_bytes] = '\0';
 
@@ -199,7 +310,8 @@ int LyXFunc::processKeyEvent(XEvent * ev)
                       << " and num_bytes is "
                       << num_bytes
                       << " the string returned is \""
-                      << s_r << '\"' << endl;
+                      << s_r << '\"'
+                      << endl;
        }
        // Do nothing if we have nothing (JMarc)
        if (num_bytes == 0 && keysym_return == NoSymbol) {
@@ -213,12 +325,12 @@ int LyXFunc::processKeyEvent(XEvent * ev)
        if (owner->view()->available() && tli && (keysym_return==XK_Escape)) {
                if (tli == tli->GetLockingInset()) {
                        owner->view()->unlockInset(tli);
-                       owner->view()->text->CursorRight();
+                       owner->view()->text->CursorRight(owner->view());
                        moveCursorUpdate(false);
-                       owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+                       owner->showState();
                } else {
                        tli->UnlockInsetInInset(owner->view(),
-                                               tli->GetLockingInset());
+                                               tli->GetLockingInset(),true);
                }
                return 0;
        }
@@ -260,8 +372,10 @@ int LyXFunc::processKeyEvent(XEvent * ev)
                keyseq.print(buf);
                lyxerr << "Key ["
                       << action << "]["
-                      << buf << "]["
-                      << num_bytes << "]" << endl;
+                      << buf << "]"
+                      << "["
+                      << num_bytes << "]"
+                      << endl;
        }
 
        // already here we know if it any point in going further
@@ -295,18 +409,20 @@ int LyXFunc::processKeyEvent(XEvent * ev)
                        // so we`ll skip the dispatch.
                        return 0;
                }
-       } else
+       }
+       else
                if (action == LFUN_SELFINSERT) {
                        argument = s_r[0];
                }
-    
+
         bool tmp_sc = show_sc;
        show_sc = false;
-       Dispatch(action, argument.c_str());
+       Dispatch(action, argument);
        show_sc = tmp_sc;
        
        return 0;
 } 
+#endif
 
 
 LyXFunc::func_status LyXFunc::getStatus(int ac) const
@@ -318,13 +434,13 @@ LyXFunc::func_status LyXFunc::getStatus(int ac) const
        
        if (lyxaction.isPseudoAction(ac)) 
                action = lyxaction.retrieveActionArg(ac, argument);
-       else 
+       else
                action = static_cast<kb_action>(ac);
        
        if (action == LFUN_UNKNOWN_ACTION) {
                setErrorMessage(N_("Unknown action"));
                return LyXFunc::Unknown;
-       } 
+       }
        
        // Check whether we need a buffer
        if (!lyxaction.funcHasFlag(action, LyXAction::NoBuffer)) {
@@ -344,49 +460,27 @@ LyXFunc::func_status LyXFunc::getStatus(int ac) const
                        setErrorMessage(N_("Command not allowed with"
                                           "out any document open"));
                        flag |= LyXFunc::Disabled;
+                       return flag;
                }
        }
 
-       if (flag & LyXFunc::Disabled)
-               return flag;
-
        // I would really like to avoid having this switch and rather try to
        // encode this in the function itself.
         static bool noLaTeX = lyxrc.latex_command == "none";
         bool disable = false;
         switch (action) {
-       case LFUN_PREVIEW:
-               disable = noLaTeX || lyxrc.view_dvi_command == "none";
-               break;  
-       case LFUN_PREVIEWPS: 
-               disable = noLaTeX || lyxrc.view_ps_command == "none";
-               break;
-       case LFUN_RUNLATEX:
-       case LFUN_RUNDVIPS:
-               disable = noLaTeX;
-               break;
        case LFUN_MENUPRINT:
                disable = noLaTeX || lyxrc.print_command == "none";
                break;
        case LFUN_FAX:
-               disable = noLaTeX || lyxrc.fax_command == "none"; 
+               disable = noLaTeX || lyxrc.fax_command == "none";
                break;
        case LFUN_IMPORT:
-               if (argument == "latex")
+               if (argument == "latex" || argument == "noweb")
                        disable = lyxrc.relyx_command == "none";
-               if (argument == "linuxdoc")
+               else if (argument == "linuxdoc")
                        disable = lyxrc.linuxdoc_to_lyx_command == "none";
                break;
-       case LFUN_EXPORT:
-               if (argument == "dvi" || argument == "postscript")
-                       disable = noLaTeX;
-               if (argument == "html")
-                       disable = lyxrc.html_command == "none";
-               if (argument == "html-linuxdoc")
-                       disable = lyxrc.linuxdoc_to_html_command == "none";
-               if (argument == "html-docbook")
-                       disable = lyxrc.docbook_to_html_command == "none";
-               break;
        case LFUN_UNDO:
                disable = buf->undostack.empty();
                break;
@@ -399,8 +493,63 @@ LyXFunc::func_status LyXFunc::getStatus(int ac) const
        case LFUN_RUNCHKTEX:
                disable = lyxrc.chktex_command == "none";
                break;
-       case LFUN_LAYOUT_TABLE:
-               disable = ! owner->view()->text->cursor.par->table;
+       case LFUN_BUILDPROG:
+               disable = (lyxrc.literate_command == "none" 
+                          || ! buf->isLiterate());
+               break;
+
+       case LFUN_LAYOUT_TABULAR:
+               disable = true;
+               if (owner->view()->the_locking_inset) {
+                       disable = (owner->view()->the_locking_inset->LyxCode() != Inset::TABULAR_CODE) &&
+                               !owner->view()->the_locking_inset->GetFirstLockingInsetOfType(Inset::TABULAR_CODE);
+               }
+               break;
+
+       case LFUN_TABULAR_FEATURE:
+               disable = true;
+               if (owner->view()->the_locking_inset) {
+                       func_status ret = LyXFunc::Disabled;
+                       if (owner->view()->the_locking_inset->LyxCode() == Inset::TABULAR_CODE) {
+                               ret = static_cast<InsetTabular *>
+                                       (owner->view()->the_locking_inset)->
+                                       getStatus(argument);
+                       } else if (owner->view()->the_locking_inset->GetFirstLockingInsetOfType(Inset::TABULAR_CODE)) {
+                               ret = static_cast<InsetTabular *>
+                                       (owner->view()->the_locking_inset->
+                                       GetFirstLockingInsetOfType(Inset::TABULAR_CODE))->
+                                       getStatus(argument);
+                       }
+                       flag |= ret;
+                       disable = false;
+               } else {
+                   static InsetTabular inset(owner->buffer(), 1, 1);
+                   func_status ret;
+
+                   disable = true;
+                   ret = inset.getStatus(argument);
+                   if ((ret & LyXFunc::ToggleOn) ||
+                       (ret & LyXFunc::ToggleOff))
+                       flag |= LyXFunc::ToggleOff;
+               }
+               break;
+
+       case LFUN_VC_REGISTER:
+               disable = buf->lyxvc.inUse();
+               break;
+       case LFUN_VC_CHECKIN:
+               disable = !buf->lyxvc.inUse() || buf->isReadonly();
+               break;
+       case LFUN_VC_CHECKOUT:
+               disable = !buf->lyxvc.inUse() || !buf->isReadonly();
+               break;
+       case LFUN_VC_REVERT:
+       case LFUN_VC_UNDO:
+       case LFUN_VC_HISTORY:
+               disable = !buf->lyxvc.inUse();
+               break;
+       case LFUN_REF_BACK:
+               disable = owner->view()->NoSavedPositions();
                break;
        default:
                break;
@@ -410,7 +559,13 @@ LyXFunc::func_status LyXFunc::getStatus(int ac) const
 
        if (buf) {
                func_status box = LyXFunc::ToggleOff;
-               LyXFont font = owner->view()->text->real_current_font;
+               LyXFont font;
+               if (owner->view()->the_locking_inset &&
+                   owner->view()->the_locking_inset->getLyXText(owner->view()))
+                   font = owner->view()->the_locking_inset->
+                       getLyXText(owner->view())->real_current_font;
+               else
+                   font = owner->view()->text->real_current_font;
                switch (action) {
                case LFUN_EMPH:
                        if (font.emph() == LyXFont::ON)
@@ -439,25 +594,26 @@ LyXFunc::func_status LyXFunc::getStatus(int ac) const
 }
 
 
-string LyXFunc::Dispatch(string const & s) 
+string const LyXFunc::Dispatch(string const & s) 
 {
        // Split command string into command and argument
-       string cmd, line = frontStrip(s);
+       string cmd;
+       string line = frontStrip(s);
        string arg = strip(frontStrip(split(line, cmd, ' ')));
 
-       return Dispatch(lyxaction.LookupFunc(cmd.c_str()), arg.c_str());
+       return Dispatch(lyxaction.LookupFunc(cmd), arg);
 }
 
 
-string LyXFunc::Dispatch(int ac,
-                        char const * do_not_use_this_arg)
+string const LyXFunc::Dispatch(int ac,
+                        string const & do_not_use_this_arg)
 {
        string argument;
        kb_action action;
         
         // we have not done anything wrong yet.
         errorstat = false;
-       dispatch_buffer.clear();
+       dispatch_buffer.erase();
        
        // if action is a pseudo-action, we need the real action
        if (lyxaction.isPseudoAction(ac)) {
@@ -468,7 +624,7 @@ string LyXFunc::Dispatch(int ac,
                        argument = tmparg;
        } else {
                action = static_cast<kb_action>(ac);
-               if (do_not_use_this_arg)
+               if (!do_not_use_this_arg.empty())
                        argument = do_not_use_this_arg; // except here
        }
     
@@ -478,10 +634,10 @@ string LyXFunc::Dispatch(int ac,
                owner->view()->hideCursor();
 
        // We cannot use this function here
-       if (getStatus(action) & Disabled)
+       if (getStatus(ac) & Disabled)
                goto exit_with_message;
 
-       commandshortcut.clear();
+       commandshortcut.erase();
        
        if (lyxrc.display_shortcuts && show_sc) {
                if (action != LFUN_SELFINSERT) {
@@ -497,7 +653,7 @@ string LyXFunc::Dispatch(int ac,
                                // this is better
                                pseudoaction = 
                                        lyxaction.searchActionArg(action,
-                                                                 argument.c_str());
+                                                                 argument);
 
                                if (pseudoaction == -1) {
                                        pseudoaction = action;
@@ -533,11 +689,11 @@ string LyXFunc::Dispatch(int ac,
        // the math inset [asierra060396]
        if (owner->view()->available() &&
            owner->view()->the_locking_inset) {
-               if (action > 1
-                   || (action == LFUN_UNKNOWN_ACTION
-                       && keyseq.length >= -1)) {
-                       if (action == LFUN_UNKNOWN_ACTION
-                           && argument.empty()) {
+               UpdatableInset::RESULT result;
+               if ((action > 1) || ((action == LFUN_UNKNOWN_ACTION) &&
+                                    (keyseq.length >= -1)))
+               {
+                       if ((action==LFUN_UNKNOWN_ACTION) && argument.empty()){
                                argument = keyseq.getiso();
                        }
                        // Undo/Redo pre 0.13 is a bit tricky for insets.
@@ -545,15 +701,15 @@ string LyXFunc::Dispatch(int ac,
                                int slx, sly;
                                UpdatableInset * inset = 
                                        owner->view()->the_locking_inset;
-                               inset->GetCursorPos(slx, sly);
+                               inset->GetCursorPos(owner->view(), slx, sly);
                                owner->view()->unlockInset(inset);
                                owner->view()->menuUndo();
-                               if (owner->view()->text->cursor.par->
-                                   IsInset(owner->view()->text->cursor.pos)) {
+                               if (owner->view()->text->cursor.par()->
+                                   IsInset(owner->view()->text->cursor.pos())) {
                                        inset = static_cast<UpdatableInset*>(
-                                               owner->view()->text->cursor.par->
+                                               owner->view()->text->cursor.par()->
                                                GetInset(owner->view()->text->
-                                                        cursor.pos));
+                                                        cursor.pos()));
                                } else {
                                        inset = 0;
                                }
@@ -564,20 +720,21 @@ string LyXFunc::Dispatch(int ac,
                                int slx, sly;
                                UpdatableInset * inset = owner->view()->
                                        the_locking_inset;
-                               inset->GetCursorPos(slx, sly);
+                               inset->GetCursorPos(owner->view(), slx, sly);
                                owner->view()->unlockInset(inset);
                                owner->view()->menuRedo();
                                inset = static_cast<UpdatableInset*>(
-                                       owner->view()->text->cursor.par->
+                                       owner->view()->text->cursor.par()->
                                        GetInset(owner->view()->text->
-                                                cursor.pos));
+                                                cursor.pos()));
                                if (inset)
                                        inset->Edit(owner->view(),slx,sly,0); 
                                return string();
-                       } else if (owner->view()->the_locking_inset->
+                       } else if (((result=owner->view()->the_locking_inset->
                                   LocalDispatch(owner->view(), action,
-                                                argument) ==
-                                  UpdatableInset::DISPATCHED)
+                                                argument)) ==
+                                  UpdatableInset::DISPATCHED) ||
+                                  (result == UpdatableInset::DISPATCHED_NOUPDATE))
                                return string();
                        else {
                                setMessage(N_("Text mode"));
@@ -585,26 +742,29 @@ string LyXFunc::Dispatch(int ac,
                                case LFUN_UNKNOWN_ACTION:
                                case LFUN_BREAKPARAGRAPH:
                                case LFUN_BREAKLINE:
-                                       owner->view()->text->CursorRight();
+                                       owner->view()->text->CursorRight(owner->view());
                                        owner->view()->setState();
-                                       owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+                                       owner->showState();
                                        break;
                                case LFUN_RIGHT:
-                                       if (!owner->view()->text->cursor.par->isRightToLeftPar()) {
-                                               owner->view()->text->CursorRight();
+                                       if (!owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params)) {
+                                               owner->view()->text->CursorRight(owner->view());
                                                moveCursorUpdate(false);
-                                               owner->getMiniBuffer()->
-                                                       Set(CurrentState(owner->view()));
+                                               owner->showState();
                                        }
                                        return string();
                                case LFUN_LEFT: 
-                                       if (owner->view()->text->cursor.par->isRightToLeftPar()) {
-                                               owner->view()->text->CursorRight();
+                                       if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params)) {
+                                               owner->view()->text->CursorRight(owner->view());
                                                moveCursorUpdate(false);
-                                               owner->getMiniBuffer()->
-                                                       Set(CurrentState(owner->view()));
+                                               owner->showState();
                                        }
                                        return string();
+                               case LFUN_DOWN:
+                                       owner->view()->text->CursorDown(owner->view());
+                                       moveCursorUpdate(false);
+                                       owner->showState();
+                                       return string();
                                default:
                                        break;
                                }
@@ -630,11 +790,11 @@ string LyXFunc::Dispatch(int ac,
 
                if (!searched_string.empty() &&
                    ((action == LFUN_WORDFINDBACKWARD) ? 
-                    ltCur->SearchBackward(searched_string.c_str()) :
-                    ltCur->SearchForward(searched_string.c_str()))) {
+                    ltCur->SearchBackward(owner->view(), searched_string) :
+                    ltCur->SearchForward(owner->view(), searched_string))) {
 
                        // ??? What is that ???
-                       owner->view()->update(-2);
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
 
                        // ??? Needed ???
                        // clear the selection (if there is any) 
@@ -643,7 +803,7 @@ string LyXFunc::Dispatch(int ac,
 
                        // Move cursor so that successive C-s 's will not stand in place. 
                        if( action == LFUN_WORDFINDFORWARD ) 
-                               owner->view()->text->CursorRightOneWord();
+                               owner->view()->text->CursorRightOneWord(owner->view());
                        owner->view()->text->FinishUndo();
                        moveCursorUpdate(false);
 
@@ -662,7 +822,7 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_PREFIX:
        {
                if (owner->view()->available()) {
-                       owner->view()->update(-2);
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                }
                string buf;
                keyseq.print(buf, true);
@@ -680,7 +840,7 @@ string LyXFunc::Dispatch(int ac,
                meta_fake_bit = 0;
                if(owner->view()->available())
                        // cancel any selection
-                       Dispatch(LFUN_MARK_OFF, 0);
+                       Dispatch(LFUN_MARK_OFF);
                setMessage(N_("Cancel"));
                break;
 
@@ -709,8 +869,8 @@ string LyXFunc::Dispatch(int ac,
                
        case LFUN_APPENDIX:
                if (owner->view()->available()) {
-                       owner->view()->text->toggleAppendix();
-                       owner->view()->update(1);
+                       owner->view()->text->toggleAppendix(owner->view());
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                }
                break;
 
@@ -732,16 +892,20 @@ string LyXFunc::Dispatch(int ac,
                break;
                
        case LFUN_MENUWRITE:
-               owner->getMiniBuffer()->Set(_("Saving document"),
-                                           MakeDisplayPath(owner->buffer()->fileName()),
-                                           "...");
-               MenuWrite(owner->buffer());
-               //owner->getMiniBuffer()->
-               //      Set(_("Document saved as"),
-               //          MakeDisplayPath(owner->buffer()->fileName()));
-               //} else {
-               //owner->getMiniBuffer()->Set(_("Save failed!"));
-               //}
+               if (!owner->buffer()->isUnnamed()) {
+                       owner->getMiniBuffer()->Set(_("Saving document"),
+                                                   MakeDisplayPath(owner->buffer()->fileName()),
+                                                   "...");
+                       MenuWrite(owner->buffer());
+                       //owner->getMiniBuffer()-> {
+                       //      Set(_("Document saved as"),
+                       //          MakeDisplayPath(owner->buffer()->fileName()));
+                       //} else {
+                       //owner->getMiniBuffer()->Set(_("Save failed!"));
+                       //}
+               } else {
+                       MenuWriteAs(owner->buffer());
+               }
                break;
                
        case LFUN_MENUWRITEAS:
@@ -752,16 +916,12 @@ string LyXFunc::Dispatch(int ac,
                reloadBuffer();
                break;
                
-       case LFUN_PREVIEW:
-               PreviewDVI(owner->buffer());
-               break;
-                       
-       case LFUN_PREVIEWPS:
-               PreviewPostscript(owner->buffer());
+       case LFUN_UPDATE:
+               Exporter::Export(owner->buffer(), argument, true);
                break;
-               
-       case LFUN_RUNLATEX:
-               MenuRunLaTeX(owner->buffer());
+
+       case LFUN_PREVIEW:
+               Exporter::Preview(owner->buffer(), argument);
                break;
                
         case LFUN_BUILDPROG:
@@ -771,111 +931,94 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_RUNCHKTEX:
                MenuRunChktex(owner->buffer());
                break;
-               
-       case LFUN_RUNDVIPS:
-               CreatePostscript(owner->buffer(), false);
-               break;
-               
+                               
        case LFUN_MENUPRINT:
-               MenuPrint(owner->buffer());
+               owner->getDialogs()->showPrint();
                break;
-               
+
        case LFUN_FAX:
                MenuFax(owner->buffer());
                break;
                        
        case LFUN_EXPORT:
-               MenuExport(owner->buffer(), argument);
+               Exporter::Export(owner->buffer(), argument, false);
                break;
 
        case LFUN_IMPORT:
-       {
-               //needs argument as string
-               string imtyp = argument;
-               
-               // latex
-               if (imtyp == "latex") {
-                       doImportLaTeX(false);
-               }
-               // ascii
-               else if (imtyp == "ascii") {
-                       doImportASCII(false);
-               } else if (imtyp == "asciiparagraph") {
-                       doImportASCII(true);
-                       // noweb
-               } else if (imtyp == "noweb") {
-                       doImportLaTeX(true);
-               } else if (imtyp == "linuxdoc") {
-                       doImportLinuxDoc();
-               } else {
-                       setErrorMessage(string(N_("Unknown import type: "))
-                                       + imtyp);
-               }
+               doImport(argument);
                break;
-       }
                
        case LFUN_QUIT:
                QuitLyX();
                break;
                
        case LFUN_TOCVIEW:
-               TocUpdateCB(0, 0);
-               if (fd_form_toc->form_toc->visible) {
-                       fl_raise_form(fd_form_toc->form_toc);
-               } else {
-                       static int ow = -1, oh;
-                       fl_show_form(fd_form_toc->form_toc,
-                                    FL_PLACE_MOUSE |
-                                    FL_FREE_SIZE, FL_FULLBORDER,
-                                    _("Table of Contents"));
-                       if (ow < 0) {
-                               ow = fd_form_toc->form_toc->w;
-                               oh = fd_form_toc->form_toc->h;
-                       }
-                       fl_set_form_minsize(fd_form_toc->form_toc, ow, oh);
-               }
+       case LFUN_LOFVIEW:
+       case LFUN_LOTVIEW:
+       case LFUN_LOAVIEW:
+       {
+               InsetCommandParams p;
+               
+               if( action == LFUN_TOCVIEW )
+                       p.setCmdName( "tableofcontents" );
+               else if( action == LFUN_LOAVIEW )
+                       p.setCmdName( "listofalgorithms" );
+               else if( action == LFUN_LOFVIEW )
+                       p.setCmdName( "listoffigures" );
+               else
+                       p.setCmdName( "listoftables" );
+
+               owner->getDialogs()->createTOC( p.getAsString() );
                break;
-               
+       }       
+
        case LFUN_TOC_INSERT:
-       {
-               Inset * new_inset = new InsetTOC(owner->buffer());
-               owner->view()->insertInset(new_inset, "Standard", true);
-               break;
-       }
-       
-       case LFUN_LOF_INSERT:
-       {
-               Inset * new_inset = new InsetLOF(owner->buffer());
-               owner->view()->insertInset(new_inset, "Standard", true);
-               break;
-       }
-       
        case LFUN_LOA_INSERT:
-       {
-               Inset * new_inset = new InsetLOA(owner->buffer());
-               owner->view()->insertInset(new_inset, "Standard", true);
-               break;
-       }
-
+       case LFUN_LOF_INSERT:
        case LFUN_LOT_INSERT:
        {
-               Inset * new_inset = new InsetLOT(owner->buffer());
-               owner->view()->insertInset(new_inset, "Standard", true);
+               InsetCommandParams p;
+               
+               if( action == LFUN_TOC_INSERT )
+                       p.setCmdName( "tableofcontents" );
+               else if( action == LFUN_LOA_INSERT )
+                       p.setCmdName( "listofalgorithms" );
+               else if( action == LFUN_LOF_INSERT )
+                       p.setCmdName( "listoffigures" );
+               else
+                       p.setCmdName( "listoftables" );
+
+               Inset * inset = new InsetTOC( p );
+               if( !owner->view()->insertInset( inset, "Standard", true ) )
+                       delete inset;
                break;
        }
                
-       case LFUN_TABLE:
-               Table();
+       case LFUN_DIALOG_TABULAR_INSERT:
+               owner->getDialogs()->showTabularCreate();
                break;
                
+       case LFUN_TABULAR_FEATURE:
+       case LFUN_SCROLL_INSET:
+               // this is not handled here as this funktion is only aktive
+               // if we have a locking_inset and that one is (or contains)
+               // a tabular-inset
+               break;
+
        case LFUN_FIGURE:
                Figure();
                break;
 
-       case LFUN_INSERT_GRAPHICS:
+       case LFUN_INSET_GRAPHICS:
        {
                Inset * new_inset = new InsetGraphics;
-               owner->view()->insertInset(new_inset);
+               if (!owner->view()->insertInset(new_inset)) {
+                       delete new_inset;
+               } else {
+                       // this is need because you don't use a inset->Edit()
+                       owner->view()->updateInset(new_inset, true);
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               }
                break;
        }
        
@@ -899,8 +1042,7 @@ string LyXFunc::Dispatch(int ac,
                static LyXFindReplace FR_;
                FR_.StartSearch(owner->view());
        }
-       
-               break;
+       break;
                
        case LFUN_PASTE:
                owner->view()->paste();
@@ -911,10 +1053,10 @@ string LyXFunc::Dispatch(int ac,
        {
                bool asPara = false;
                if (argument == "paragraph") asPara = true;
-               MenuPasteSelection(asPara);
-               break;
+               owner->view()->pasteClipboard(asPara);
        }
-
+       break;
+       
        case LFUN_CUT:
                owner->view()->cut();
                break;
@@ -940,17 +1082,19 @@ string LyXFunc::Dispatch(int ac,
                if (owner->view()->removeAutoInsets()) {
                        owner->view()->redraw();
                        owner->view()->fitCursor();
-                       owner->view()->updateScrollbar();
+                       //owner->view()->updateScrollbar();
                }
                break;
                
        case LFUN_GOTONOTE:
                owner->view()->gotoNote();
                break;
-               
+
+#ifndef NEW_INSETS
        case LFUN_OPENSTUFF:
                owner->view()->openStuff();
                break;
+#endif
                
        case LFUN_HYPHENATION:
                owner->view()->hyphenationPoint();
@@ -986,29 +1130,31 @@ string LyXFunc::Dispatch(int ac,
                
        case LFUN_FREE:
                Free(owner->view());
+               owner->view()->setState();
+               owner->showState();
                break;
                
        case LFUN_TEX:
                Tex(owner->view());
                owner->view()->setState();
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
-               
+#ifndef NEW_INSETS             
        case LFUN_MELT:
                Melt(owner->view());
                break;
-               
+#endif
        case LFUN_RECONFIGURE:
                Reconfigure(owner->view());
                break;
-
+#ifndef NEW_INSETS
        case LFUN_FOOTMELT:
                if (owner->view()->available()
                    && !owner->view()->text->selection
-                   && owner->view()->text->cursor.par->footnoteflag
+                   && owner->view()->text->cursor.par()->footnoteflag
                    != LyXParagraph::NO_FOOTNOTE)
                        { // only melt footnotes with FOOTMELT, not margins etc
-                               if(owner->view()->text->cursor.par->footnotekind == LyXParagraph::FOOTNOTE)
+                               if(owner->view()->text->cursor.par()->footnotekind == LyXParagraph::FOOTNOTE)
                                        Melt(owner->view());
                        }
                else
@@ -1019,16 +1165,56 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_MARGINMELT:
                if (owner->view()->available()
                    && !owner->view()->text->selection
-                   && owner->view()->text->cursor.par->footnoteflag
+                   && owner->view()->text->cursor.par()->footnoteflag
                    != LyXParagraph::NO_FOOTNOTE) {
                        // only melt margins
-                       if(owner->view()->text->cursor.par->footnotekind == LyXParagraph::MARGIN)
+                       if(owner->view()->text->cursor.par()->footnotekind == LyXParagraph::MARGIN)
                                Melt(owner->view());
                } else
                        Margin(owner->view()); 
                owner->view()->setState();
                break;
-               
+#endif
+       case LFUN_HELP_COPYRIGHT:
+               owner->getDialogs()->showCopyright();
+               break;
+
+       case LFUN_HELP_CREDITS:
+               owner->getDialogs()->showCredits();
+               break;
+
+        case LFUN_HELP_OPEN: {
+               string arg = argument;
+               if (arg.empty()) {
+                       setErrorMessage(N_("Missing argument"));
+                       break;
+               }
+               ProhibitInput(owner->view());
+               string fname = i18nLibFileSearch("doc", arg, "lyx");
+               if (fname.empty()) {
+                       lyxerr << "LyX: unable to find documentation file `"
+                              << arg << "'. Bad installation?" << endl;
+                       AllowInput(owner->view());
+                       break;
+               }
+               owner->getMiniBuffer()->Set(_("Opening help file"),
+                                           MakeDisplayPath(fname),"...");
+               owner->view()->buffer(bufferlist.loadLyXFile(fname,false));
+               AllowInput(owner->view());
+               break;
+        }
+
+       case LFUN_HELP_VERSION: 
+               ProhibitInput(owner->view());
+               fl_show_message((string(_("LyX Version ")) + LYX_VERSION 
+                                + _(" of ") + LYX_RELEASE).c_str(),
+                               (_("Library directory: ")
+                                + MakeDisplayPath(system_lyxdir)).c_str(),
+                               (_("User directory: ") 
+                                + MakeDisplayPath(user_lyxdir)).c_str());
+               AllowInput(owner->view());
+               break;
+
                // --- version control -------------------------------
        case LFUN_VC_REGISTER:
        {
@@ -1073,6 +1259,11 @@ string LyXFunc::Dispatch(int ac,
        
        // --- buffers ----------------------------------------
 
+        case LFUN_SWITCHBUFFER:
+                owner->view()->buffer(bufferlist.getBuffer(argument));
+               break;
+
+
        case LFUN_FILE_INSERT:
        {
                MenuInsertLyXFile(argument);
@@ -1119,7 +1310,7 @@ string LyXFunc::Dispatch(int ac,
                Dispatch(int(LFUN_LAYOUT), 
                         textclasslist.NameOfLayout(owner->view()
                                                    ->buffer()->params.textclass,
-                                                   sel).c_str());
+                                                   sel));
                return string();
        }
                
@@ -1154,47 +1345,47 @@ string LyXFunc::Dispatch(int ac,
                if (current_layout != layout.second) {
                        owner->view()->hideCursor();
                        current_layout = layout.second;
-                       owner->view()->update(-2);
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                        owner->view()->text->
-                               SetLayout(layout.second);
-                       owner->getToolbar()->combox->
-                               select(owner->view()->
-                                      text->cursor.par->
-                                      GetLayout() + 1);
-                       owner->view()->update(1);
+                               SetLayout(owner->view(), layout.second);
+                       owner->setLayout(layout.second);
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                        owner->view()->setState();
                }
        }
        break;
 
        case LFUN_LAYOUT_DOCUMENT:
-               MenuLayoutDocument();
+               owner->getDialogs()->showLayoutDocument();
                break;
                
        case LFUN_LAYOUT_PARAGRAPH:
+#ifdef USE_OLD_PARAGRAPH_LAYOUT
                MenuLayoutParagraph();
+#else
+               owner->getDialogs()->showLayoutParagraph();
+#endif
                break;
                
        case LFUN_LAYOUT_CHARACTER:
                MenuLayoutCharacter();
                break;
-               
-       case LFUN_LAYOUT_TABLE:
-       {
-               int flag = 0;
-               if (argument == "true") flag = 1;
-               MenuLayoutTable(flag);
-       }
-       break;
-               
-       case LFUN_LAYOUT_PAPER:
-               MenuLayoutPaper();
-               break;
-               
-       case LFUN_LAYOUT_QUOTES:
-               MenuLayoutQuotes();
-               break;
-               
+
+       case LFUN_LAYOUT_TABULAR:
+           if (owner->view()->the_locking_inset) {
+               if (owner->view()->the_locking_inset->LyxCode()==Inset::TABULAR_CODE) {
+                   InsetTabular * inset = static_cast<InsetTabular *>
+                       (owner->view()->the_locking_inset);
+                   inset->OpenLayoutDialog(owner->view());
+               } else if (owner->view()->the_locking_inset->
+                          GetFirstLockingInsetOfType(Inset::TABULAR_CODE)!=0) {
+                   InsetTabular * inset = static_cast<InsetTabular *>(
+                       owner->view()->the_locking_inset->GetFirstLockingInsetOfType(Inset::TABULAR_CODE));
+                   inset->OpenLayoutDialog(owner->view());
+               }
+           }
+           break;
+
        case LFUN_LAYOUT_PREAMBLE:
                MenuLayoutPreamble();
                break;
@@ -1204,60 +1395,58 @@ string LyXFunc::Dispatch(int ac,
                break;
                
        case LFUN_DROP_LAYOUTS_CHOICE:
-               owner->getToolbar()->combox->Show();
+               owner->getToolbar()->openLayoutList();
                break;
 
        case LFUN_LANGUAGE:
-       {
                Lang(owner->view(), argument);
                owner->view()->setState();
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
-       }
+               owner->showState();
                break;
 
        case LFUN_EMPH:
                Emph(owner->view());
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
-               
+
        case LFUN_BOLD:
                Bold(owner->view());
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_NOUN:
                Noun(owner->view());
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_CODE:
                Code(owner->view());
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_SANS:
                Sans(owner->view());
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_ROMAN:
                Roman(owner->view());
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_DEFAULT:
                StyleReset(owner->view());
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_UNDERLINE:
                Underline(owner->view());
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_FONT_SIZE:
                FontSize(owner->view(), argument);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_FONT_STATE:
@@ -1265,60 +1454,53 @@ string LyXFunc::Dispatch(int ac,
                break;
                
        case LFUN_UPCASE_WORD:
-               owner->view()->update(-2);
-               FreeUpdateTimer();
-               owner->view()->text->ChangeWordCase(LyXText::text_uppercase);
-               owner->view()->update(1);
-               SetUpdateTimer();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->ChangeWordCase(owner->view(),
+                                                   LyXText::text_uppercase);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                break;
                
        case LFUN_LOWCASE_WORD:
-               owner->view()->update(-2);
-               FreeUpdateTimer();
-               owner->view()->text->ChangeWordCase(LyXText::text_lowercase);
-               owner->view()->update(1);
-               SetUpdateTimer();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->ChangeWordCase(owner->view(),
+                                                   LyXText::text_lowercase);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                break;
                
        case LFUN_CAPITALIZE_WORD:
-               owner->view()->update(-2);
-               FreeUpdateTimer();
-               owner->view()->text->ChangeWordCase(LyXText::text_capitalization);
-               owner->view()->update(1);
-               SetUpdateTimer();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->ChangeWordCase(owner->view(),
+                                                   LyXText::text_capitalization);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                break;
                
        case LFUN_INSERT_LABEL:
-               MenuInsertLabel(argument.c_str());
+               MenuInsertLabel(argument);
                break;
                
-       case LFUN_INSERT_REF:
-               MenuInsertRef();
-               break;
-               
-       case LFUN_REFTOGGLE:
-       {
-               InsetRef * inset = 
-                       static_cast<InsetRef*>(getInsetByCode(Inset::REF_CODE));
-               if (inset) {
-                       if (inset->getFlag() == InsetRef::REF)
-                               inset->setFlag(InsetRef::PAGE_REF);
-                       else
-                               inset->setFlag(InsetRef::REF);
-                       owner->view()->updateInset(inset, true);
+       case LFUN_REF_INSERT:
+               if (argument.empty()) {
+                       InsetCommandParams p("ref");
+               owner->getDialogs()->createRef(p.getAsString());
                } else {
-                       setErrorMessage(N_("No cross-reference to toggle"));
+                       InsetCommandParams p;
+                       p.setFromString(argument);
+
+                       InsetRef * inset = new InsetRef(p);
+                       if (!owner->view()->insertInset(inset))
+                               delete inset;
+                       else
+                               owner->view()->updateInset(inset, true);
                }
-       }
-       break;
-       
-       case LFUN_REFBACK:
+               break;
+
+       case LFUN_REF_BACK:
        {
                owner->view()->restorePosition();
        }
        break;
 
-       case LFUN_REFGOTO:
+       case LFUN_REF_GOTO:
        {
                string label(argument);
                if (label.empty()) {
@@ -1330,13 +1512,16 @@ string LyXFunc::Dispatch(int ac,
                
                if (!label.empty()) {
                        owner->view()->savePosition();
-                       owner->view()->gotoLabel(label.c_str());
+                       if (!owner->view()->gotoLabel(label))
+                               WriteAlert(_("Error"), 
+                                          _("Couldn't find this label"), 
+                                          _("in current document."));
                }
        }
        break;
                
        case LFUN_MENU_OPEN_BY_NAME:
-               owner->getMenus()->openByName(argument);
+               owner->getMenubar()->openByName(argument);
                break; // RVDK_PATCH_5
                
        case LFUN_SPELLCHECK:
@@ -1348,27 +1533,27 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_RIGHT:
        {
                LyXText * tmptext = owner->view()->text;
-               bool is_rtl = tmptext->cursor.par->isRightToLeftPar();
+               bool is_rtl = tmptext->cursor.par()->isRightToLeftPar(owner->buffer()->params);
                if(!tmptext->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-2);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                if (is_rtl)
-                       tmptext->CursorLeft();
-               if (tmptext->cursor.pos < tmptext->cursor.par->Last()
-                   && tmptext->cursor.par->GetChar(tmptext->cursor.pos)
+                       tmptext->CursorLeft(owner->view(), false);
+               if (tmptext->cursor.pos() < tmptext->cursor.par()->Last()
+                   && tmptext->cursor.par()->GetChar(tmptext->cursor.pos())
                    == LyXParagraph::META_INSET
-                   && tmptext->cursor.par->GetInset(tmptext->cursor.pos)
-                   && tmptext->cursor.par->GetInset(tmptext->cursor.pos)->Editable() == Inset::HIGHLY_EDITABLE){
-                       Inset * tmpinset = tmptext->cursor.par->GetInset(tmptext->cursor.pos);
+                   && tmptext->cursor.par()->GetInset(tmptext->cursor.pos())
+                   && tmptext->cursor.par()->GetInset(tmptext->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE){
+                       Inset * tmpinset = tmptext->cursor.par()->GetInset(tmptext->cursor.pos());
                        setMessage(tmpinset->EditMessage());
                        tmpinset->Edit(owner->view(), 0, 0, 0);
                        break;
                }
                if (!is_rtl)
-                       tmptext->CursorRight();
+                       tmptext->CursorRight(owner->view(), false);
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
        }
        break;
                
@@ -1377,342 +1562,332 @@ string LyXFunc::Dispatch(int ac,
                // This is soooo ugly. Isn`t it possible to make
                // it simpler? (Lgb)
                LyXText * txt = owner->view()->text;
-               bool is_rtl = txt->cursor.par->isRightToLeftPar();
+               bool is_rtl = txt->cursor.par()->isRightToLeftPar(owner->buffer()->params);
                if(!txt->mark_set) owner->view()->beforeChange();
-               owner->view()->update(-2);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                if (!is_rtl)
-                       txt->CursorLeft();
-               if (txt->cursor.pos < txt->cursor.par->Last()
-                   && txt->cursor.par->GetChar(txt->cursor.pos)
+                       txt->CursorLeft(owner->view(), false);
+               if (txt->cursor.pos() < txt->cursor.par()->Last()
+                   && txt->cursor.par()->GetChar(txt->cursor.pos())
                    == LyXParagraph::META_INSET
-                   && txt->cursor.par->GetInset(txt->cursor.pos)
-                   && txt->cursor.par->GetInset(txt->cursor.pos)->Editable() == Inset::HIGHLY_EDITABLE) {
-                       Inset * tmpinset = txt->cursor.par->GetInset(txt->cursor.pos);
+                   && txt->cursor.par()->GetInset(txt->cursor.pos())
+                   && txt->cursor.par()->GetInset(txt->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE) {
+                       Inset * tmpinset = txt->cursor.par()->GetInset(txt->cursor.pos());
                        setMessage(tmpinset->EditMessage());
+                       LyXFont font = txt->GetFont(owner->view()->buffer(),
+                                                   txt->cursor.par(),
+                                                   txt->cursor.pos());
                        tmpinset->Edit(owner->view(),
-                                      tmpinset->width(owner->view()->painter(),
-                                                      txt->GetFont(txt->cursor.par,
-                                                                   txt->cursor.pos)),
-                                      0, 0);
+                                      tmpinset->x() +
+                                      tmpinset->width(owner->view(),font),
+                                      tmpinset->descent(owner->view(),font),
+                                      0);
                        break;
                }
                if  (is_rtl)
-                       txt->CursorRight();
+                       txt->CursorRight(owner->view(), false);
 
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
        }
        break;
                
        case LFUN_UP:
                if(!owner->view()->text->mark_set) owner->view()->beforeChange();
-               owner->view()->update(-3);
-               owner->view()->text->CursorUp();
+               owner->view()->update(BufferView::UPDATE);
+               owner->view()->text->CursorUp(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_DOWN:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-3);
-               owner->view()->text->CursorDown();
+               owner->view()->update(BufferView::UPDATE);
+               owner->view()->text->CursorDown(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
 
        case LFUN_UP_PARAGRAPH:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-3);
-               owner->view()->text->CursorUpParagraph();
+               owner->view()->update(BufferView::UPDATE);
+               owner->view()->text->CursorUpParagraph(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_DOWN_PARAGRAPH:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-3);
-               owner->view()->text->CursorDownParagraph();
+               owner->view()->update(BufferView::UPDATE);
+               owner->view()->text->CursorDownParagraph(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_PRIOR:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-3);
+               owner->view()->update(BufferView::UPDATE);
                owner->view()->cursorPrevious();
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_NEXT:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-3);
+               owner->view()->update(BufferView::UPDATE);
                owner->view()->cursorNext();
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_HOME:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-2);
-               owner->view()->text->CursorHome();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorHome(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_END:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-2);
-               owner->view()->text->CursorEnd();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorEnd(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
+       case LFUN_SHIFT_TAB:
        case LFUN_TAB:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-2);
-               owner->view()->text->CursorTab();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorTab(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_WORDRIGHT:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-2);
-               if (owner->view()->text->cursor.par->isRightToLeftPar())
-                       owner->view()->text->CursorLeftOneWord();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
+                       owner->view()->text->CursorLeftOneWord(owner->view());
                else
-                       owner->view()->text->CursorRightOneWord();
+                       owner->view()->text->CursorRightOneWord(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_WORDLEFT:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-2);
-               if (owner->view()->text->cursor.par->isRightToLeftPar())
-                       owner->view()->text->CursorRightOneWord();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
+                       owner->view()->text->CursorRightOneWord(owner->view());
                else
-                       owner->view()->text->CursorLeftOneWord();
+                       owner->view()->text->CursorLeftOneWord(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_BEGINNINGBUF:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-2);
-               owner->view()->text->CursorTop();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorTop(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_ENDBUF:
                if(!owner->view()->text->mark_set)
                        owner->view()->beforeChange();
-               owner->view()->update(-2);
-               owner->view()->text->CursorBottom();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorBottom(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
 
       
                /* cursor selection ---------------------------- */
        case LFUN_RIGHTSEL:
-               owner->view()->update(-2);
-               if (owner->view()->text->cursor.par->isRightToLeftPar())
-                       owner->view()->text->CursorLeft();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
+                       owner->view()->text->CursorLeft(owner->view());
                else
-                       owner->view()->text->CursorRight();
+                       owner->view()->text->CursorRight(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_LEFTSEL:
-               owner->view()->update(-2);
-               if (owner->view()->text->cursor.par->isRightToLeftPar())
-                       owner->view()->text->CursorRight();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
+                       owner->view()->text->CursorRight(owner->view());
                else
-                       owner->view()->text->CursorLeft();
+                       owner->view()->text->CursorLeft(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_UPSEL:
-               owner->view()->update(-2);
-               owner->view()->text->CursorUp();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorUp(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_DOWNSEL:
-               owner->view()->update(-2);
-               owner->view()->text->CursorDown();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorDown(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
 
        case LFUN_UP_PARAGRAPHSEL:
-               owner->view()->update(-2);
-               owner->view()->text->CursorUpParagraph();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorUpParagraph(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_DOWN_PARAGRAPHSEL:
-               owner->view()->update(-2);
-               owner->view()->text->CursorDownParagraph();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorDownParagraph(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_PRIORSEL:
-               owner->view()->update(-2);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                owner->view()->cursorPrevious();
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_NEXTSEL:
-               owner->view()->update(-2);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                owner->view()->cursorNext();
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_HOMESEL:
-               owner->view()->update(-2);
-               owner->view()->text->CursorHome();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorHome(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_ENDSEL:
-               owner->view()->update(-2);
-               owner->view()->text->CursorEnd();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorEnd(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_WORDRIGHTSEL:
-               owner->view()->update(-2);
-               if (owner->view()->text->cursor.par->isRightToLeftPar())
-                       owner->view()->text->CursorLeftOneWord();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
+                       owner->view()->text->CursorLeftOneWord(owner->view());
                else
-                       owner->view()->text->CursorRightOneWord();
+                       owner->view()->text->CursorRightOneWord(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_WORDLEFTSEL:
-               owner->view()->update(-2);
-               if (owner->view()->text->cursor.par->isRightToLeftPar())
-                       owner->view()->text->CursorRightOneWord();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
+                       owner->view()->text->CursorRightOneWord(owner->view());
                else
-                       owner->view()->text->CursorLeftOneWord();
+                       owner->view()->text->CursorLeftOneWord(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_BEGINNINGBUFSEL:
-               owner->view()->update(-2);
-               owner->view()->text->CursorTop();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorTop(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
        case LFUN_ENDBUFSEL:
-               owner->view()->update(-2);
-               owner->view()->text->CursorBottom();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->CursorBottom(owner->view());
                owner->view()->text->FinishUndo();
                moveCursorUpdate(true);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
 
                // --- text changing commands ------------------------
        case LFUN_BREAKLINE:
-#if 1
                owner->view()->beforeChange();
-               owner->view()->text->InsertChar(LyXParagraph::META_NEWLINE);
-               owner->view()->smallUpdate(1);
-               SetUpdateTimer(0.01);
+               owner->view()->text->InsertChar(owner->view(), LyXParagraph::META_NEWLINE);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                moveCursorUpdate(false);
-#else
-               owner->view()->newline();
-#endif
                break;
                
        case LFUN_PROTECTEDSPACE:
-#if 1
        {
                LyXLayout const & style =
                        textclasslist.Style(owner->view()->buffer()->params.textclass,
-                                           owner->view()->text->cursor.par->GetLayout());
+                                           owner->view()->text->cursor.par()->GetLayout());
 
                if (style.free_spacing) {
-                       owner->view()->text->InsertChar(' ');
-                       owner->view()->update(-1);
+                       owner->view()->text->InsertChar(owner->view(), ' ');
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                } else {
                        owner->view()->protectedBlank();
                }
                moveCursorUpdate(false);
        }
-#else
-               owner->view()->beforeChange();
-               owner->view()->text->
-                       InsertChar(LyXParagraph::META_PROTECTED_SEPARATOR);
-               owner->view()->smallUpdate(1);
-               SetUpdateTimer();
-                moveCursorUpdate(false);
-#endif
-               break;
+       break;
                
        case LFUN_SETMARK:
                if(owner->view()->text->mark_set) {
                        owner->view()->beforeChange();
-                       owner->view()->update(0);
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                        setMessage(N_("Mark removed"));
                } else {
                        owner->view()->beforeChange();
                        owner->view()->text->mark_set = 1;
-                       owner->view()->update(0);
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                        setMessage(N_("Mark set"));
                }
                owner->view()->text->sel_cursor = 
@@ -1720,21 +1895,19 @@ string LyXFunc::Dispatch(int ac,
                break;
                
        case LFUN_DELETE:
-               FreeUpdateTimer();
                if (!owner->view()->text->selection) {
-                       owner->view()->text->Delete();
+                       owner->view()->text->Delete(owner->view());
                        owner->view()->text->sel_cursor = 
                                owner->view()->text->cursor;
-                       owner->view()->smallUpdate(1);
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                        // It is possible to make it a lot faster still
                        // just comment out the lone below...
                        owner->view()->showCursor();
                } else {
                        owner->view()->cut();
                }
-               SetUpdateTimer();
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                owner->view()->setState();
                break;
 
@@ -1744,81 +1917,74 @@ string LyXFunc::Dispatch(int ac,
                
                LyXCursor cursor = owner->view()->text->cursor;
 
-               FreeUpdateTimer();
                if (!owner->view()->text->selection) {
-                       if (cursor.pos == cursor.par->Last()) {
-                               owner->view()->text->CursorRight();
+                       if (cursor.pos() == cursor.par()->Last()) {
+                               owner->view()->text->CursorRight(owner->view());
                                cursor = owner->view()->text->cursor;
-                               if (cursor.pos == 0
-                                   && !(cursor.par->added_space_top 
+                               if (cursor.pos() == 0
+                                   && !(cursor.par()->added_space_top 
                                         == VSpace (VSpace::NONE))) {
                                        owner->view()->text->SetParagraph
-                                               (cursor.par->line_top,
-                                                cursor.par->line_bottom,
-                                                cursor.par->pagebreak_top, 
-                                                cursor.par->pagebreak_bottom,
+                                               (owner->view(),
+                                                cursor.par()->line_top,
+                                                cursor.par()->line_bottom,
+                                                cursor.par()->pagebreak_top, 
+                                                cursor.par()->pagebreak_bottom,
                                                 VSpace(VSpace::NONE), 
-                                                cursor.par->added_space_bottom,
-                                                cursor.par->align, 
-                                                cursor.par->labelwidthstring, 0);
-                                       owner->view()->text->CursorLeft();
-                                       owner->view()->update (1);
+                                                cursor.par()->added_space_bottom,
+                                                cursor.par()->align, 
+                                                cursor.par()->labelwidthstring, 0);
+                                       owner->view()->text->CursorLeft(owner->view());
+                                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                                } else {
-                                       owner->view()->text->CursorLeft();
-                                       owner->view()->text->Delete();
+                                       owner->view()->text->CursorLeft(owner->view());
+                                       owner->view()->text->Delete(owner->view());
                                        owner->view()->text->sel_cursor = 
                                                owner->view()->text->cursor;
-                                       owner->view()->smallUpdate(1);
+                                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                                }
                        } else {
-                               owner->view()->text->Delete();
+                               owner->view()->text->Delete(owner->view());
                                owner->view()->text->sel_cursor = 
                                        owner->view()->text->cursor;
-                               owner->view()->smallUpdate(1);
+                               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                        }
                } else {
                        owner->view()->cut();
                }
-               SetUpdateTimer();
        }
        break;
 
        /* -------> Delete word forward. */
        case LFUN_DELETE_WORD_FORWARD:
-               owner->view()->update(-2);
-               FreeUpdateTimer();
-               owner->view()->text->DeleteWordForward();
-               owner->view()->update( 1 );
-               SetUpdateTimer();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->DeleteWordForward(owner->view());
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
 
                /* -------> Delete word backward. */
        case LFUN_DELETE_WORD_BACKWARD:
-               owner->view()->update(-2);
-               FreeUpdateTimer();
-               owner->view()->text->DeleteWordBackward();
-               owner->view()->update( 1 );
-               SetUpdateTimer();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->DeleteWordBackward(owner->view());
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                moveCursorUpdate(false);
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
                
                /* -------> Kill to end of line. */
        case LFUN_DELETE_LINE_FORWARD:
-               FreeUpdateTimer();
-               owner->view()->update(-2);
-               owner->view()->text->DeleteLineForward();
-               owner->view()->update( 1 );
-               SetUpdateTimer();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
+               owner->view()->text->DeleteLineForward(owner->view());
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                moveCursorUpdate(false);
                break;
                
                /* -------> Set mark off. */
        case LFUN_MARK_OFF:
                owner->view()->beforeChange();
-               owner->view()->update(0);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                owner->view()->text->sel_cursor = 
                        owner->view()->text->cursor;
                setMessage(N_("Mark off"));
@@ -1828,7 +1994,7 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_MARK_ON:
                owner->view()->beforeChange();
                owner->view()->text->mark_set = 1;
-               owner->view()->update( 0 );
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
                owner->view()->text->sel_cursor = 
                        owner->view()->text->cursor;
                setMessage(N_("Mark on"));
@@ -1836,13 +2002,12 @@ string LyXFunc::Dispatch(int ac,
                
        case LFUN_BACKSPACE:
        {
-               FreeUpdateTimer();
                if (!owner->view()->text->selection) {
                        if (owner->getIntl()->getTrans()->backspace()) {
-                               owner->view()->text->Backspace();
+                               owner->view()->text->Backspace(owner->view());
                                owner->view()->text->sel_cursor = 
                                        owner->view()->text->cursor;
-                               owner->view()->smallUpdate(1);
+                               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                                // It is possible to make it a lot faster still
                                // just comment out the lone below...
                                owner->view()->showCursor();
@@ -1850,8 +2015,7 @@ string LyXFunc::Dispatch(int ac,
                } else {
                        owner->view()->cut();
                }
-               SetUpdateTimer();
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                owner->view()->setState();
        }
        break;
@@ -1862,55 +2026,52 @@ string LyXFunc::Dispatch(int ac,
                
                LyXCursor cursor = owner->view()->text->cursor;
                
-               FreeUpdateTimer();
                if (!owner->view()->text->selection) {
-                       if (cursor.pos == 0 
-                           && !(cursor.par->added_space_top 
+                       if (cursor.pos() == 0 
+                           && !(cursor.par()->added_space_top 
                                 == VSpace (VSpace::NONE))) {
                                owner->view()->text->SetParagraph 
-                                       (cursor.par->line_top,      
-                                        cursor.par->line_bottom,
-                                        cursor.par->pagebreak_top, 
-                                        cursor.par->pagebreak_bottom,
-                                        VSpace(VSpace::NONE), cursor.par->added_space_bottom,
-                                        cursor.par->align, 
-                                        cursor.par->labelwidthstring, 0);
-                               owner->view()->update (1);
+                                       (owner->view(),
+                                        cursor.par()->line_top,      
+                                        cursor.par()->line_bottom,
+                                        cursor.par()->pagebreak_top, 
+                                        cursor.par()->pagebreak_bottom,
+                                        VSpace(VSpace::NONE), cursor.par()->added_space_bottom,
+                                        cursor.par()->align, 
+                                        cursor.par()->labelwidthstring, 0);
+                               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                        } else {
-                               owner->view()->text->Backspace();
+                               owner->view()->text->Backspace(owner->view());
                                owner->view()->text->sel_cursor 
                                        = cursor;
-                               owner->view()->smallUpdate (1);
+                               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                        }
                } else
                        owner->view()->cut();
-               SetUpdateTimer();
        }
        break;
 
        case LFUN_BREAKPARAGRAPH:
        {
                owner->view()->beforeChange();
-               owner->view()->text->BreakParagraph(0);
-               owner->view()->smallUpdate(1);
-               SetUpdateTimer(0.01);
+               owner->view()->text->BreakParagraph(owner->view(), 0);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                owner->view()->text->sel_cursor = 
                        owner->view()->text->cursor;
                owner->view()->setState();
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
        }
 
        case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
        {
                owner->view()->beforeChange();
-               owner->view()->text->BreakParagraph(1);
-               owner->view()->smallUpdate(1);
-               SetUpdateTimer(0.01);
+               owner->view()->text->BreakParagraph(owner->view(), 1);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                owner->view()->text->sel_cursor = 
                        owner->view()->text->cursor;
                owner->view()->setState();
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
                break;
        }
        
@@ -1923,44 +2084,43 @@ string LyXFunc::Dispatch(int ac,
                LyXCursor cursor = owner->view()->text->cursor;
                
                owner->view()->beforeChange();
-               if (cursor.pos == 0) {
-                       if (cursor.par->added_space_top == VSpace(VSpace::NONE)) {
+               if (cursor.pos() == 0) {
+                       if (cursor.par()->added_space_top == VSpace(VSpace::NONE)) {
                                owner->view()->text->SetParagraph
-                                       (cursor.par->line_top,      
-                                        cursor.par->line_bottom,
-                                        cursor.par->pagebreak_top, 
-                                        cursor.par->pagebreak_bottom,
-                                        VSpace(VSpace::DEFSKIP), cursor.par->added_space_bottom,
-                                        cursor.par->align, 
-                                        cursor.par->labelwidthstring, 1);
-                               owner->view()->update(1);
+                                       (owner->view(),
+                                        cursor.par()->line_top,      
+                                        cursor.par()->line_bottom,
+                                        cursor.par()->pagebreak_top, 
+                                        cursor.par()->pagebreak_bottom,
+                                        VSpace(VSpace::DEFSKIP), cursor.par()->added_space_bottom,
+                                        cursor.par()->align, 
+                                        cursor.par()->labelwidthstring, 1);
+                               //owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                        } 
                }
                else {
-                       owner->view()->text->BreakParagraph(0);
-                       owner->view()->smallUpdate(1);
+                       owner->view()->text->BreakParagraph(owner->view(), 0);
+                       //owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                }
-               SetUpdateTimer(0.01);
+
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                owner->view()->text->sel_cursor = cursor;
                owner->view()->setState();
-               owner->getMiniBuffer()->Set(CurrentState(owner->view()));
+               owner->showState();
        }
        break;
 
        case LFUN_PARAGRAPH_SPACING:
        {
-               LyXParagraph * par = owner->view()->text->cursor.par;
+               LyXParagraph * par = owner->view()->text->cursor.par();
                Spacing::Space cur_spacing = par->spacing.getSpace();
                float cur_value = 1.0;
                if (cur_spacing == Spacing::Other) {
                        cur_value = par->spacing.getValue();
                }
                
-#ifdef HAVE_SSTREAM
                istringstream istr(argument);
-#else
-               istrstream istr(argument.c_str());
-#endif
+
                string tmp;
                istr >> tmp;
                Spacing::Space new_spacing = cur_spacing;
@@ -1989,62 +2149,171 @@ string LyXFunc::Dispatch(int ac,
                }
                if (cur_spacing != new_spacing || cur_value != new_value) {
                        par->spacing.set(new_spacing, new_value);
-                       owner->view()->text->RedoParagraph();
-                       owner->view()->update(-1);
+                       owner->view()->text->RedoParagraph(owner->view());
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                }
        }
        break;
        
        case LFUN_QUOTE:
                owner->view()->beforeChange();
-               owner->view()->text->InsertChar('\"');  // This " matches the single quote in the code
-               owner->view()->smallUpdate(1);
-               SetUpdateTimer();
+               owner->view()->text->InsertChar(owner->view(), '\"');  // This " matches the single quote in the code
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                 moveCursorUpdate(false);
                break;
 
        case LFUN_HTMLURL:
        case LFUN_URL:
        {
-               InsetCommand * new_inset;
+               InsetCommandParams p;
                if (action == LFUN_HTMLURL)
-                       new_inset = new InsetUrl("htmlurl", "", "");
+                       p.setCmdName("htmlurl");
                else
-                       new_inset = new InsetUrl("url", "", "");
-               owner->view()->insertInset(new_inset);
-               new_inset->Edit(owner->view(), 0, 0, 0);
+                       p.setCmdName("url");
+               owner->getDialogs()->createUrl( p.getAsString() );
        }
        break;
-       
-       case LFUN_INSET_TEXT:
+                   
+       case LFUN_INSERT_URL:
        {
-               InsetText * new_inset = new InsetText(owner->buffer());
-               owner->view()->insertInset(new_inset);
-               new_inset->Edit(owner->view(), 0, 0, 0);
+               InsetCommandParams p;
+               p.setFromString( argument );
+
+               InsetUrl * inset = new InsetUrl( p );
+               if (!owner->view()->insertInset(inset))
+                       delete inset;
+               else
+                       owner->view()->updateInset( inset, true );
        }
        break;
-#if 0
-       case LFUN_INSET_NUMBER:
+                   
+       case LFUN_INSET_TEXT:
        {
-               InsetNumber * new_inset = new InsetNumber(owner->buffer());
-               owner->view()->insertInset(new_inset);
-               new_inset->Edit(owner->view(), 0, 0, 0);
+               InsetText * new_inset = new InsetText;
+               if (owner->view()->insertInset(new_inset))
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete new_inset;
        }
        break;
-#endif
+       
        case LFUN_INSET_ERT:
        {
-               InsetERT * new_inset = new InsetERT(owner->buffer());
-               owner->view()->insertInset(new_inset);
-               new_inset->Edit(owner->view(), 0, 0, 0);
+               InsetERT * new_inset = new InsetERT;
+               if (owner->view()->insertInset(new_inset))
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete new_inset;
+       }
+       break;
+       
+       case LFUN_INSET_EXTERNAL:
+       {
+               InsetExternal * new_inset = new InsetExternal;
+               if (owner->view()->insertInset(new_inset))
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete new_inset;
        }
        break;
        
        case LFUN_INSET_FOOTNOTE:
        {
-               InsetFoot * new_inset = new InsetFoot(owner->buffer());
-               owner->view()->insertInset(new_inset);
-               new_inset->Edit(owner->view(), 0, 0, 0);
+               InsetFoot * new_inset = new InsetFoot;
+               if (owner->view()->insertInset(new_inset))
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete new_inset;
+       }
+       break;
+
+       case LFUN_INSET_MARGINAL:
+       {
+               InsetMarginal * new_inset = new InsetMarginal;
+               if (owner->view()->insertInset(new_inset))
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete new_inset;
+       }
+       break;
+
+       case LFUN_INSET_MINIPAGE:
+       {
+               InsetMinipage * new_inset = new InsetMinipage;
+               if (owner->view()->insertInset(new_inset))
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete new_inset;
+       }
+       break;
+
+       case LFUN_INSET_FLOAT:
+       {
+               // check if the float type exist
+               if (floatList.typeExist(argument)) {
+                       InsetFloat * new_inset = new InsetFloat(argument);
+                       if (owner->view()->insertInset(new_inset))
+                               new_inset->Edit(owner->view(), 0, 0, 0);
+                       else
+                               delete new_inset;
+               } else {
+                       lyxerr << "Non-existant float type: "
+                              << argument << endl;
+               }
+               
+       }
+       break;
+
+       case LFUN_INSET_LIST:
+       {
+               InsetList * new_inset = new InsetList;
+               if (owner->view()->insertInset(new_inset))
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete new_inset;
+       }
+       break;
+
+       case LFUN_INSET_THEOREM:
+       {
+               InsetTheorem * new_inset = new InsetTheorem;
+               if (owner->view()->insertInset(new_inset))
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete new_inset;
+       }
+       break;
+
+       case LFUN_INSET_CAPTION:
+       {
+               // Do we have a locking inset...
+               if (owner->view()->the_locking_inset) {
+                       lyxerr << "Locking inset code: "
+                              << static_cast<int>(owner->view()->the_locking_inset->LyxCode());
+                       InsetCaption * new_inset = new InsetCaption;
+                       new_inset->setOwner(owner->view()->the_locking_inset);
+                       new_inset->SetAutoBreakRows(true);
+                       new_inset->SetDrawFrame(0, InsetText::LOCKED);
+                       new_inset->SetFrameColor(0, LColor::footnoteframe);
+                       if (owner->view()->insertInset(new_inset))
+                               new_inset->Edit(owner->view(), 0, 0, 0);
+                       else
+                               delete new_inset;
+               }
+       }
+       break;
+       
+       case LFUN_INSET_TABULAR:
+       {
+               int r = 2, c = 2;
+               if (!argument.empty())
+                       ::sscanf(argument.c_str(),"%d%d", &r, &c);
+               InsetTabular * new_inset =
+                       new InsetTabular(owner->buffer(), r, c);
+               if (owner->view()->insertInset(new_inset))
+                       new_inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete new_inset;
        }
        break;
 
@@ -2053,13 +2322,13 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_CHARATCURSOR:
        {
                LyXParagraph::size_type pos = 
-                       owner->view()->text->cursor.pos;
-               if(pos < owner->view()->text->cursor.par->size())
+                       owner->view()->text->cursor.pos();
+               if(pos < owner->view()->text->cursor.par()->size())
                        //dispatch_buffer = owner->view()->text->
-                       //      cursor.par->text[pos];
+                       //      cursor.par()->text[pos];
                        dispatch_buffer =
                                owner->view()->text->
-                               cursor.par->GetChar(pos);
+                               cursor.par()->GetChar(pos);
                else
                        dispatch_buffer = "EOF";
        }
@@ -2067,22 +2336,22 @@ string LyXFunc::Dispatch(int ac,
        
        case LFUN_GETXY:
                dispatch_buffer = 
-                       tostr(owner->view()->text->cursor.x) + ' '
-                       + tostr(owner->view()->text->cursor.y);
+                       tostr(owner->view()->text->cursor.x()) + ' '
+                       + tostr(owner->view()->text->cursor.y());
                break;
                
        case LFUN_SETXY:
        {
                int  x;
                long y;
-               sscanf(argument.c_str(), " %d %ld", &x, &y);
-               owner->view()->text->SetCursorFromCoordinates(x, y);
+               ::sscanf(argument.c_str(), " %d %ld", &x, &y);
+               owner->view()->text->SetCursorFromCoordinates(owner->view(), x, y);
        }
        break;
        
        case LFUN_GETLAYOUT:
                dispatch_buffer =  
-                       tostr(owner->view()->text->cursor.par->layout);
+                       tostr(owner->view()->text->cursor.par()->layout);
                break;
                        
        case LFUN_GETFONT:
@@ -2128,10 +2397,10 @@ string LyXFunc::Dispatch(int ac,
        {
                char file_name[100];
                int  row;
-               sscanf(argument.c_str(), " %s %d", file_name, &row);
+               ::sscanf(argument.c_str(), " %s %d", file_name, &row);
 
                // Must replace extension of the file to be .lyx and get full path
-               string s = ChangeExtension(string(file_name), ".lyx", false);
+               string s = ChangeExtension(string(file_name), ".lyx");
 
                // Either change buffer or load the file
                if (bufferlist.exists(s))
@@ -2147,10 +2416,28 @@ string LyXFunc::Dispatch(int ac,
        }
        break;
 
+       case LFUN_GOTO_PARAGRAPH:
+       {
+                istringstream istr(argument);
+
+               int id;
+               istr >> id;
+               LyXParagraph * par = owner->view()->text->GetParFromID(id);
+
+               // Set the cursor
+               owner->view()->text->SetCursor(owner->view(), par, 0);
+               owner->view()->setState();
+               owner->showState();
+
+               // Recenter screen
+               owner->view()->center();
+       }
+       break;
+
        case LFUN_APROPOS:
        case LFUN_GETTIP:
        {
-               int qa = lyxaction.LookupFunc(argument.c_str());
+               int const qa = lyxaction.LookupFunc(argument);
                setMessage(lyxaction.helpText(static_cast<kb_action>(qa)));
        }
        break;
@@ -2175,12 +2462,10 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_CIRCLE:
        case LFUN_OGONEK:
        {
-               char c;
+               char c = 0;
                
                if (keyseq.length == -1 && keyseq.getiso() != 0) 
                        c = keyseq.getiso();
-               else
-                       c = 0;
                
                owner->getIntl()->getTrans()->
                        deadkey(c, get_accent(action).accent, 
@@ -2192,8 +2477,8 @@ string LyXFunc::Dispatch(int ac,
                keyseq.length = 0;
                
                // copied verbatim from do_accent_char
-               owner->view()->smallUpdate(1);
-               SetUpdateTimer();
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+
                owner->view()->text->sel_cursor = 
                        owner->view()->text->cursor;
        }   
@@ -2203,15 +2488,7 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_PUSH_TOOLBAR:
        {
                int nth = strToInt(argument);
-               if (lyxerr.debugging(Debug::TOOLBAR)) {
-                       lyxerr << "LFUN_PUSH_TOOLBAR: argument = `"
-                              << argument << "'\n"
-                              << "LFUN_PUSH_TOOLBAR: nth = `"
-                              << nth << "'" << endl;
-               }
-               
                if (nth <= 0) {
-                       LyXBell();
                        setErrorMessage(N_("Push-toolbar needs argument > 0"));
                } else {
                        owner->getToolbar()->push(nth);
@@ -2221,7 +2498,7 @@ string LyXFunc::Dispatch(int ac,
        
        case LFUN_ADD_TO_TOOLBAR:
        {
-               if (lyxerr.debugging(Debug::TOOLBAR)) {
+               if (lyxerr.debugging(Debug::GUI)) {
                        lyxerr << "LFUN_ADD_TO_TOOLBAR:"
                                "argument = `" << argument << '\'' << endl;
                }
@@ -2229,7 +2506,6 @@ string LyXFunc::Dispatch(int ac,
                //lyxerr <<string("Argument: ") + argument);
                //lyxerr <<string("Tmp     : ") + tmp);
                if (tmp.empty()) {
-                       LyXBell();
                        setErrorMessage(N_("Usage: toolbar-add-to <LyX command>"));
                } else {
                        owner->getToolbar()->add(argument, false);
@@ -2282,7 +2558,7 @@ string LyXFunc::Dispatch(int ac,
               
        case LFUN_INSERT_MATH:
        {
-               math_insert_symbol(argument.c_str());
+               math_insert_symbol(argument);
        }
        break;
        
@@ -2301,7 +2577,7 @@ string LyXFunc::Dispatch(int ac,
                                setErrorMessage(N_("Missing argument"));
                        else {
                                string s1 = token(s, ' ', 1);
-                               int na = s1.empty() ? 0: atoi(s1.c_str());
+                               int na = s1.empty() ? 0 : lyx::atoi(s1);
                                owner->view()->
                                        open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na));
                        }
@@ -2310,8 +2586,7 @@ string LyXFunc::Dispatch(int ac,
        break;
 
        case LFUN_MATH_MODE:   // Open or create a math inset
-       {
-               
+       {               
                if (owner->view()->available())
                        owner->view()->open_new_inset(new InsetFormula);
                setMessage(N_("Math editor mode"));
@@ -2322,27 +2597,42 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_MATH_LIMITS:
        {
                setErrorMessage(N_("This is only allowed in math mode!"));
+       
+       }
+       break;
+
+       case LFUN_MATH_PANEL:
+       {
+               show_symbols_form(this);
        }
        break;
        
-       case LFUN_INSERT_CITATION:
-       {   
-               InsetCitation * new_inset = new InsetCitation();
-               // ale970405
-               // The note, if any, must be after the key, delimited
-               // by a | so both key and remark can have spaces.
-               if (!argument.empty()) {
-                       string lsarg(argument);
-                       if (contains(lsarg, "|")) {
-                               new_inset->setContents(token(lsarg, '|', 0));
-                               new_inset->setOptions(token(lsarg, '|', 1));
-                       } else
-                               new_inset->setContents(lsarg);
-                       owner->view()->insertInset(new_inset);
+       case LFUN_CITATION_CREATE:
+       {
+               // Should do this "at source"
+               InsetCommandParams p( "cite" );
+               
+               if (contains(argument, "|")) {
+                       p.setContents( token(argument, '|', 0) );
+                       p.setOptions(  token(argument, '|', 1) );
                } else {
-                       owner->view()->insertInset(new_inset);
-                       new_inset->Edit(owner->view(), 0, 0, 0);
+                       p.setContents( argument );
                }
+
+               owner->getDialogs()->createCitation( p.getAsString() );
+       }
+       break;
+                   
+       case LFUN_CITATION_INSERT:
+       {
+               InsetCommandParams p;
+               p.setFromString( argument );
+
+               InsetCitation * inset = new InsetCitation( p );
+               if (!owner->view()->insertInset(inset))
+                       delete inset;
+               else
+                       owner->view()->updateInset( inset, true );
        }
        break;
                    
@@ -2351,19 +2641,19 @@ string LyXFunc::Dispatch(int ac,
                // ale970405+lasgoutt970425
                // The argument can be up to two tokens separated 
                // by a space. The first one is the bibstyle.
-               string lsarg(argument);
-               string bibstyle = token(lsarg, ' ', 1);
+               string db       = token(argument, ' ', 0);
+               string bibstyle = token(argument, ' ', 1);
                if (bibstyle.empty())
                        bibstyle = "plain";
-               InsetBibtex * new_inset 
-                       = new InsetBibtex(token(lsarg, ' ', 0),
-                                         bibstyle,
-                                         owner->buffer());
+
+               InsetCommandParams p( "BibTeX", db, bibstyle );
+               InsetBibtex * inset = new InsetBibtex(p, owner->buffer());
                
-               owner->view()->insertInset(new_inset);
-               if (lsarg.empty()) {
-                       new_inset->Edit(owner->view(), 0, 0, 0);
-               }
+               if (owner->view()->insertInset(inset)) {
+                       if (argument.empty())
+                               inset->Edit(owner->view(), 0, 0, 0);
+               } else
+                       delete inset;
        }
        break;
                
@@ -2398,75 +2688,90 @@ string LyXFunc::Dispatch(int ac,
        }
        break;
                
-       case LFUN_INDEX_INSERT:
-       case LFUN_INDEX_INSERT_LAST:
+       case LFUN_INDEX_CREATE:
        {
-               // Can't do that at the beginning of a paragraph.
-               if (owner->view()->text->cursor.pos - 1 < 0)
-                       break;
+               InsetCommandParams p( "index" );
+               
+               if( argument.empty() ) {
+                       // Get the word immediately preceding the cursor
+                       LyXParagraph::size_type curpos = 
+                               owner->view()->text->cursor.pos() - 1;
 
-               InsetIndex * new_inset = new InsetIndex();
-               if (!argument.empty()) {
-                       string lsarg(argument);
-                       new_inset->setContents(lsarg);
-                       owner->view()->insertInset(new_inset);
+                       string curstring;
+                       if( curpos >= 0 )
+                               curstring = owner->view()->text
+                                           ->cursor.par()->GetWord(curpos);
+
+                       p.setContents( curstring );
                } else {
-                       //reh 98/09/21
-                       //get the current word for an argument
-                       LyXParagraph::size_type lastpos = 
-                               owner->view()->text->cursor.pos - 1;
-                       // Get the current word. note that this must be done
-                       // before inserting the inset, or the inset will
-                       // break the word
-                       string curstring(owner->view()
-                                        ->text->cursor.par->GetWord(lastpos));
-
-                       //make the new inset and write the current word into it
-                       InsetIndex * new_inset = new InsetIndex();
-
-                       new_inset->setContents(curstring);
-
-                       //don't edit it if the call was to INSERT_LAST
-                       if(action != LFUN_INDEX_INSERT_LAST) {
-                               new_inset->Edit(owner->view(), 0, 0, 0);
-                       } else {
-                               //it looks blank on the screen unless
-                               //we do  something.  put it here.
+                       p.setContents( argument );
+               }
 
-                               // move the cursor to the returned value of lastpos
-                               // but only for the auto-insert
-                               owner->view()->text->cursor.pos = lastpos;
-                       }
+               owner->getDialogs()->createIndex( p.getAsString() );
+       }
+       break;
+                   
+       case LFUN_INDEX_INSERT:
+       {
+               InsetCommandParams p;
+               p.setFromString( argument );
+               InsetIndex * inset = new InsetIndex( p );
 
-                       //put the new inset into the buffer.
-                       // there should be some way of knowing the user
-                       //cancelled & avoiding this, but i don't know how
-                       owner->view()->insertInset(new_inset);
-               }
+               if (!owner->view()->insertInset(inset))
+                       delete inset;
+               else
+                       owner->view()->updateInset( inset, true );
        }
        break;
+                   
+       case LFUN_INDEX_INSERT_LAST:
+       {
+               // Get word immediately preceding the cursor
+               LyXParagraph::size_type curpos = 
+                       owner->view()->text->cursor.pos() - 1;
+               // Can't do that at the beginning of a paragraph
+               if( curpos < 0 ) break;
+
+               string curstring( owner->view()->text
+                                 ->cursor.par()->GetWord(curpos) );
+
+               InsetCommandParams p( "index", curstring );
+               InsetIndex * inset = new InsetIndex( p );
 
+               if (!owner->view()->insertInset(inset))
+                       delete inset;
+               else
+                       owner->view()->updateInset( inset, true );
+       }
+       break;
+                   
        case LFUN_INDEX_PRINT:
        {
-               Inset * new_inset = new InsetPrintIndex(owner->buffer());
-               owner->view()->insertInset(new_inset, "Standard", true);
+               InsetCommandParams p( "printindex" );
+               Inset * inset = new InsetPrintIndex(p);
+               if (!owner->view()->insertInset(inset, "Standard", true))
+                       delete inset;
        }
        break;
 
        case LFUN_PARENTINSERT:
        {
                lyxerr << "arg " << argument << endl;
-               Inset * new_inset = new InsetParent(argument, owner->buffer());
-               owner->view()->insertInset(new_inset, "Standard", true);
+               InsetCommandParams p( "lyxparent", argument );
+               Inset * inset = new InsetParent(p, owner->buffer());
+               if (!owner->view()->insertInset(inset, "Standard", true))
+                       delete inset;
        }
        break;
 
        case LFUN_CHILDINSERT:
        {
-               Inset * new_inset = new InsetInclude(argument,
-                                                    owner->buffer());
-               owner->view()->insertInset(new_inset, "Standard", true);
-               new_inset->Edit(owner->view(), 0, 0, 0);
+               InsetCommandParams p( "Include", argument );
+               Inset * inset = new InsetInclude(p, owner->buffer());
+               if (owner->view()->insertInset(inset, "Standard", true))
+                       inset->Edit(owner->view(), 0, 0, 0);
+               else
+                       delete inset;
        }
        break;
 
@@ -2488,7 +2793,7 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_INSERT_NOTE:
                owner->view()->insertNote();
                break;
-               
+#ifndef NEW_INSETS
        case LFUN_INSERTFOOTNOTE: 
        {
                LyXParagraph::footnote_kind kind;
@@ -2510,16 +2815,12 @@ string LyXFunc::Dispatch(int ac,
                        setErrorMessage(N_("Unknown kind of footnote"));
                        break;
                }
-               owner->view()->text->InsertFootnoteEnvironment(kind);
-               owner->view()->update(1);
+               owner->view()->text->InsertFootnoteEnvironment(owner->view(), kind);
+               owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                owner->view()->setState();
        }
        break;
-       
-       case LFUN_BUFFERBULLETSSELECT:
-               bulletForm();
-               break;
-               
+#endif
        case LFUN_TOGGLECURSORFOLLOW:
                cursor_follows_scrollbar = !cursor_follows_scrollbar;
                break;
@@ -2543,12 +2844,11 @@ string LyXFunc::Dispatch(int ac,
        case LFUN_SELFINSERT:
        {
                for (string::size_type i = 0; i < argument.length(); ++i) {
-                       owner->view()->text->InsertChar(argument[i]);
+                       owner->view()->text->InsertChar(owner->view(), argument[i]);
                        // This needs to be in the loop, or else we
                        // won't break lines correctly. (Asger)
-                       owner->view()->smallUpdate(1);
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                }
-               SetUpdateTimer();
                owner->view()->text->sel_cursor = 
                        owner->view()->text->cursor;
                moveCursorUpdate(false);
@@ -2568,37 +2868,79 @@ string LyXFunc::Dispatch(int ac,
 
        case LFUN_DATE_INSERT:  // jdblair: date-insert cmd
        {
-               char datetmp[32];
-               int datetmp_len;
-               time_t now_time_t;
-               struct tm *now_tm;
-               static string arg;
+               struct tm * now_tm;
                
-               now_time_t = time(NULL);
+               time_t now_time_t = time(NULL);
                now_tm = localtime(&now_time_t);
-               (void)setlocale(LC_TIME, "");
+               setlocale(LC_TIME, "");
+               string arg;
                if (!argument.empty())
                        arg = argument;
-               else if (arg.empty())
+               else 
                        arg = lyxrc.date_insert_format;
-               datetmp_len = (int) strftime(datetmp, 32, arg.c_str(), now_tm);
+               char datetmp[32];
+               int datetmp_len = ::strftime(datetmp, 32, arg.c_str(), now_tm);
                for (int i = 0; i < datetmp_len; i++) {
-                       owner->view()->text->InsertChar(datetmp[i]);
-                       owner->view()->smallUpdate(1);
+                       owner->view()->text->InsertChar(owner->view(), datetmp[i]);
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                }
-               SetUpdateTimer();
+
                owner->view()->text->sel_cursor = owner->view()->text->cursor;
                moveCursorUpdate(false);
        }
        break;
 
+       case LFUN_DIALOG_PREFERENCES:
+               owner->getDialogs()->showPreferences();
+               break;
+               
        case LFUN_SAVEPREFERENCES:
        {
                Path p(user_lyxdir);
                lyxrc.write("preferences");
        }
        break;
-       
+
+       case LFUN_SCREEN_FONT_UPDATE:
+       {
+               // handle the screen font changes.
+               // 
+               lyxrc.set_font_norm_type();
+               fontloader.update();
+               // Of course we should only do the resize and the textcache.clear
+               // if values really changed...but not very important right now. (Lgb)
+               // All buffers will need resize
+               bufferlist.resize();
+               // We also need to empty the textcache so that
+               // the buffer will be formatted correctly after
+               // a zoom change.
+               textcache.clear();
+       }
+
+       case LFUN_SET_COLOR:
+       {
+               string lyx_name, x11_name;
+               x11_name = split(argument, lyx_name, ' ');
+               if (lyx_name.empty() || x11_name.empty()) {
+                       LyXBell();
+                       setErrorMessage(N_("Syntax: set-color <lyx_name>"
+                                               " <x11_name>"));
+                       break;
+                       }
+
+               if (!lcolor.setColor(lyx_name, x11_name)) {
+                       static string err1 (N_("Set-color \""));
+                       static string err2 (N_("\" failed - color is undefined "
+                                               "or may not be redefined"));
+                       LyXBell();
+                       setErrorMessage(err1 + lyx_name + err2);
+                       break;
+               }
+               lyxColorHandler->updateColor(lcolor.getFromLyXName(lyx_name));
+               owner->view()->redraw();
+               break;
+       }
+
        case LFUN_UNKNOWN_ACTION:
        {
                if(!owner->buffer()) {
@@ -2623,26 +2965,12 @@ string LyXFunc::Dispatch(int ac,
                
                        if ( lyxrc.auto_region_delete ) {
                                if (owner->view()->text->selection){
-                                       owner->view()->text->CutSelection(false);
-                                       owner->view()->update(-1);
+                                       owner->view()->text->CutSelection(owner->view(), false);
+                                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
                                }
                        }
                        
                        owner->view()->beforeChange();
-
-#if 0
-                       if (isdigit(argument[0]) &&
-                           (lyxrc.number_inset == "true" ||
-                            (lyxrc.number_inset == "rtl" &&
-                             owner->view()->text->real_current_font.isVisibleRightToLeft() 
-                             ))) {
-                               UpdatableInset * tmpinset = new InsetNumber(owner->buffer());
-                               owner->view()->open_new_inset(tmpinset);
-                               tmpinset->LocalDispatch(owner->view(), action,
-                                                       argument);
-                               return string();
-                       }
-#endif
                        
                        for (string::size_type i = 0;
                             i < argument.length(); ++i) {
@@ -2652,9 +2980,8 @@ string LyXFunc::Dispatch(int ac,
                                } else
                                        owner->getIntl()->getTrans()->TranslateAndInsert(argument[i], owner->view()->text);
                        }
-                       
-                       owner->view()->smallUpdate(1);
-                       SetUpdateTimer();
+
+                       owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
 
                        owner->view()->text->sel_cursor = 
                                owner->view()->text->cursor;
@@ -2714,31 +3041,35 @@ void LyXFunc::MenuNew(bool fromTemplate)
                        initpath = trypath;
        }
 
-       ProhibitInput(owner->view());
-       fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
-       fileDlg.SetButton(1, _("Templates"), lyxrc.template_path);
-       fname = fileDlg.Select(_("Enter Filename for new document"), 
-                              initpath, "*.lyx", _("newfile"));
-       AllowInput(owner->view());
-       
-       if (fname.empty()) {
-               owner->getMiniBuffer()->Set(_("Canceled."));
-               lyxerr.debug() << "New Document Cancelled." << endl;
-               return;
-       }
-        
-       // get absolute path of file and make sure the filename ends
-       // with .lyx
-       string s = MakeAbsPath(fname);
-       if (!IsLyXFilename(s))
-               s += ".lyx";
+       static int newfile_number = 0;
+       string s;
 
-       // Check if the document already is open
-       if (bufferlist.exists(s)){
-               switch(AskConfirmation(_("Document is already open:"), 
-                                      MakeDisplayPath(s, 50),
-                                      _("Do you want to close that document now?\n"
-                                        "('No' will just switch to the open version)")))
+       if (lyxrc.new_ask_filename) {
+               ProhibitInput(owner->view());
+               fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
+               fileDlg.SetButton(1, _("Templates"), lyxrc.template_path);
+               fname = fileDlg.Select(_("Enter Filename for new document"), 
+                                      initpath, "*.lyx", _("newfile"));
+               AllowInput(owner->view());
+       
+               if (fname.empty()) {
+                       owner->getMiniBuffer()->Set(_("Canceled."));
+                       lyxerr.debug() << "New Document Cancelled." << endl;
+                       return;
+               }
+       
+               // get absolute path of file and make sure the filename ends
+               // with .lyx
+               s = MakeAbsPath(fname);
+               if (!IsLyXFilename(s))
+                       s += ".lyx";
+
+               // Check if the document already is open
+               if (bufferlist.exists(s)) {
+                       switch(AskConfirmation(_("Document is already open:"), 
+                                              MakeDisplayPath(s, 50),
+                                              _("Do you want to close that document now?\n"
+                                                "('No' will just switch to the open version)")))
                        {
                        case 1: // Yes: close the document
                                if (!bufferlist.close(bufferlist.getBuffer(s)))
@@ -2752,25 +3083,36 @@ void LyXFunc::MenuNew(bool fromTemplate)
                                owner->getMiniBuffer()->Set(_("Canceled."));
                                return;
                        }
-       }
-        
-       // Check whether the file already exists
-       if (IsLyXFilename(s)) {
+               }
+               // Check whether the file already exists
+               if (IsLyXFilename(s)) {
+                       FileInfo fi(s);
+                       if (fi.readable() &&
+                           AskQuestion(_("File already exists:"), 
+                                       MakeDisplayPath(s, 50),
+                                       _("Do you want to open the document?"))) {
+                               // loads document
+                               owner->getMiniBuffer()->Set(_("Opening document"), 
+                                                           MakeDisplayPath(s), "...");
+                               XFlush(fl_display);
+                               owner->view()->buffer(
+                                       bufferlist.loadLyXFile(s));
+                               owner->getMiniBuffer()->Set(_("Document"),
+                                                           MakeDisplayPath(s),
+                                                           _("opened."));
+                               return;
+                       }
+               }
+       } else {
+               s = lyxrc.document_path +
+                   "newfile" + tostr(++newfile_number) + ".lyx";
                FileInfo fi(s);
-               if (fi.readable() &&
-                   AskQuestion(_("File already exists:"), 
-                               MakeDisplayPath(s, 50),
-                               _("Do you want to open the document?"))) {
-                       // loads document
-                       owner->getMiniBuffer()->Set(_("Opening document"), 
-                                                   MakeDisplayPath(s), "...");
-                       XFlush(fl_display);
-                       owner->view()->buffer(
-                               bufferlist.loadLyXFile(s));
-                       owner->getMiniBuffer()->Set(_("Document"),
-                                                   MakeDisplayPath(s),
-                                                   _("opened."));
-                       return;
+               while (bufferlist.exists(s) || fi.readable()) {
+                       ++newfile_number;
+                       s = lyxrc.document_path +
+                           "newfile" + tostr(newfile_number) +
+                           ".lyx";
+                       fi.newFile(s);
                }
        }
 
@@ -2839,53 +3181,66 @@ void LyXFunc::MenuOpen()
        }
 }
 
+// returns filename if file must be imported,
+// empty string if either file not found or already loaded
+// checks for running without gui are missing.
 
-void LyXFunc::doImportASCII(bool linorpar)
+void LyXFunc::doImportHelper(
+       string const & file,          // filename (possibly empty)
+       string const & text,          // info when asking for filename
+       string const & pattern,       // filetype
+       bool func(BufferView *, string const &)     // the real import function
+)
 {
-       string initpath = lyxrc.document_path;
-       LyXFileDlg fileDlg;
-  
-       if (owner->view()->available()) {
-               string trypath = owner->buffer()->filepath;
-               // If directory is writeable, use this as default.
-               if (IsDirWriteable(trypath) == 1)
-                       initpath = trypath;
-       }
+       string filename = file;
 
-       // launches dialog
-       ProhibitInput(owner->view());
-       fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
-       fileDlg.SetButton(1, _("Examples"), 
-                         AddPath(system_lyxdir, "examples"));
-       string filename = fileDlg.Select(_("Select ASCII file to Import"),
-                                        initpath, "*.txt");
-       AllowInput(owner->view());
+       if (filename.empty()) { // need user interaction
+               string initpath = lyxrc.document_path;
+               LyXFileDlg fileDlg;
+               
+               if (owner->view()->available()) {
+                       string trypath = owner->buffer()->filepath;
+                       // If directory is writeable, use this as default.
+                       if (IsDirWriteable(trypath) == 1)
+                               initpath = trypath;
+               }
+
+               // launches dialog
+               ProhibitInput(owner->view());
+               fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
+               fileDlg.SetButton(1, _("Examples"), 
+                                       AddPath(system_lyxdir, "examples"));
+               filename = fileDlg.Select(text, initpath, pattern);
+               AllowInput(owner->view());
  
-       // check selected filename
-       if (filename.empty()) {
-               owner->getMiniBuffer()->Set(_("Canceled."));
-               return;
+               // check selected filename
+               if (filename.empty()) 
+                       owner->getMiniBuffer()->Set(_("Canceled."));
        }
 
+       // still no filename? abort
+       if (filename.empty()) 
+               return;
+
        // get absolute path of file
        filename = MakeAbsPath(filename);
 
-       string s = ChangeExtension(filename, ".lyx", false);
+       string lyxfile = ChangeExtension(filename, ".lyx");
 
        // Check if the document already is open
-       if (bufferlist.exists(s)) {
+       if (bufferlist.exists(lyxfile)) {
                switch(AskConfirmation(_("Document is already open:"), 
-                                      MakeDisplayPath(s, 50),
+                                      MakeDisplayPath(lyxfile, 50),
                                       _("Do you want to close that document now?\n"
                                         "('No' will just switch to the open version)")))
                        {
                        case 1: // Yes: close the document
-                               if (!bufferlist.close(bufferlist.getBuffer(s)))
+                               if (!bufferlist.close(bufferlist.getBuffer(lyxfile)))
                                // If close is canceled, we cancel here too.
                                        return;
                                break;
                        case 2: // No: switch to the open document
-                               owner->view()->buffer(bufferlist.getBuffer(s));
+                               owner->view()->buffer(bufferlist.getBuffer(lyxfile));
                                return;
                        case 3: // Cancel: Do nothing
                                owner->getMiniBuffer()->Set(_("Canceled."));
@@ -2894,208 +3249,87 @@ void LyXFunc::doImportASCII(bool linorpar)
        }
 
        // Check if a LyX document by the same root exists in filesystem
-       FileInfo f(s, true);
+       FileInfo f(lyxfile, true);
        if (f.exist() && !AskQuestion(_("A document by the name"), 
-                                     MakeDisplayPath(s),
+                                     MakeDisplayPath(lyxfile),
                                      _("already exists. Overwrite?"))) {
                owner->getMiniBuffer()->Set(_("Canceled."));
                return;
        }
+       // filename should be valid now
 
-       owner->view()->buffer(bufferlist.newFile(s, string()));
-       owner->getMiniBuffer()->Set(_("Importing ASCII file"),
-                                   MakeDisplayPath(filename), "...");
-       // Insert ASCII file
-       InsertAsciiFile(owner->view(), filename, linorpar);
-       owner->getMiniBuffer()->Set(_("ASCII file "),
-                                   MakeDisplayPath(filename),
-                                   _("imported."));
-}
-
-
-void LyXFunc::doImportLaTeX(bool isnoweb)
-{
-       string initpath = lyxrc.document_path;
-       LyXFileDlg fileDlg;
-  
-       if (owner->view()->available()) {
-               string trypath = owner->buffer()->filepath;
-               // If directory is writeable, use this as default.
-               if (IsDirWriteable(trypath) == 1)
-                       initpath = trypath;
-       }
-
-       // launches dialog
-       ProhibitInput(owner->view());
-       fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
-       fileDlg.SetButton(1, _("Examples"), 
-                         AddPath(system_lyxdir, "examples"));
-       string filename;
-       if (isnoweb) {
-               filename = fileDlg.Select(_("Select Noweb file to Import"),
-                                         initpath, "*.nw");
-       } else {
-               filename = fileDlg.Select(_("Select LaTeX file to Import"),
-                                         initpath, "*.tex");
-       }
-       
-       AllowInput(owner->view());
-       // check selected filename
-       if (filename.empty()) {
-               owner->getMiniBuffer()->Set(_("Canceled."));
-               return;
-       }
-
-       // get absolute path of file
-       filename = MakeAbsPath(filename);
-
-       // Check if the document already is open
-       string LyXfilename = ChangeExtension(filename, ".lyx", false);
-       if (bufferlist.exists(LyXfilename)){
-               switch(AskConfirmation(_("Document is already open:"), 
-                                      MakeDisplayPath(LyXfilename, 50),
-                                      _("Do you want to close that document now?\n"
-                                        "('No' will just switch to the open version)")))
-                       {
-                       case 1: // Yes: close the document
-                               if (!bufferlist.close(bufferlist.getBuffer(LyXfilename)))
-                               // If close is canceled, we cancel here too.
-                                       return;
-                               break;
-                       case 2: // No: switch to the open document
-                               owner->view()->buffer(
-                                       bufferlist.getBuffer(LyXfilename));
-                               return;
-                       case 3: // Cancel: Do nothing
-                               owner->getMiniBuffer()->Set(_("Canceled."));
-                               return;
-                       }
-       }
+       // notify user of import ahead
+       string displaypath = MakeDisplayPath(filename);
+       owner->getMiniBuffer()->Set(_("Importing"), displaypath, "...");
 
-       // Check if a LyX document by the same root exists in filesystem
-       FileInfo f(LyXfilename, true);
-       if (f.exist() && !AskQuestion(_("A document by the name"), 
-                                     MakeDisplayPath(LyXfilename),
-                                     _("already exists. Overwrite?"))) {
-               owner->getMiniBuffer()->Set(_("Canceled."));
-               return;
-       }
+       // call real importer
+       bool result = func(owner->view(), filename);
 
-       // loads document
-       Buffer * openbuf;
-       if (!isnoweb) {
-               owner->getMiniBuffer()->Set(_("Importing LaTeX file"),
-                                           MakeDisplayPath(filename), "...");
-               ImportLaTeX myImport(filename);
-               openbuf = myImport.run();
-       } else {
-               owner->getMiniBuffer()->Set(_("Importing Noweb file"),
-                                           MakeDisplayPath(filename), "...");
-               ImportNoweb myImport(filename);
-               openbuf = myImport.run();
-       }
-       if (openbuf) {
-               owner->view()->buffer(openbuf);
-               owner->getMiniBuffer()->Set(isnoweb ?
-                                           _("Noweb file ") : _("LateX file "),
-                                           MakeDisplayPath(filename),
-                                           _("imported."));
-       } else {
-               owner->getMiniBuffer()->Set(isnoweb ?
-                                           _("Could not import Noweb file") :
-                                           _("Could not import LaTeX file"),
-                                           MakeDisplayPath(filename));
-       }
+       // we are done
+       if (result)
+               owner->getMiniBuffer()->Set(displaypath, _("imported."));
+       else
+               owner->getMiniBuffer()->Set(displaypath, _(": import failed."));
 }
 
-
-void LyXFunc::doImportLinuxDoc()
+static
+bool doImportASCIIasLines(BufferView * view, string const & filename)
 {
-       string initpath = lyxrc.document_path;
-       LyXFileDlg fileDlg;
-  
-       if (owner->view()->available()) {
-               string trypath = owner->buffer()->filepath;
-               // If directory is writeable, use this as default.
-               if (IsDirWriteable(trypath) == 1)
-                       initpath = trypath;
-       }
-
-       // launches dialog
-       ProhibitInput(owner->view());
-       fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
-       fileDlg.SetButton(1, _("Examples"), 
-                         AddPath(system_lyxdir, "examples"));
-
-       string filename = fileDlg.Select(_("Select LinuxDoc file to Import"),
-                                         initpath, "*.sgml");
-       
-       AllowInput(owner->view());
-       // check selected filename
-       if (filename.empty()) {
-               owner->getMiniBuffer()->Set(_("Canceled."));
-               return;
-       }
-
-       // get absolute path of file
-       filename = MakeAbsPath(filename);
+       view->buffer(bufferlist.newFile(filename, string()));
+       InsertAsciiFile(view, filename, false);
+       return true;
+}
 
-       // Check if the document already is open
-       string LyXfilename = ChangeExtension(filename, ".lyx", false);
-       if (bufferlist.exists(LyXfilename)){
-               switch(AskConfirmation(_("Document is already open:"), 
-                                      MakeDisplayPath(LyXfilename, 50),
-                                      _("Do you want to close that document now?\n"
-                                        "('No' will just switch to the open version)")))
-                       {
-                       case 1: // Yes: close the document
-                               if (!bufferlist.close(bufferlist.getBuffer(LyXfilename)))
-                               // If close is canceled, we cancel here too.
-                                       return;
-                               break;
-                       case 2: // No: switch to the open document
-                               owner->view()->buffer(
-                                       bufferlist.getBuffer(LyXfilename));
-                               return;
-                       case 3: // Cancel: Do nothing
-                               owner->getMiniBuffer()->Set(_("Canceled."));
-                               return;
-                       }
-       }
+static
+bool doImportASCIIasParagraphs(BufferView * view, string const & filename)
+{
+       view->buffer(bufferlist.newFile(filename, string()));
+       InsertAsciiFile(view, filename, true);
+       return true;
+}
 
-       // Check if a LyX document by the same root exists in filesystem
-       FileInfo f(LyXfilename, true);
-       if (f.exist() && !AskQuestion(_("A document by the name"), 
-                                     MakeDisplayPath(LyXfilename),
-                                     _("already exists. Overwrite?"))) {
-               owner->getMiniBuffer()->Set(_("Canceled."));
-               return;
-       }
+static
+bool doImportLaTeX(BufferView * view, string const & filename)
+{
+       ImportLaTeX myImport(filename);
+       Buffer * openbuf = myImport.run();
+       if (openbuf) { 
+               view->buffer(openbuf);
+               return true;
+       }
+       else
+               return false;
+}
 
-       // loads document
-       owner->getMiniBuffer()->Set(_("Importing LinuxDoc file"),
-                                   MakeDisplayPath(filename), "...");
+static
+bool doImportNoweb(BufferView * view, string const & filename)
+{
+       ImportNoweb myImport(filename);
+       Buffer * openbuf = myImport.run();
+       if (openbuf) { 
+               view->buffer(openbuf);
+               return true;
+       }
+       else
+               return false;
+}
 
+static
+bool doImportLinuxDoc(BufferView *, string const & filename)
+{
        // run sgml2lyx
        string tmp = lyxrc.linuxdoc_to_lyx_command + filename;
-        Systemcalls one;
+       Systemcalls one;
        Buffer * buf = 0;
 
        int result = one.startscript(Systemcalls::System, tmp);
        if (result == 0) {
-               string filename = ChangeExtension(filename, ".lyx", false);
+               string filename = ChangeExtension(filename, ".lyx");
                // File was generated without problems. Load it.
                buf = bufferlist.loadLyXFile(filename);
-               owner->view()->buffer(buf);
-               owner->getMiniBuffer()->Set(_("LinuxDoc file "),
-                                           MakeDisplayPath(filename),
-                                           _("imported."));
-       } else {
-               owner->getMiniBuffer()->Set(_("Could not import LinuxDoc file"),
-                                           MakeDisplayPath(filename));
        }
+
+       return result == 0;
 }
 
 
@@ -3151,6 +3385,36 @@ void LyXFunc::MenuInsertLyXFile(string const & filen)
        }
 }
 
+void LyXFunc::doImport(string const & argument)
+{
+       string type;
+       string filename = split(argument, type, ' ');
+       lyxerr.debug() << "LyXFunc::doImport: " << type 
+                      << " file: " << filename << endl;
+
+       if (type == "latex") 
+               doImportHelper(filename,
+                              _("Select LaTeX file to import"), "*.tex", 
+                              doImportLaTeX);
+       else if (type == "ascii") 
+               doImportHelper(filename,
+                              _("Select ASCII file to import"), "*.txt", 
+                              doImportASCIIasLines);
+       else if (type == "asciiparagraph") 
+               doImportHelper(filename,
+                              _("Select ASCII file to import"), "*.txt", 
+                              doImportASCIIasParagraphs);
+       else if (type == "noweb") 
+               doImportHelper(filename,
+                              _("Select NoWeb file to import"), "*.nw", 
+                              doImportNoweb);
+       else if (type == "linuxdoc") 
+               doImportHelper(filename,
+                              _("Select LinuxDoc file to import"), "*.doc", 
+                              doImportLinuxDoc);
+       else 
+               setErrorMessage(string(N_("Unknown import type: ")) + type);
+}
 
 void LyXFunc::reloadBuffer()
 {
@@ -3167,7 +3431,7 @@ void LyXFunc::CloseBuffer()
                        // need this otherwise SEGV may occur while trying to
                        // set variables that don't exist
                        // since there's no current buffer
-                       CloseAllBufferRelatedPopups();
+                       owner->getDialogs()->hideBufferDependent();
                }
                else {
                        owner->view()->buffer(bufferlist.first());
@@ -3178,23 +3442,15 @@ void LyXFunc::CloseBuffer()
 
 Inset * LyXFunc::getInsetByCode(Inset::Code code)
 {
-       bool found = false;
-       Inset * inset = 0;
        LyXCursor cursor = owner->view()->text->cursor;
-       LyXParagraph::size_type pos = cursor.pos;
-       LyXParagraph * par = cursor.par;
-       
-       while (par && !found) {
-               while ((inset = par->ReturnNextInsetPointer(pos))){
-                       if (inset->LyxCode() == code) {
-                               found = true;
-                               break;
-                       }
-                       ++pos;
-               } 
-               par = par->next;
+       Buffer * buffer = owner->view()->buffer();
+       for (Buffer::inset_iterator it = Buffer::inset_iterator(cursor.par(),
+                                                               cursor.pos());
+            it != buffer->inset_iterator_end(); ++it) {
+               if ((*it)->LyxCode() == code)
+                       return *it;
        }
-       return found ? inset : 0;
+       return 0;
 }