Trivial fixes to some warnings thrown up by MSVS.Net 2003.

[lyx.git] / src / lyxfunc.C

diff --git a/src/lyxfunc.C b/src/lyxfunc.C
index a679f52b4bb2ebd19bd10c2a03ca3f65b46f3ad4..936d4916a33c47bcf7523b3862f09a7f328bbc68 100644 (file)
--- a/src/lyxfunc.C
+++ b/src/lyxfunc.C
@@ -64,6 +64,7 @@
 #include "insets/insetexternal.h"
 #include "insets/insetfloat.h"
 #include "insets/insetgraphics.h"
+#include "insets/insetinclude.h"
 #include "insets/insetnote.h"
 #include "insets/insettabular.h"
 #include "insets/insetvspace.h"
@@ -173,6 +174,28 @@ bool getStatus(LCursor cursor,
        return res;
 }
 
+
+/** Return the change status at cursor position, taking in account the
+ * status at each level of the document iterator (a table in a deleted
+ * footnote is deleted).
+ * When \param outer is true, the top slice is not looked at.
+ */
+Change::Type lookupChange(DocIterator const & dit, bool outer = false)
+{
+       size_t const depth = dit.depth() - (outer ? 1 : 0);
+
+       for (size_t i = 0 ; i < depth ; ++i) {
+               CursorSlice const & slice = dit[i];
+               if (!slice.inset().inMathed() 
+                   && slice.pos() < slice.paragraph().size()) {
+                       Change::Type const ch = slice.paragraph().lookupChange(slice.pos());
+                       if (ch != Change::UNCHANGED)
+                               return ch;
+               }
+       }
+       return Change::UNCHANGED;
+}
+
 }
 
 LyXFunc::LyXFunc(LyXView * lv)
@@ -315,6 +338,9 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
           application can still be accessed without giving focus to
           the main window. In this case, we want to disable the menu
           entries that are buffer-related.
+
+          Note that this code is not perfect, as bug 1941 attests:
+          http://bugzilla.lyx.org/show_bug.cgi?id=1941#c4
        */
        Buffer * buf;
        if (cmd.origin == FuncRequest::UI && !owner->hasFocus())
@@ -510,6 +536,12 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
                break;
        }
 
+       case LFUN_INSERT_CITATION: {
+               FuncRequest fr(LFUN_INSET_INSERT, "citation");
+               enable = getStatus(fr).enabled();
+               break;
+       }
+
        // this one is difficult to get right. As a half-baked
        // solution, we consider only the first action of the sequence
        case LFUN_SEQUENCE: {
@@ -593,6 +625,15 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
                flag.enabled(false);
        }
 
+       // Are we in a DELETED change-tracking region?
+       if (buf && buf->params().tracking_changes
+           && lookupChange(cur, true) == Change::DELETED
+           && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
+           && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
+               flag.message(N_("This portion of the document is deleted."));
+               flag.enabled(false);
+       }
+
        // the default error message if we disable the command
        if (!flag.enabled() && flag.message().empty())
                flag.message(N_("Command disabled"));
@@ -1138,7 +1179,6 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
                        string data = trim(cmd.argument.substr(name.size()));
                        if (name == "bibitem" ||
                            name == "bibtex" ||
-                           name == "include" ||
                            name == "index" ||
                            name == "label" ||
                            name == "ref" ||
@@ -1146,6 +1186,9 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
                            name == "url") {
                                InsetCommandParams p(name);
                                data = InsetCommandMailer::params2string(name, p);
+                       } else if (name == "include") {
+                               InsetCommandParams p(data);
+                               data = InsetIncludeMailer::params2string(p);
                        } else if (name == "box") {
                                // \c data == "Boxed" || "Frameless" etc
                                InsetBoxParams p(data);
@@ -1209,6 +1252,30 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
                        owner->getDialogs().disconnect(argument);
                        break;
 
+               
+               case LFUN_INSERT_CITATION: {
+                       if (!argument.empty()) {
+                               // we can have one optional argument, delimited by '|'
+                               // citation-insert <key>|<text_before>
+                               // this should be enhanced to also support text_after 
+                               // and citation style
+                               string arg = argument;
+                               string opt1;
+                               if (contains(argument, "|")) {
+                                       arg = token(argument, '|', 0);
+                                       opt1 = '[' + token(argument, '|', 1) + ']';
+                               }
+                               std::ostringstream os;
+                               os << "citation LatexCommand\n"
+                                  << "\\cite" << opt1 << "{" << arg << "}\n"
+                                  << "\\end_inset";
+                               FuncRequest fr(LFUN_INSET_INSERT, os.str());
+                               dispatch(fr);
+                       } else
+                               dispatch(FuncRequest(LFUN_DIALOG_SHOW, "citation"));
+                       break;
+               }
+
                case LFUN_CHILDOPEN: {
                        string const filename =
                                MakeAbsPath(argument, owner->buffer()->filePath());
@@ -1371,9 +1438,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
                        InsetIterator const end = inset_iterator_end(inset);
                        for (; it != end; ++it) {
                                if (inset_code == InsetBase::NO_CODE
-                                   || inset_code == it->lyxCode())
-                                       it->dispatch(cur, fr);
+                                   || inset_code == it->lyxCode()) {
+                                       LCursor tmpcur = cur;
+                                       tmpcur.pushLeft(*it);
+                                       it->dispatch(tmpcur, fr);
+                               }
                        }
+                       update = true;
                        break;
                }
 
@@ -1450,7 +1521,6 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
                }
 
                case LFUN_TEXTCLASS_APPLY: {
-                       recordUndoFullDocument(view());
                        Buffer * buffer = owner->buffer();
 
                        lyx::textclass_type const old_class =
@@ -1470,6 +1540,8 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
                                break;
 
                        owner->message(_("Converting document to new document class..."));
+                       recordUndoFullDocument(view());
+                       buffer->params().textclass = new_class;
                        StableDocIterator backcur(view()->cursor());
                        ErrorList el;
                        lyx::cap::SwitchBetweenClasses(
@@ -1541,8 +1613,15 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & cmd)
 {
-       owner->updateMenubar();
-       owner->updateToolbars();
+       /* When an action did not originate from the UI/kbd, it makes
+        * sense to avoid updating the GUI. It turns out that this
+        * fixes bug 1941, for reasons that are described here:
+        * http://bugzilla.lyx.org/show_bug.cgi?id=1941#c4 
+        */
+       if (cmd.origin != FuncRequest::INTERNAL) {
+               owner->updateMenubar();
+               owner->updateToolbars();
+       }
 
        const bool verbose = (cmd.origin == FuncRequest::UI
                              || cmd.origin == FuncRequest::COMMANDBUFFER);