src/frontends/qt4/GuiWorkArea.h

   1 // -*- C++ -*-
   2 /**
   3  * \file GuiWorkArea.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author John Levon
   8  * \author Abdelrazak Younes
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #ifndef WORKAREA_H
  14 #define WORKAREA_H
  15
  16 #include "frontends/WorkArea.h"
  17
  18 #include "DocIterator.h"
  19 #include "FuncRequest.h"
  20 #include "qt_helpers.h"
  21 #include "support/docstring.h"
  22 #include "support/Timeout.h"
  23
  24 #include <QAbstractScrollArea>
  25 #include <QMouseEvent>
  26 #include <QPixmap>
  27 #include <QResizeEvent>
  28 #include <QTabBar>
  29 #include <QTabWidget>
  30 #include <QTimer>
  31
  32 class QContextMenuEvent;
  33 class QDragEnterEvent;
  34 class QDropEvent;
  35 class QKeyEvent;
  36 class QWheelEvent;
  37 class QPaintEvent;
  38 class QToolButton;
  39 class QWidget;
  40
  41 #ifdef CursorShape
  42 #undef CursorShape
  43 #endif
  44
  45 namespace lyx {
  46
  47 class Buffer;
  48
  49 namespace frontend {
  50
  51 class GuiCompleter;
  52 class GuiView;
  53 class GuiWorkArea;
  54
  55 /// for emulating triple click
  56 class DoubleClick {
  57 public:
  58         ///
  59         DoubleClick() : state(Qt::NoButton), active(false) {}
  60         ///
  61         DoubleClick(QMouseEvent * e) : state(e->button()), active(true) {}
  62         ///
  63         bool operator==(QMouseEvent const & e) { return state == e.button(); }
  64         ///
  65 public:
  66         ///
  67         Qt::MouseButton state;
  68         ///
  69         bool active;
  70 };
  71
  72 /** Qt only emits mouse events when the mouse is being moved, but
  73  *  we want to generate 'pseudo' mouse events when the mouse button is
  74  *  pressed and the mouse cursor is below the bottom, or above the top
  75  *  of the work area. In this way, we'll be able to continue scrolling
  76  *  (and selecting) the text.
  77  *
  78  *  This class stores all the parameters needed to make this happen.
  79  */
  80 class SyntheticMouseEvent
  81 {
  82 public:
  83         SyntheticMouseEvent();
  84
  85         FuncRequest cmd;
  86         Timeout timeout;
  87         bool restart_timeout;
  88         int x_old;
  89         int y_old;
  90         double scrollbar_value_old;
  91 };
  92
  93
  94 /**
  95  * Implementation of the work area (buffer view GUI)
  96 */
  97 class CursorWidget;
  98
  99 class GuiWorkArea : public QAbstractScrollArea, public WorkArea
 100 {
 101         Q_OBJECT
 102
 103 public:
 104         ///
 105         GuiWorkArea(QWidget *);
 106         ///
 107         GuiWorkArea(Buffer & buffer, GuiView & gv);
 108         ///
 109         ~GuiWorkArea();
 110
 111         ///
 112         void init();
 113         ///
 114         void setBuffer(Buffer &);
 115         ///
 116         void setGuiView(GuiView &);
 117         ///
 118         void setFullScreen(bool full_screen);
 119         /// is LyXView in fullscreen mode?
 120         bool isFullScreen();
 121         ///
 122         void scheduleRedraw() { schedule_redraw_ = true; }
 123         ///
 124         BufferView & bufferView();
 125         ///
 126         BufferView const & bufferView() const;
 127         ///
 128         void redraw();
 129         ///
 130         void stopBlinkingCursor();
 131         ///
 132         void startBlinkingCursor();
 133         /// Process Key pressed event.
 134         /// This needs to be public because it is accessed externally by GuiView.
 135         void processKeySym(KeySymbol const & key, KeyModifier mod);
 136         ///
 137         void resizeBufferView();
 138
 139         bool inDialogMode() const { return dialog_mode_; }
 140         void setDialogMode(bool mode) { dialog_mode_ = mode; }
 141
 142         ///
 143         GuiCompleter & completer() { return *completer_; }
 144
 145
 146         /// Return the GuiView this workArea belongs to
 147         GuiView const & view() const { return *lyx_view_; }
 148         GuiView & view() { return *lyx_view_; }
 149
 150 Q_SIGNALS:
 151         ///
 152         void titleChanged(GuiWorkArea *);
 153
 154 private Q_SLOTS:
 155         /// Scroll the BufferView.
 156         /**
 157           * This is a slot for the valueChanged() signal of the vertical scrollbar.
 158           * \p value value of the scrollbar.
 159         */
 160         void scrollTo(int value);
 161         /// timer to limit triple clicks
 162         void doubleClickTimeout();
 163         /// toggle the cursor's visibility
 164         void toggleCursor();
 165         /// close this work area.
 166         /// Slot for Buffer::closing signal.
 167         void close();
 168         /// Slot to restore proper scrollbar behaviour.
 169         void fixVerticalScrollBar();
 170
 171 private:
 172         friend class GuiCompleter;
 173
 174         /// update the passed area.
 175         void update(int x, int y, int w, int h);
 176         ///
 177         void updateScreen();
 178
 179         /// paint the cursor and store the background
 180         virtual void showCursor(int x, int y, int h,
 181                 bool l_shape, bool rtl, bool completable);
 182
 183         /// hide the cursor
 184         virtual void removeCursor();
 185
 186         /// This function is called when the buffer readonly status change.
 187         void setReadOnly(bool);
 188
 189         /// Update window titles of all users.
 190         void updateWindowTitle();
 191         ///
 192         bool event(QEvent *);
 193         ///
 194         void contextMenuEvent(QContextMenuEvent *);
 195         ///
 196         void focusInEvent(QFocusEvent *);
 197         ///
 198         void focusOutEvent(QFocusEvent *);
 199         /// repaint part of the widget
 200         void paintEvent(QPaintEvent * ev);
 201         /// widget has been resized
 202         void resizeEvent(QResizeEvent * ev);
 203         /// mouse button press
 204         void mousePressEvent(QMouseEvent * ev);
 205         /// mouse button release
 206         void mouseReleaseEvent(QMouseEvent * ev);
 207         /// mouse double click of button
 208         void mouseDoubleClickEvent(QMouseEvent * ev);
 209         /// mouse motion
 210         void mouseMoveEvent(QMouseEvent * ev);
 211         /// wheel event
 212         void wheelEvent(QWheelEvent * ev);
 213         /// key press
 214         void keyPressEvent(QKeyEvent * ev);
 215         /// IM events
 216         void inputMethodEvent(QInputMethodEvent * ev);
 217         /// IM query
 218         QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
 219
 220         /// The slot connected to SyntheticMouseEvent::timeout.
 221         void generateSyntheticMouseEvent();
 222         ///
 223         void dispatch(FuncRequest const & cmd0, KeyModifier = NoModifier);
 224         /// hide the visible cursor, if it is visible
 225         void hideCursor();
 226         /// show the cursor if it is not visible
 227         void showCursor();
 228         ///
 229         void updateScrollbar();
 230
 231         ///
 232         BufferView * buffer_view_;
 233         ///
 234         GuiView * lyx_view_;
 235         /// is the cursor currently displayed
 236         bool cursor_visible_;
 237
 238         ///
 239         QTimer cursor_timeout_;
 240         ///
 241         SyntheticMouseEvent synthetic_mouse_event_;
 242         ///
 243         DoubleClick dc_event_;
 244
 245         ///
 246         CursorWidget * cursor_;
 247         ///
 248         QPixmap screen_;
 249         ///
 250         bool need_resize_;
 251         ///
 252         bool schedule_redraw_;
 253         ///
 254         int preedit_lines_;
 255
 256         ///
 257         GuiCompleter * completer_;
 258
 259         /// Special mode in which Esc and Enter (with or without Shift)
 260         /// are ignored
 261         bool dialog_mode_;
 262 }; // GuiWorkArea
 263
 264
 265 class EmbeddedWorkArea : public GuiWorkArea
 266 {
 267         Q_OBJECT
 268 public:
 269         ///
 270         EmbeddedWorkArea(QWidget *);
 271         ~EmbeddedWorkArea();
 272
 273         /// Dummy methods for Designer.
 274         void setWidgetResizable(bool) {}
 275         void setWidget(QWidget *) {}
 276
 277         ///
 278         void disable();
 279
 280 protected:
 281         ///
 282         void closeEvent(QCloseEvent * ev);
 283         ///
 284         void hideEvent(QHideEvent *ev);
 285
 286 private:
 287         /// Embedded Buffer.
 288         Buffer * buffer_;
 289 }; // EmbeddedWorkArea
 290
 291
 292 /// A tabbed set of GuiWorkAreas.
 293 class TabWorkArea : public QTabWidget
 294 {
 295         Q_OBJECT
 296 public:
 297         TabWorkArea(QWidget * parent = 0);
 298
 299         ///
 300         void setFullScreen(bool full_screen);
 301         void showBar(bool show);
 302         void closeAll();
 303         bool setCurrentWorkArea(GuiWorkArea *);
 304         GuiWorkArea * addWorkArea(Buffer & buffer, GuiView & view);
 305         bool removeWorkArea(GuiWorkArea *);
 306         GuiWorkArea * currentWorkArea();
 307         GuiWorkArea * workArea(Buffer & buffer);
 308
 309 Q_SIGNALS:
 310         ///
 311         void currentWorkAreaChanged(GuiWorkArea *);
 312         ///
 313         void lastWorkAreaRemoved();
 314
 315 public Q_SLOTS:
 316         /// close current buffer, or the one given by \c clicked_tab_
 317         void closeCurrentBuffer();
 318         /// close current tab, or the one given by \c clicked_tab_
 319         void closeCurrentTab();
 320         ///
 321         void updateTabTexts();
 322
 323 private Q_SLOTS:
 324         ///
 325         void on_currentTabChanged(int index);
 326         ///
 327         void showContextMenu(const QPoint & pos);
 328         ///
 329         void moveTab(int fromIndex, int toIndex);
 330
 331 private:
 332         ///
 333         int clicked_tab_;
 334         ///
 335         QToolButton * closeBufferButton;
 336 }; // TabWorkArea
 337
 338
 339 class DragTabBar : public QTabBar
 340 {
 341         Q_OBJECT
 342 public:
 343         ///
 344         DragTabBar(QWidget * parent = 0);
 345
 346 #if QT_VERSION < 0x040300
 347         ///
 348         int tabAt(QPoint const & position) const;
 349 #endif
 350
 351 protected:
 352         ///
 353         void mousePressEvent(QMouseEvent * event);
 354         ///
 355         void mouseMoveEvent(QMouseEvent * event);
 356         ///
 357         void dragEnterEvent(QDragEnterEvent * event);
 358         ///
 359         void dropEvent(QDropEvent * event);
 360
 361 private:
 362         ///
 363         QPoint dragStartPos_;
 364         ///
 365         int dragCurrentIndex_;
 366
 367 Q_SIGNALS:
 368         ///
 369         void tabMoveRequested(int fromIndex, int toIndex);
 370 };
 371
 372 } // namespace frontend
 373 } // namespace lyx
 374
 375 #endif // WORKAREA_H