* Full author contact details are available in file CREDITS.
*/
-#ifndef LYX_APPLICATION_H
-#define LYX_APPLICATION_H
+#ifndef APPLICATION_H
+#define APPLICATION_H
-#include <boost/function.hpp>
+#include "ColorCode.h"
+#include "FuncCode.h"
+
+#include "KeyModifier.h"
+
+#include "support/strfwd.h"
+
+#include <functional>
+
+#include <vector>
-#include <string>
namespace lyx {
class BufferView;
-class LyXView;
-class LColor_color;
+class Buffer;
+class DispatchResult;
+class docstring_list;
+class FuncRequest;
+class FuncStatus;
+class Inset;
+class Lexer;
struct RGBColor;
namespace frontend {
class Clipboard;
class FontLoader;
-class Gui;
class Selection;
/// The main application class
There should be only one instance of this class. No Qt object
initialisation should be done before the instanciation of this class.
-\todo The work areas handling could be moved to a base virtual class
-common to all frontends.
+ Model/View/Controller separation at frontend level in LyX-qt4:
+
+ BufferList (N Buffers)
+ |
+ Buffer-a
+ Buffer-b
+ Buffer-c
+ Buffer-d
+
+ Application (this is the frontend really, should probably be renamed).
+ |
+ GuiView-1 (one or more in case of split-view mode).
+ | |
+ | <tab-widget-1-1>
+ | | |
+ | | WorkArea-1-1-1 (M1-1 WorkAreas, M1-1 <= N)
+ | | | |
+ | | | BufferView <-----------> Buffer-c
+ | | | |
+ | | | Cursor
+ | | |
+ | | WorkArea-1-1-2
+ | | | |
+ | | | BufferView <-----------> Buffer-a
+ | | | |
+ | | | Cursor
+ | |
+ | <tab-widget-1-2>
+ |
+ GuiView-2 (one or more in case of split-view mode).
+ | |
+ | <tab-widget-2-1>
+ | | |
+ | | WorkArea-2-1-1 (M2-1 WorkAreas, M2-1 <= N, M2-1 independent of M1-1)
+ ...
+
- Model/View/Controller separation in LyX:
-
1) The Model: \c Buffer
The Buffer is the in-memory representation of a LyX file format. The
Buffer does not (should not) have any information on what part of it
is represented on screen. There is one unique Buffer per opened LyX
- file.
+ file. A Buffer may or may not be represented on screen; typically, a
+ child document does not have an associated BufferView unless the user
+ choose to visualize it.
+
-
- 2) The Controller: \c BufferView / \c Painter
+ 2) The Controller: \c BufferView / \c Painter \c Cursor
- The BufferView is a tool used by the view that translates a part of
- the Buffer contents into drawing routines. The BufferView asks each
- inset of the Buffer to draw itself onto the screen using the Painter.
- There can be only one Buffer displayed in a BufferView. While there
- is the possibility to switch Buffer inside the BufferView, the goal
- is to instantiate a new BufferView on each Buffer switch.
+ The BufferView is a tool used by the view (\sa WorkArea) that
+ translates a part of the Buffer contents into drawing routines. The
+ BufferView asks each inset of the Buffer to draw itself onto the
+ screen using the Painter. There can be only one Buffer displayed in
+ a BufferView and it is set on construction. Ideally, a BufferView
+ should not be able to change the contents of its associated Buffer.
+ A BufferView is instanciated and destroyed by a \c WorkArea; it is
+ automatically destroyed by the parent WorkArea when its Buffer is
+ closed.
- \todo Instantiate a new BufferView on each Buffer switch.
+ \todo Move all Buffer changing LFUN to Buffer::dispatch(),
+ LyXFunc::dispatch() or Cursor::dispatch().
+ \todo BufferView::buffer() should only offer const access.
The \c Painter is just a virtual interface to formalize each kind of
drawing routines (text, line, rectangle, etc).
-
+
The \c BufferView also contains a Cursor which may or may not be
visible on screen. The cursor is really just a bookmark to remember
where the next Buffer insertion/deletion is going to take place.
-
+
3) The View: \c WorkArea (and it's qt4 specialisation GuiWorkArea)
This contains the real screen area where the drawing is done by the
- Painter. One WorkArea holds one unique \c BufferView. While it could be
- possible that multiple WorkArea share one BufferView, this is not
- possible right now.
+ Painter. One WorkArea holds one unique \c BufferView. While it could
+ be possible that multiple WorkArea share one BufferView, this is not
+ something desirable because a BufferView is dependent of the WorkArea
+ size.
The WorkArea also provide a scrollbar which position is translated
into scrolling command to the inner \c BufferView.
- select char
- etc.
-
- 4) The Window: \c LyXView (and its qt4 specialisation \c GuiView)
-
- This is a full window containing a menubar, toolbars, a tabbar and a
- WorkArea. One LyXView could in theory contain multiple WorkArea
- (ex: with split window) but this number is limited to one only for
- now. In any case, there would be only one WorkArea that gets the focus
+
+ 4) The Window: \c GuiView
+
+ This is a full window containing a menubar, toolbars and a central
+ widget. A GuiView is in charge of creating and closing a View for a
+ given Buffer.
+ In the qt4 specialisation, \c GuiView, the central widget is a tab
+ widget. Each tab is reverved to the visualisation of one Buffer and
+ contains one WorkArea. In the qt4 frontend, one GuiView thus contains
+ multiple WorkAreas but this number can limited to one for another
+ frontend. The idea is that the kernel should not know how a Buffer
+ is displayed on screen; it's the frontend business.
+ It is also possible to have multiple Workareas showing
+ simultaneously in the same GuiView (ex: with split window), thus
+ sharing the menubar and toolbars.
+
+ In any case, there should be only one WorkArea that gets the focus
at a time.
- Now, concerning the TabBar versus TabWidget issue. Right now, there is
- only one WorkArea and the TabBar just used to tell the BufferView inside
- the WorkArea to switch to this another Buffer.
+ With our current implementation using a QTabWidget, each Tab own its
+ own \c WorkArea. Clicking on a tab switch a WorkArea and not really
+ a Buffer. LFUN_BUFFER_SWITCH will tell the frontend to search the
+ WorkArea associated to this Buffer. The WorkArea is automatically
+ created if not already present.
+
+ A WorkArea is connected to the Buffer::closing signal and is thus
+ automatically destroyed when its Buffer is closed.
- With a TabWidget, each Tab would own its own \c WorkArea. Clicking on a tab
- would switch a WorkArea instead of a Buffer.
*/
class Application
{
public:
///
- Application(int & argc, char ** argv);
+ Application() {}
///
virtual ~Application() {}
+ /// LyX dispatcher: executes lyx actions and does necessary
+ /// screen updates depending on results.
+ /// This method encapsulates all the LyX command operations.
+ /// This is the class of the LyX's "high level event handler".
+ /// Every user command is processed here, either invocated from
+ /// keyboard or from the GUI. All GUI objects, including buttons and
+ /// menus should use this class and never call kernel functions directly.
+ virtual DispatchResult const & dispatch(FuncRequest const &) = 0;
+
+ /// LyX dispatcher: executes lyx actions and returns result.
+ virtual void dispatch(FuncRequest const &, DispatchResult & dr) = 0;
+
+ ///
+ virtual FuncStatus getStatus(FuncRequest const & cmd) const = 0;
+
+ /// Load files and restore GUI Session.
+ virtual void restoreGuiSession() = 0;
+
///
- virtual Gui & gui() = 0;
+ virtual Buffer const * updateInset(Inset const * inset) const = 0;
/// Start the main event loop.
/// The batch command is programmed to be execute once
/// the event loop is started.
- virtual int const exec() = 0;
+ virtual int exec() = 0;
/// Quit running LyX.
/**
*/
virtual void exit(int status) = 0;
- /**
- * Synchronise all pending events.
- */
- virtual void syncEvents() = 0;
- ///
- virtual Clipboard & clipboard() = 0;
- ///
- virtual Selection & selection() = 0;
- ///
- virtual FontLoader & fontLoader() = 0;
-
- /// return a suitable serif font name.
- virtual std::string const romanFontName() = 0;
-
- /// return a suitable sans serif font name.
- virtual std::string const sansFontName() = 0;
-
- /// return a suitable monospaced font name.
- virtual std::string const typewriterFontName() = 0;
-
/**
* Given col, fills r, g, b in the range 0-255.
* The function returns true if successful.
* It returns false on failure and sets r, g, b to 0.
*/
- virtual bool getRgbColor(LColor_color col, RGBColor & rgbcol) = 0;
-
- /** Eg, passing LColor::black returns "000000",
- * passing LColor::white returns "ffffff".
- */
- virtual std::string const hexName(LColor_color col) = 0;
+ virtual bool getRgbColor(ColorCode col, RGBColor & rgbcol) = 0;
+ /// Like getRgbColor(), but static and slower
+ static bool getRgbColorUncached(ColorCode col, RGBColor & rgbcol);
- /**
- * update an altered GUI color
+ /** Eg, passing Color_black returns "000000",
+ * passing Color_white returns "ffffff".
*/
- virtual void updateColor(LColor_color col) = 0;
+ virtual std::string const hexName(ColorCode col) = 0;
/**
* add a callback for socket read notification
* @param fd socket descriptor (file/socket/etc)
*/
- virtual void registerSocketCallback(
- int fd, boost::function<void()> func) = 0;
+ typedef std::function<void()> SocketCallback;
+ virtual void registerSocketCallback(int fd, SocketCallback func) = 0;
/**
* remove a I/O read callback
*/
virtual void unregisterSocketCallback(int fd) = 0;
- /// Create the main window with given geometry settings.
- LyXView & createView(unsigned int width, unsigned int height,
- int posx, int posy, bool maximize, unsigned int iconSizeXY,
- const std::string & geometryArg);
-
- ///
- LyXView const * currentView() const;
+ virtual bool searchMenu(FuncRequest const & func,
+ docstring_list & names) const = 0;
- ///
- LyXView * currentView();
+ /// \return the icon file name for the given action.
+ static docstring iconName(FuncRequest const & f, bool unknown);
+ /// \return the math icon name for the given command.
+ static docstring mathIcon(docstring const & c);
- ///
- void setCurrentView(LyXView & current_view);
+ /// Handle a accented char key sequence
+ /// FIXME: this is only needed for LFUN_ACCENT_* in Text::dispatch()
+ virtual void handleKeyFunc(FuncCode action) = 0;
-private:
- /// This LyXView is the one receiving Clipboard and Selection
- /// Events
- LyXView * current_view_;
+ /// Start a long operation with some cancel possibility (button or ESC)
+ virtual void startLongOperation() = 0;
+ /// This needs to be periodically called to avoid freezing the GUI
+ virtual bool longOperationCancelled() = 0;
+ /// Stop the long operation mode (i.e., release the GUI)
+ virtual void stopLongOperation() = 0;
+ /// A started long operation is still in progress ?
+ virtual bool longOperationStarted() = 0;
-}; // Application
+ // Add a buffer to the current view, do not switch to it.
+ virtual bool unhide(Buffer * buf) = 0;
+};
+
+/// Return the list of loadable formats.
+std::vector<std::string> loadableImageFormats();
} // namespace frontend
frontend::Application * theApp();
frontend::Application * createApplication(int & argc, char * argv[]);
-
+void hideDialogs(std::string const & name, Inset * inset);
+/// Set locale correctly using LyXRC::gui_language
+void setLocale();
} // namespace lyx
-#endif // LYX_APPLICATION_H
+#endif // APPLICATION_H
projects / lyx.git / blobdiff