RandomAccessList.h
SignalSlot.h
SignalSlotPrivate.h
+ ProgressInterface.h
Systemcall.h
+ SystemcallPrivate.h
Timeout.h
Translator.h
convert.h
Path.cpp
SignalSlot.cpp
Systemcall.cpp
+ SystemcallPrivate.cpp
Timeout.cpp
abort.cpp
convert.cpp
GuiPopupMenu.h
GuiPrefs.h
GuiPrint.h
+ GuiProgress.h
GuiRef.h
GuiSearch.h
GuiSelection.h
GuiParagraph.cpp
GuiPopupMenu.cpp
GuiPrefs.cpp
+ GuiProgress.cpp
GuiPrint.cpp
GuiRef.cpp
GuiSearch.cpp
Item "Fold Math Macro" "math-macro-fold"
Separator
Item "View Source|S" "dialog-toggle view-source"
+ Item "View LaTeX Progress|" "dialog-toggle latex-progress"
Submenu "Update|U" "view_update"
ViewFormats
Separator
if (output_preamble) {
if (!runparams.nice) {
// code for usual, NOT nice-latex-file
- os << "\\batchmode\n"; // changed
- // from \nonstopmode
+ os << "\\nonstopmode\n";
d->texrow.newline();
}
if (!original_path.empty()) {
int LaTeX::startscript()
{
// onlyFilename() is needed for cygwin
- string tmp = cmd + ' '
- + quoteName(onlyFilename(file.toFilesystemEncoding()))
- + " > " + os::nulldev();
- Systemcall one;
- return one.startscript(Systemcall::Wait, tmp);
+ string tmp = cmd + ' ' + "-max-print-line=200 "
+ + quoteName(onlyFilename(file.toFilesystemEncoding()));
+ return Systemcall().startscript(Systemcall::Wait, tmp);
}
--- /dev/null
+// -*- C++ -*-
+/**
+ * \file GuiProgress.cpp
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Peter Kümmel
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#include <config.h>
+
+#include "GuiProgress.h"
+
+#include "support/Systemcall.h"
+
+#include <QApplication>
+
+
+namespace lyx {
+namespace frontend {
+
+
+GuiProgress::GuiProgress(GuiView & parent, Qt::DockWidgetArea area,
+ Qt::WindowFlags flags) : DockView(parent, "latex-progress", area, flags)
+{
+ setWindowTitle(qt_("LaTeX Progress"));
+ setWidget(&text_edit);
+ lyx::support::Systemcall::registerProgressInterface(this);
+}
+
+
+void GuiProgress::appendMessage(QString const & msg)
+{
+ text_edit.append(msg);
+ // QEventLoop::ExcludeUserInputEvents:
+ // don't allow user inputs while processing a document
+ // if we allow it, we open will Pandora's Box of multithreading
+ QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
+}
+
+
+void GuiProgress::clearMessages()
+{
+ text_edit.clear();
+}
+
+
+Dialog * createGuiProgress(GuiView & lv)
+{
+ GuiView & guiview = static_cast<GuiView &>(lv);
+#ifdef Q_WS_MACX
+ // TODO where to show up on the Mac?
+ //return new GuiProgress(guiview, Qt::RightDockWidgetArea, Qt::Drawer);
+#else
+ return new GuiProgress(guiview, Qt::BottomDockWidgetArea);
+#endif
+}
+
+} // namespace frontend
+} // namespace lyx
+
+
--- /dev/null
+// -*- C++ -*-
+/**
+ * \file GuiProgress.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Peter Kümmel
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#ifndef GUIPROGRESS_H
+#define GUIPROGRESS_H
+
+#include "support/ProgressInterface.h"
+
+#include "DockView.h"
+
+#include <QTextEdit>
+
+#include <string>
+
+
+namespace lyx {
+namespace frontend {
+
+
+class GuiProgress :
+ public DockView,
+ public lyx::support::ProgressInterface
+{
+
+public:
+ GuiProgress(
+ GuiView & parent, ///< the main window where to dock.
+ Qt::DockWidgetArea area, ///< Position of the dock (and also drawer)
+ Qt::WindowFlags flags = 0);
+
+ void appendMessage(QString const &);
+ void clearMessages();
+
+ /// Controller inherited method.
+ ///@{
+ bool initialiseParams(std::string const & source) { return true; }
+ void clearParams() {}
+ void dispatchParams() {}
+ bool isBufferDependent() const { return true; }
+ bool canApply() const { return true; }
+ bool canApplyToReadOnly() const { return true; }
+ void updateView() {}
+ ///@}
+
+private:
+ QTextEdit text_edit;
+};
+
+
+} // namespace frontend
+} // namespace lyx
+
+#endif
+
#include "GuiMenubar.h"
#include "GuiToolbar.h"
#include "GuiToolbars.h"
+#include "GuiProgress.h"
#include "qt_helpers.h"
"thesaurus",
#endif
-"texinfo", "toc", "href", "view-source", "vspace", "wrap", "listings" };
+"texinfo", "toc", "href", "view-source", "latex-progress", "vspace", "wrap", "listings" };
char const * const * const end_dialognames =
dialognames + (sizeof(dialognames) / sizeof(char *));
Dialog * createGuiHyperlink(GuiView & lv);
Dialog * createGuiVSpace(GuiView & lv);
Dialog * createGuiViewSource(GuiView & lv);
+Dialog * createGuiProgress(GuiView & lv);
Dialog * createGuiWrap(GuiView & lv);
return createGuiLog(*this);
if (name == "view-source")
return createGuiViewSource(*this);
+ if (name == "latex-progress")
+ return createGuiProgress(*this);
if (name == "mathdelimiter")
return createGuiDelimiter(*this);
if (name == "mathmatrix")
GuiPopupMenu.cpp \
GuiPrefs.cpp \
GuiPrint.cpp \
+ GuiProgress.cpp \
GuiRef.cpp \
GuiSearch.cpp \
GuiSelection.cpp \
GuiPopupMenu.h \
GuiPrefs.h \
GuiPrint.h \
+ GuiProgress.h \
GuiRef.h \
GuiSearch.h \
GuiSelection.h \
strfwd.h \
Systemcall.cpp \
Systemcall.h \
+ SystemcallPrivate.cpp \
+ SystemcallPrivate.h \
+ ProgressInterface.h \
SignalSlot.cpp \
SignalSlot.h \
SignalSlotPrivate.h \
--- /dev/null
+// -*- C++ -*-
+/**
+ * \file ProgressInterface.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Peter Kümmel
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#ifndef LYX_SUPPORT_PROGRESSINTERFACE_H
+#define LYX_SUPPORT_PROGRESSINTERFACE_H
+
+class QString;
+
+namespace lyx {
+namespace support {
+
+
+class ProgressInterface
+{
+public:
+ virtual ~ProgressInterface() {}
+
+ virtual void appendMessage(QString const &) = 0;
+ virtual void clearMessages() = 0;
+
+protected:
+ ProgressInterface() {}
+};
+
+
+} // namespace support
+} // namespace lyx
+
+#endif // LYX_SUPPORT_PROGRESSINTERFACE_H
+
* Licence details can be found in the file COPYING.
*
* \author Asger Alstrup
+ * \author Peter Kümmel
*
* Interface cleaned up by
* \author Angus Leeming
#include <config.h>
#include "support/Systemcall.h"
-#include "support/os.h"
+#include "support/SystemcallPrivate.h"
+#include "support/ProgressInterface.h"
-#include <cstdlib>
+namespace lyx {
+namespace support {
-using std::string;
+static ProgressInterface* progress_impl = 0;
-#ifndef CXX_GLOBAL_CSTD
-using std::system;
-#endif
-namespace lyx {
-namespace support {
+void Systemcall::registerProgressInterface(ProgressInterface* p)
+{
+ progress_impl = p;
+}
-// Reuse of instance
-int Systemcall::startscript(Starttype how, string const & what)
+
+ProgressInterface* Systemcall::progress()
+{
+ return progress_impl;
+}
+
+
+int Systemcall::startscript(Starttype how, std::string const & what)
{
- string command = what;
-
- if (how == DontWait) {
- switch (os::shell()) {
- case os::UNIX:
- command += " &";
- break;
- case os::CMD_EXE:
- command = "start /min " + command;
- break;
- }
- }
-
- return ::system(command.c_str());
+ // TODO Reuse of instance?
+ SystemcallPrivate* process = new SystemcallPrivate;
+ if (how == Wait)
+ return process->start(what, true);
+ return process->start(what, false);
}
+
} // namespace support
} // namespace lyx
* Licence details can be found in the file COPYING.
*
* \author Asger Alstrup
+ * \author Peter Kümmel
*
* Interface cleaned up by
* \author Angus Leeming
namespace lyx {
namespace support {
+class ProgressInterface;
+
/**
* An instance of Class Systemcall represents a single child process.
*
- * Class Systemcall uses system() to launch the child process.
+ * Class Systemcall uses SystemcallPrivate to launch the child process.
* The user can choose to wait or not wait for the process to complete, but no
* callback is invoked upon completion of the child.
*
* by spaces.
*/
int startscript(Starttype how, std::string const & what);
+
+ static void registerProgressInterface(ProgressInterface*);
+ static ProgressInterface* progress();
};
} // namespace support
--- /dev/null
+// -*- C++ -*-
+/**
+ * \file SystemcallPrivate.cpp
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Peter Kümmel
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#include <config.h>
+
+#include "SystemcallPrivate.h"
+
+#include "Systemcall.h"
+#include "ProgressInterface.h"
+
+#include "gettext.h"
+#include "qstring_helpers.h"
+
+
+namespace lyx {
+namespace support {
+
+
+// TODO should we move qt_ to qstring_helpers?
+static
+QString const qt_(char const * str)
+{
+ return toqstr(_(str));
+}
+
+
+
+SystemcallPrivate::SystemcallPrivate()
+{
+ ProgressInterface* progress = Systemcall::progress();
+ if (progress) {
+ connect(&process, SIGNAL(readyReadStandardOutput()), this, SLOT(newProcessOutput()));
+ connect(&process, SIGNAL(started()), this, SLOT(processStarted()));
+ connect(&process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
+ connect(&process, SIGNAL(finished(int, QProcess::ExitStatus)),
+ this, SLOT(processFinished(int, QProcess::ExitStatus)));
+ }
+}
+
+
+int SystemcallPrivate::start(const std::string& cmd, bool waitForFinished)
+{
+ ProgressInterface* progress = Systemcall::progress();
+ if (progress) {
+ progress->clearMessages();
+ progress->appendMessage(qt_("Starting LaTex with command "));
+ progress->appendMessage(cmd.c_str());
+ }
+
+ process.setReadChannel(QProcess::StandardOutput);
+ process.start(cmd.c_str(), QStringList(), QIODevice::ReadOnly);
+ // wait some seconds until the process has started
+ process.waitForStarted(10 * 1000);
+ if (waitForFinished) {
+ // with waitForFinished(-1); we only get one signal per run
+ while (process.state() == QProcess::Running)
+ process.waitForFinished(500);
+ return process.exitCode();
+ }
+ if (process.state() != QProcess::Running) {
+ process.kill();
+ // TODO this needs more testing
+ deleteLater();
+ return -1;
+ }
+ return 0;
+}
+
+
+void SystemcallPrivate::newProcessOutput()
+{
+ ProgressInterface* progress = Systemcall::progress();
+ if (progress) {
+ const QString output = QString::fromLocal8Bit(process.readAllStandardOutput());
+ progress->appendMessage(output);
+ }
+}
+
+
+void SystemcallPrivate::processStarted()
+{
+ ProgressInterface* progress = Systemcall::progress();
+ if (progress) {
+ progress->appendMessage(qt_("LaTex started\n"));
+ }
+}
+
+
+void SystemcallPrivate::processError(QProcess::ProcessError)
+{
+ ProgressInterface* progress = Systemcall::progress();
+ if (progress) {
+ progress->appendMessage(qt_("LaTex error\n"));
+ }
+}
+
+
+void SystemcallPrivate::processFinished(int, QProcess::ExitStatus)
+{
+ deleteLater();
+}
+
+
+} // namespace support
+} // namespace lyx
+
+#include "SystemcallPrivate_moc.cpp"
--- /dev/null
+// -*- C++ -*-
+/**
+ * \file SystemcallPrivate.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Peter Kümmel
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#ifndef LYX_SUPPORT_SYSTEMCALLPRIVATE_H
+#define LYX_SUPPORT_SYSTEMCALLPRIVATE_H
+
+#include <QObject>
+#include <QProcess>
+
+#include <string>
+
+
+namespace lyx {
+namespace support {
+
+class ProgressInterface;
+
+class SystemcallPrivate : public QObject
+{
+ Q_OBJECT
+
+public:
+ SystemcallPrivate();
+
+ // When waitForFinished == true : returns the exit code of the process
+ // When waitForFinished == false: returns 0 if the process could be started
+ int start(const std::string& cmd, bool waitForFinished);
+
+public Q_SLOTS:
+ void newProcessOutput();
+ void processStarted();
+ void processError(QProcess::ProcessError);
+ void processFinished(int, QProcess::ExitStatus);
+
+private:
+ QProcess process;
+};
+
+
+} // namespace support
+} // namespace lyx
+
+#endif // LYX_SUPPORT_SYSTEMCALLPRIVATE_H
projects / features.git / commitdiff