#ifndef WORKAREA_H
#define WORKAREA_H
-#include "frontends/WorkArea.h"
-
-#include "QLPainter.h"
+#include "ui_WorkAreaUi.h"
-#include "funcrequest.h"
-#include "frontends/Timeout.h"
+#include "frontends/WorkArea.h"
#include <QAbstractScrollArea>
-#include <QMouseEvent>
-#include <QResizeEvent>
-#include <QKeyEvent>
-#include <QTimer>
-#include <QPixmap>
-
-#include <queue>
+#include <QTabBar>
+#include <QTabWidget>
-class QWidget;
class QDragEnterEvent;
class QDropEvent;
-class QWheelEvent;
-class QPaintEvent;
+class QToolButton;
+class QWidget;
+
+#ifdef CursorShape
+#undef CursorShape
+#endif
namespace lyx {
-class Painter;
+class Buffer;
+class FuncRequest;
namespace frontend {
+class GuiCompleter;
class GuiView;
-/// for emulating triple click
-class double_click {
-public:
- int x;
- int y;
- Qt::MouseButton state;
- bool active;
-
- bool operator==(QMouseEvent const & e) {
- return x == e.x() && y == e.y()
- && state == e.button();
- }
-
- double_click()
- : x(0), y(0), state(Qt::NoButton), active(false) {}
-
- double_click(QMouseEvent * e)
- : x(e->x()), y(e->y()),
- state(e->button()), active(true) {}
-};
-
-/** Qt only emits mouse events when the mouse is being moved, but
- * we want to generate 'pseudo' mouse events when the mouse button is
- * pressed and the mouse cursor is below the bottom, or above the top
- * of the work area. In this way, we'll be able to continue scrolling
- * (and selecting) the text.
- *
- * This class stores all the parameters needed to make this happen.
- */
-class SyntheticMouseEvent
-{
-public:
- SyntheticMouseEvent();
-
- FuncRequest cmd;
- Timeout timeout;
- bool restart_timeout;
- int x_old;
- int y_old;
- double scrollbar_value_old;
-};
-
-/**
- * Qt-specific implementation of the work area
- * (buffer view GUI)
-*/
-class GuiWorkArea: public QAbstractScrollArea, public WorkArea
+class GuiWorkArea : public QAbstractScrollArea, public WorkArea
{
Q_OBJECT
public:
///
- GuiWorkArea(int width, int height, LyXView & lyx_view);
-
- /// return the width of the content pane
- virtual int width() const { return viewport()->width(); }
- /// return the height of the content pane
- virtual int height() const { return viewport()->height(); }
+ GuiWorkArea(QWidget *);
///
- virtual void setScrollbarParams(int height, int pos, int line_height);
-
+ GuiWorkArea(Buffer & buffer, GuiView & gv);
///
- virtual void dragEnterEvent(QDragEnterEvent * event);
+ ~GuiWorkArea();
///
- virtual void dropEvent(QDropEvent* event);
+ void init();
+ ///
+ void setBuffer(Buffer &);
+ ///
+ void setGuiView(GuiView &);
+ ///
+ void setFullScreen(bool full_screen);
+ /// is GuiView in fullscreen mode?
+ bool isFullScreen() const;
+ ///
+ void scheduleRedraw();
+ ///
+ BufferView & bufferView();
+ ///
+ BufferView const & bufferView() const;
+ ///
+ void redraw(bool update_metrics);
- /// return the widget's painter
- virtual Painter & getPainter() { return (Painter &) painter_; }
+ /// return true if the key is part of a shortcut
+ bool queryKeySym(KeySymbol const & key, KeyModifier mod) const;
+ /// Process Key pressed event.
+ /// This needs to be public because it is accessed externally by GuiView.
+ void processKeySym(KeySymbol const & key, KeyModifier mod);
- /// return the backing pixmap
- QPaintDevice * paintDevice() { return &paint_device_; }
+ bool inDialogMode() const;
+ void setDialogMode(bool mode);
- /// update the passed area.
- void update(int x, int y, int w, int h);
+ ///
+ GuiCompleter & completer();
- /// copies specified area of pixmap to screen
- virtual void expose(int x, int y, int exp_width, int exp_height);
+ Qt::CursorShape cursorShape() const;
- /// paint the cursor and store the background
- virtual void showCursor(int x, int y, int h, CursorShape shape);
+ /// Return the GuiView this workArea belongs to
+ GuiView const & view() const;
+ GuiView & view();
- /// hide the cursor
- virtual void removeCursor();
+ /// Current ratio between physical pixels and device-independent pixels
+ double pixelRatio() const;
-protected:
+public Q_SLOTS:
+ ///
+ void stopBlinkingCursor();
+ ///
+ void startBlinkingCursor();
+
+Q_SIGNALS:
+ ///
+ void titleChanged(GuiWorkArea *);
+ ///
+ void busy(bool);
+ ///
+ void bufferViewChanged();
+
+private Q_SLOTS:
+ /// Scroll the BufferView.
+ /**
+ * This is a slot for the valueChanged() signal of the vertical scrollbar.
+ * \p value value of the scrollbar.
+ */
+ void scrollTo(int value);
+ /// timer to limit triple clicks
+ void doubleClickTimeout();
+ /// toggle the cursor's visibility
+ void toggleCursor();
+ /// close this work area.
+ /// Slot for Buffer::closing signal.
+ void close();
+ /// Slot to restore proper scrollbar behaviour.
+ void fixVerticalScrollBar();
+private:
+ /// Update window titles of all users.
+ void updateWindowTitle();
+ ///
+ bool event(QEvent *);
+ ///
+ void contextMenuEvent(QContextMenuEvent *);
+ ///
+ void focusInEvent(QFocusEvent *);
+ ///
+ void focusOutEvent(QFocusEvent *);
/// repaint part of the widget
- void paintEvent(QPaintEvent * e);
+ void paintEvent(QPaintEvent * ev);
/// widget has been resized
- void resizeEvent(QResizeEvent * e);
+ void resizeEvent(QResizeEvent * ev);
/// mouse button press
- void mousePressEvent(QMouseEvent * e);
+ void mousePressEvent(QMouseEvent * ev);
/// mouse button release
- void mouseReleaseEvent(QMouseEvent * e);
+ void mouseReleaseEvent(QMouseEvent * ev);
/// mouse double click of button
- void mouseDoubleClickEvent(QMouseEvent * e);
+ void mouseDoubleClickEvent(QMouseEvent * ev);
/// mouse motion
- void mouseMoveEvent(QMouseEvent * e);
+ void mouseMoveEvent(QMouseEvent * ev);
/// wheel event
- void wheelEvent(QWheelEvent * e);
- /// key press
- void keyPressEvent(QKeyEvent * e);
+ void wheelEvent(QWheelEvent * ev);
+ /// key press event. It also knows how to handle ShortcutOverride events to
+ /// avoid code duplication.
+ void keyPressEvent(QKeyEvent * ev);
/// IM events
- void inputMethodEvent(QInputMethodEvent * e);
+ void inputMethodEvent(QInputMethodEvent * ev);
+ /// IM query
+ QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
-public Q_SLOTS:
+ /// The slot connected to SyntheticMouseEvent::timeout.
+ void generateSyntheticMouseEvent();
- /// Timeout event Slot for keyboard bufferring.
- /// \todo This is not used currently in the code, remove?
- void keyeventTimeout();
+ friend class GuiCompleter;
+ struct Private;
+ Private * const d;
+}; // GuiWorkArea
- /// Adjust the LyX buffer view with the position of the scrollbar.
- /**
- * The action argument is not used in the the code, it is there
- * only for the connection to the vertical srollbar signal which
- * emits an 'int' action.
- */
- void adjustViewWithScrollBar(int action = 0);
-private:
+class EmbeddedWorkArea : public GuiWorkArea
+{
+ Q_OBJECT
+public:
+ ///
+ EmbeddedWorkArea(QWidget *);
+ ~EmbeddedWorkArea();
- /// Our painter.
- QLPainter painter_;
+ /// Dummy methods for Designer.
+ void setWidgetResizable(bool) {}
+ void setWidget(QWidget *) {}
- /// The slot connected to SyntheticMouseEvent::timeout.
- void generateSyntheticMouseEvent();
+ QSize sizeHint () const;
+ ///
+ void disable();
+protected:
///
- SyntheticMouseEvent synthetic_mouse_event_;
+ void closeEvent(QCloseEvent * ev);
+ ///
+ void hideEvent(QHideEvent *ev);
+
+private:
+ /// Embedded Buffer.
+ Buffer * buffer_;
+}; // EmbeddedWorkArea
- /// Our client side painting device.
- QPixmap paint_device_;
- /// \todo remove
- QTimer step_timer_;
+class GuiWorkAreaContainer;
- /// \todo remove
- std::queue<boost::shared_ptr<QKeyEvent> > keyeventQueue_;
+/// A tabbed set of GuiWorkAreas.
+class TabWorkArea : public QTabWidget
+{
+ Q_OBJECT
+public:
+ TabWorkArea(QWidget * parent = 0);
- double_click dc_event_;
+ /// hide QTabWidget methods
+ GuiWorkAreaContainer * currentWidget() const;
+ GuiWorkAreaContainer * widget(int index) const;
///
- int cursor_x_;
+ void setFullScreen(bool full_screen);
+ void showBar(bool show);
+ void closeAll();
+ bool setCurrentWorkArea(GuiWorkArea *);
+ GuiWorkArea * addWorkArea(Buffer & buffer, GuiView & view);
+ bool removeWorkArea(GuiWorkArea *);
+ GuiWorkArea * currentWorkArea() const;
+ GuiWorkArea * workArea(Buffer & buffer) const;
+ GuiWorkArea * workArea(int index) const;
+ void paintEvent(QPaintEvent *);
+
+Q_SIGNALS:
///
- int cursor_y_;
+ void currentWorkAreaChanged(GuiWorkArea *);
///
- int cursor_w_;
+ void lastWorkAreaRemoved();
+
+public Q_SLOTS:
+ /// close current buffer, or the one given by \c clicked_tab_
+ void closeCurrentBuffer();
+ /// hide current tab, or the one given by \c clicked_tab_
+ void hideCurrentTab();
+ /// close the tab given by \c index
+ void closeTab(int index);
///
- int cursor_h_;
+ void moveTab(int fromIndex, int toIndex);
///
- QPixmap hcursor_;
+ void updateTabTexts();
+
+private Q_SLOTS:
///
- QPixmap vcursor_;
+ void on_currentTabChanged(int index);
///
- bool show_hcursor_;
+ void showContextMenu(const QPoint & pos);
+ /// enable closing tab on middle-click
+ void mousePressEvent(QMouseEvent * me);
+ void mouseReleaseEvent(QMouseEvent * me);
///
- bool show_vcursor_;
+ void mouseDoubleClickEvent(QMouseEvent * event);
///
- bool lshape_cursor_;
+ int indexOfWorkArea(GuiWorkArea * w) const;
+
+private:
+ using QTabWidget::addTab;
+ using QTabWidget::insertTab;
+
+ /// true if position is a tab (rather than the blank space in tab bar)
+ bool posIsTab(QPoint position);
+
+ int clicked_tab_;
///
- QColor cursor_color_;
+ int midpressed_tab_;
///
- CursorShape cursor_shape_;
+ QToolButton * closeBufferButton;
+}; // TabWorkArea
+
+
+class DragTabBar : public QTabBar
+{
+ Q_OBJECT
+public:
+ ///
+ DragTabBar(QWidget * parent = 0);
+
+protected:
+ ///
+ void mousePressEvent(QMouseEvent * event);
+ ///
+ void mouseMoveEvent(QMouseEvent * event);
+ ///
+ void dragEnterEvent(QDragEnterEvent * event);
+ ///
+ void dropEvent(QDropEvent * event);
+
+private:
+ ///
+ QPoint dragStartPos_;
+
+Q_SIGNALS:
+ ///
+ void tabMoveRequested(int fromIndex, int toIndex);
};
+
+class GuiWorkAreaContainer : public QWidget, public Ui::WorkAreaUi
+{
+ Q_OBJECT
+ // non-null
+ GuiWorkArea * const wa_;
+ void dispatch(FuncRequest f) const;
+
+private Q_SLOTS:
+ void updateDisplay();
+ void reload() const;
+ void ignore() const;
+
+protected:
+ void mouseDoubleClickEvent(QMouseEvent * event); //override
+
+public:
+ /// wa != 0
+ GuiWorkAreaContainer(GuiWorkArea * wa, QWidget * parent = 0);
+ /// non-null
+ GuiWorkArea * workArea() const { return wa_; }
+};
+
+
+
} // namespace frontend
} // namespace lyx
projects / lyx.git / blobdiff