dissolve Importer 'class' to LyXFunc/Converter

[features.git] / src / LyXFunc.cpp

diff --git a/src/LyXFunc.cpp b/src/LyXFunc.cpp
index a41f0b8c988139f332ce7d6e93e2d5962a1d4611..87e6b031e4502249fe40b7094e979763d37b9a15 100644 (file)
--- a/src/LyXFunc.cpp
+++ b/src/LyXFunc.cpp
@@ -28,7 +28,9 @@
 #include "BufferList.h"
 #include "BufferParams.h"
 #include "BufferView.h"
+#include "CmdDef.h"
 #include "Color.h"
+#include "Converter.h"
 #include "Cursor.h"
 #include "CutAndPaste.h"
 #include "debug.h"
@@ -39,7 +41,6 @@
 #include "FuncRequest.h"
 #include "FuncStatus.h"
 #include "gettext.h"
-#include "Importer.h"
 #include "InsetIterator.h"
 #include "Intl.h"
 #include "KeyMap.h"
@@ -106,6 +107,8 @@ using std::pair;
 using std::string;
 using std::istringstream;
 using std::ostringstream;
+using std::find;
+using std::vector;
 
 namespace fs = boost::filesystem;
 
@@ -135,12 +138,80 @@ using support::token;
 using support::trim;
 using support::prefixIs;
 
+
 namespace Alert = frontend::Alert;
 
 extern bool quitting;
 
 namespace {
 
+
+bool import(LyXView * lv, FileName const & filename,
+                     string const & format, ErrorList & errorList)
+{
+       docstring const displaypath = makeDisplayPath(filename.absFilename());
+       lv->message(bformat(_("Importing %1$s..."), displaypath));
+
+       FileName const lyxfile(changeExtension(filename.absFilename(), ".lyx"));
+
+       string loader_format;
+       vector<string> loaders = theConverters().loaders();
+       if (find(loaders.begin(), loaders.end(), format) == loaders.end()) {
+               for (vector<string>::const_iterator it = loaders.begin();
+                    it != loaders.end(); ++it) {
+                       if (theConverters().isReachable(format, *it)) {
+                               string const tofile =
+                                       changeExtension(filename.absFilename(),
+                                               formats.extension(*it));
+                               if (!theConverters().convert(0, filename, FileName(tofile),
+                                                       filename, format, *it, errorList))
+                                       return false;
+                               loader_format = *it;
+                               break;
+                       }
+               }
+               if (loader_format.empty()) {
+                       frontend::Alert::error(_("Couldn't import file"),
+                                    bformat(_("No information for importing the format %1$s."),
+                                        formats.prettyName(format)));
+                       return false;
+               }
+       } else {
+               loader_format = format;
+       }
+
+
+       if (loader_format == "lyx") {
+               Buffer * buf = lv->loadLyXFile(lyxfile);
+               if (!buf) {
+                       // we are done
+                       lv->message(_("file not imported!"));
+                       return false;
+               }
+               updateLabels(*buf);
+               lv->setBuffer(buf);
+               lv->showErrorList("Parse");
+       } else {
+               Buffer * const b = newFile(lyxfile.absFilename(), string(), true);
+               if (b)
+                       lv->setBuffer(b);
+               else
+                       return false;
+               bool as_paragraphs = loader_format == "textparagraph";
+               string filename2 = (loader_format == format) ? filename.absFilename()
+                       : changeExtension(filename.absFilename(),
+                                         formats.extension(loader_format));
+               lv->view()->insertPlaintextFile(filename2, as_paragraphs);
+               lv->dispatch(FuncRequest(LFUN_MARK_OFF));
+       }
+
+       // we are done
+       lv->message(_("imported."));
+       return true;
+}
+
+
+
 // This function runs "configure" and then rereads lyx.defaults to
 // reconfigure the automatic settings.
 void reconfigure(LyXView & lv, string const & option)
@@ -382,7 +453,7 @@ void LyXFunc::processKeySym(KeySymbol const & keysym, KeyModifier state)
        LYXERR(Debug::KEY) << BOOST_CURRENT_FUNCTION
               << " Key [action="
               << func.action << "]["
-              << to_utf8(keyseq.print(false)) << ']'
+              << to_utf8(keyseq.print(KeySequence::Portable)) << ']'
               << endl;
 
        // already here we know if it any point in going further
@@ -390,7 +461,7 @@ void LyXFunc::processKeySym(KeySymbol const & keysym, KeyModifier state)
        // num_bytes == 0? (Lgb)
 
        if (keyseq.length() > 1)
-               lyx_view_->message(keyseq.print(true));
+               lyx_view_->message(keyseq.print(KeySequence::ForGui));
 
 
        // Maybe user can only reach the key via holding down shift.
@@ -664,6 +735,23 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
                FuncRequest func(lyxaction.lookupFunc(firstcmd));
                func.origin = cmd.origin;
                flag = getStatus(func);
+               break;
+       }
+
+       case LFUN_CALL: {
+               FuncRequest func;
+               std::string name(to_utf8(cmd.argument()));
+               if (LyX::ref().topLevelCmdDef().lock(name, func)) {
+                       func.origin = cmd.origin;
+                       flag = getStatus(func);
+                       LyX::ref().topLevelCmdDef().release(name);
+               } else {
+                       // catch recursion or unknown command definiton
+                       // all operations until the recursion or unknown command 
+                       // definiton occures are performed, so set the state to enabled
+                       enable = true;
+               }
+               break;
        }
 
        case LFUN_BUFFER_NEW:
@@ -894,7 +982,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
                case LFUN_META_PREFIX:
                        meta_fake_bit = AltModifier;
-                       setMessage(keyseq.print(true));
+                       setMessage(keyseq.print(KeySequence::ForGui));
                        break;
 
                case LFUN_BUFFER_TOGGLE_READ_ONLY: {
@@ -1316,7 +1404,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
                        break;
 
                case LFUN_SERVER_NOTIFY:
-                       dispatch_buffer = keyseq.print(false);
+                       dispatch_buffer = keyseq.print(KeySequence::Portable);
                        theServer().notifyClient(to_utf8(dispatch_buffer));
                        break;
 
@@ -1416,7 +1504,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
                                        // default type is requested
                                        data = "include";
                                InsetCommandParams p(INCLUDE_CODE, data);
-                               data = InsetIncludeMailer::params2string(p);
+                               data = InsetCommandMailer::params2string("include", p);
                                break;
                        } 
                        case BOX_CODE: {
@@ -1632,6 +1720,28 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
                        break;
                }
 
+               case LFUN_CALL: {
+                       FuncRequest func;
+                       if (LyX::ref().topLevelCmdDef().lock(argument, func)) {
+                               func.origin = cmd.origin;
+                               dispatch(func);
+                               LyX::ref().topLevelCmdDef().release(argument);
+                       } else {
+                               if (func.action == LFUN_UNKNOWN_ACTION) {
+                                       // unknown command definition
+                                       lyxerr << "Warning: unknown command definition `"
+                                                  << argument << "'"
+                                                  << endl;
+                               } else {
+                                       // recursion detected
+                                       lyxerr << "Warning: Recursion in the command definition `"
+                                                  << argument << "' detected"
+                                                  << endl;
+                               }
+                       }
+                       break;
+               }
+
                case LFUN_PREFERENCES_SAVE: {
                        lyxrc.write(makeAbsPath("preferences",
                                                package().user_support().absFilename()),
@@ -2255,7 +2365,7 @@ void LyXFunc::doImport(string const & argument)
        }
 
        ErrorList errorList;
-       Importer::Import(lyx_view_, fullname, format, errorList);
+       import(lyx_view_, fullname, format, errorList);
        // FIXME (Abdel 12/08/06): Is there a need to display the error list here?
 }
 
@@ -2311,7 +2421,7 @@ docstring const LyXFunc::viewStatusMessage()
 {
        // When meta-fake key is pressed, show the key sequence so far + "M-".
        if (wasMetaKey())
-               return keyseq.print(true) + "M-";
+               return keyseq.print(KeySequence::ForGui) + "M-";
 
        // Else, when a non-complete key sequence is pressed,
        // show the available options.