Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 397 insertions, 0 deletions

diff --git a/kate/part/kateviewinternal.h b/kate/part/kateviewinternal.h
new file mode 100644
index 000000000..c5004d6be
--- /dev/null
+++ b/kate/part/kateviewinternal.h
@@ -0,0 +1,397 @@
+/* This file is part of the KDE libraries
+   Copyright (C) 2002 John Firebaugh <jfirebaugh@kde.org>
+   Copyright (C) 2002 Joseph Wenninger <jowenn@kde.org>
+   Copyright (C) 2002 Christoph Cullmann <cullmann@kde.org>
+
+   Based on:
+     KWriteView : Copyright (C) 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License version 2 as published by the Free Software Foundation.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#ifndef _KATE_VIEW_INTERNAL_
+#define _KATE_VIEW_INTERNAL_
+
+#include "katecursor.h"
+#include "katesupercursor.h"
+#include "katelinerange.h"
+#include "katetextline.h"
+#include "katedocument.h"
+
+#include <qpoint.h>
+#include <qtimer.h>
+#include <qintdict.h>
+
+class KateView;
+class KateIconBorder;
+class KateScrollBar;
+
+class QHBoxLayout;
+class QVBoxLayout;
+class QScrollBar;
+
+enum Bias
+{
+    left  = -1,
+    none  =  0,
+    right =  1
+};
+
+class KateViewInternal : public QWidget
+{
+    Q_OBJECT
+
+    friend class KateView;
+    friend class KateIconBorder;
+    friend class KateScrollBar;
+    friend class CalculatingCursor;
+    friend class BoundedCursor;
+    friend class WrappingCursor;
+
+  public:
+    KateViewInternal ( KateView *view, KateDocument *doc );
+    ~KateViewInternal ();
+
+  //BEGIN EDIT STUFF
+  public:
+    void editStart ();
+    void editEnd (int editTagLineStart, int editTagLineEnd, bool tagFrom);
+
+    void editSetCursor (const KateTextCursor &cursor);
+
+  private:
+    uint editSessionNumber;
+    bool editIsRunning;
+    KateTextCursor editOldCursor;
+  //END
+
+  //BEGIN TAG & CLEAR & UPDATE STUFF
+  public:
+    bool tagLine (const KateTextCursor& virtualCursor);
+
+    bool tagLines (int start, int end, bool realLines = false);
+    bool tagLines (KateTextCursor start, KateTextCursor end, bool realCursors = false);
+
+    void tagAll ();
+
+    void clear ();
+  //END
+
+  private:
+    void updateView (bool changed = false, int viewLinesScrolled = 0);
+    void makeVisible (const KateTextCursor& c, uint endCol, bool force = false, bool center = false, bool calledExternally = false);
+
+  public:
+    inline const KateTextCursor& startPos() const { return m_startPos; }
+    inline uint startLine () const { return m_startPos.line(); }
+    inline uint startX () const { return m_startX; }
+
+    KateTextCursor endPos () const;
+    uint endLine () const;
+
+    KateLineRange yToKateLineRange(uint y) const;
+
+    void prepareForDynWrapChange();
+    void dynWrapChanged();
+
+    KateView *view () { return m_view; }
+
+  public slots:
+    void slotIncFontSizes();
+    void slotDecFontSizes();
+
+  private slots:
+    void scrollLines(int line); // connected to the sliderMoved of the m_lineScroll
+    void scrollViewLines(int offset);
+    void scrollNextPage();
+    void scrollPrevPage();
+    void scrollPrevLine();
+    void scrollNextLine();
+    void scrollColumns (int x); // connected to the valueChanged of the m_columnScroll
+    void viewSelectionChanged ();
+
+  public:
+    void doReturn();
+    void doDelete();
+    void doBackspace();
+    void doTranspose();
+    void doDeleteWordLeft();
+    void doDeleteWordRight();
+
+    void cursorLeft(bool sel=false);
+    void cursorRight(bool sel=false);
+    void wordLeft(bool sel=false);
+    void wordRight(bool sel=false);
+    void home(bool sel=false);
+    void end(bool sel=false);
+    void cursorUp(bool sel=false);
+    void cursorDown(bool sel=false);
+    void cursorToMatchingBracket(bool sel=false);
+    void scrollUp();
+    void scrollDown();
+    void topOfView(bool sel=false);
+    void bottomOfView(bool sel=false);
+    void pageUp(bool sel=false);
+    void pageDown(bool sel=false);
+    void top(bool sel=false);
+    void bottom(bool sel=false);
+    void top_home(bool sel=false);
+    void bottom_end(bool sel=false);
+
+    inline const KateTextCursor& getCursor() { return cursor; }
+    QPoint cursorCoordinates();
+
+    void paintText (int x, int y, int width, int height, bool paintOnlyDirty = false);
+
+  // EVENT HANDLING STUFF - IMPORTANT
+  protected:
+    void paintEvent(QPaintEvent *e);
+    bool eventFilter( QObject *obj, QEvent *e );
+    void keyPressEvent( QKeyEvent* );
+    void keyReleaseEvent( QKeyEvent* );
+    void resizeEvent( QResizeEvent* );
+    void mousePressEvent(       QMouseEvent* );
+    void mouseDoubleClickEvent( QMouseEvent* );
+    void mouseReleaseEvent(     QMouseEvent* );
+    void mouseMoveEvent(        QMouseEvent* );
+    void dragEnterEvent( QDragEnterEvent* );
+    void dragMoveEvent( QDragMoveEvent* );
+    void dropEvent( QDropEvent* );
+    void showEvent ( QShowEvent *);
+    void wheelEvent(QWheelEvent* e);
+    void focusInEvent (QFocusEvent *);
+    void focusOutEvent (QFocusEvent *);
+
+    void contextMenuEvent ( QContextMenuEvent * e );
+
+  private slots:
+    void tripleClickTimeout();
+
+  signals:
+    // emitted when KateViewInternal is not handling its own URI drops
+    void dropEventPass(QDropEvent*);
+
+  private slots:
+    void slotRegionVisibilityChangedAt(unsigned int);
+    void slotRegionBeginEndAddedRemoved(unsigned int);
+    void slotCodeFoldingChanged();
+
+  private:
+    void moveChar( Bias bias, bool sel );
+    void moveEdge( Bias bias, bool sel );
+    KateTextCursor maxStartPos(bool changed = false);
+    void scrollPos(KateTextCursor& c, bool force = false, bool calledExternally = false);
+    void scrollLines( int lines, bool sel );
+
+    uint linesDisplayed() const;
+
+    int lineToY(uint viewLine) const;
+
+    void updateSelection( const KateTextCursor&, bool keepSel );
+    void updateCursor( const KateTextCursor& newCursor, bool force = false, bool center = false, bool calledExternally = false );
+    void updateBracketMarks();
+
+    void paintCursor();
+
+    void updateMicroFocusHint();
+
+    void placeCursor( const QPoint& p, bool keepSelection = false, bool updateSelection = true );
+    bool isTargetSelected( const QPoint& p );
+
+    void doDrag();
+
+    KateView *m_view;
+    KateDocument* m_doc;
+    class KateIconBorder *leftBorder;
+
+    int mouseX;
+    int mouseY;
+    int scrollX;
+    int scrollY;
+
+    Qt::CursorShape m_mouseCursor;
+
+    KateSuperCursor cursor;
+    KateTextCursor displayCursor;
+    int cXPos;
+
+    bool possibleTripleClick;
+
+    // Bracket mark
+    KateBracketRange bm;
+
+    enum DragState { diNone, diPending, diDragging };
+
+    struct _dragInfo {
+      DragState    state;
+      QPoint       start;
+      QTextDrag*   dragObject;
+    } dragInfo;
+
+    uint iconBorderHeight;
+
+    //
+    // line scrollbar + first visible (virtual) line in the current view
+    //
+    KateScrollBar *m_lineScroll;
+    QWidget* m_dummy;
+    QVBoxLayout* m_lineLayout;
+    QHBoxLayout* m_colLayout;
+
+    // These are now cursors to account for word-wrap.
+    KateSuperCursor m_startPos;
+
+    // This is set to false on resize or scroll (other than that called by makeVisible),
+    // so that makeVisible is again called when a key is pressed and the cursor is in the same spot
+    bool m_madeVisible;
+    bool m_shiftKeyPressed;
+
+    // How many lines to should be kept visible above/below the cursor when possible
+    void setAutoCenterLines(int viewLines, bool updateView = true);
+    int m_autoCenterLines;
+    int m_minLinesVisible;
+
+    //
+    // column scrollbar + x position
+    //
+    QScrollBar *m_columnScroll;
+    int m_startX;
+
+    // has selection changed while your mouse or shift key is pressed
+    bool m_selChangedByUser;
+    KateTextCursor selectAnchor;
+
+    enum SelectionMode { Default=0, Word, Line, Mouse }; ///< for drag selection. @since 2.3
+    uint m_selectionMode;
+    // when drag selecting after double/triple click, keep the initial selected
+    // word/line independant of direction.
+    // They get set in the event of a double click, and is used with mouse move + leftbutton
+    KateTextCursor selStartCached;
+    KateTextCursor selEndCached;
+
+    //
+    // lines Ranges, mostly useful to speedup + dyn. word wrap
+    //
+    QMemArray<KateLineRange> lineRanges;
+
+    // maximal lenght of textlines visible from given startLine
+    int maxLen(uint startLine);
+
+    // are we allowed to scroll columns?
+    bool columnScrollingPossible ();
+
+    // returns the maximum X value / col value a cursor can take for a specific line range
+    int lineMaxCursorX(const KateLineRange& range);
+    int lineMaxCol(const KateLineRange& range);
+
+    // get the values for a specific range.
+    // specify lastLine to get the next line of a range.
+    KateLineRange range(int realLine, const KateLineRange* previous = 0L);
+
+    KateLineRange currentRange();
+    KateLineRange previousRange();
+    KateLineRange nextRange();
+
+    // Finds the lineRange currently occupied by the cursor.
+    KateLineRange range(const KateTextCursor& realCursor);
+
+    // Returns the lineRange of the specified realLine + viewLine.
+    KateLineRange range(uint realLine, int viewLine);
+
+    // find the view line of cursor c (0 = same line, 1 = down one, etc.)
+    uint viewLine(const KateTextCursor& realCursor);
+
+    // find the view line of the cursor, relative to the display (0 = top line of view, 1 = second line, etc.)
+    // if limitToVisible is true, only lines which are currently visible will be searched for, and -1 returned if the line is not visible.
+    int displayViewLine(const KateTextCursor& virtualCursor, bool limitToVisible = false);
+
+    // find the index of the last view line for a specific line
+    uint lastViewLine(uint realLine);
+
+    // count the number of view lines for a real line
+    uint viewLineCount(uint realLine);
+
+    // find the cursor offset by (offset) view lines from a cursor.
+    // when keepX is true, the column position will be calculated based on the x
+    // position of the specified cursor.
+    KateTextCursor viewLineOffset(const KateTextCursor& virtualCursor, int offset, bool keepX = false);
+
+    // These variable holds the most recent maximum real & visible column number
+    bool m_preserveMaxX;
+    int m_currentMaxX;
+
+    bool m_usePlainLines; // accept non-highlighted lines if this is set
+
+    inline KateTextLine::Ptr textLine( int realLine )
+    {
+      if (m_usePlainLines)
+        return m_doc->plainKateTextLine(realLine);
+      else
+        return m_doc->kateTextLine(realLine);
+    }
+
+    bool m_updatingView;
+    int m_wrapChangeViewLine;
+    KateTextCursor m_cachedMaxStartPos;
+
+  private slots:
+    void doDragScroll();
+    void startDragScroll();
+    void stopDragScroll();
+
+  private:
+    // Timers
+    QTimer m_dragScrollTimer;
+    QTimer m_scrollTimer;
+    QTimer m_cursorTimer;
+    QTimer m_textHintTimer;
+
+    static const int scrollTime = 30;
+    static const int scrollMargin = 16;
+
+  private slots:
+    void scrollTimeout ();
+    void cursorTimeout ();
+    void textHintTimeout ();
+
+  //TextHint
+ public:
+   void enableTextHints(int timeout);
+   void disableTextHints();
+
+ private:
+   bool m_textHintEnabled;
+   int m_textHintTimeout;
+   int m_textHintMouseX;
+   int m_textHintMouseY;
+
+  /**
+   * IM input stuff
+   */
+  protected:
+    void imStartEvent( QIMEvent *e );
+    void imComposeEvent( QIMEvent *e );
+    void imEndEvent( QIMEvent *e );
+
+  private:
+    int m_imPreeditStartLine;
+    int m_imPreeditStart;
+    int m_imPreeditLength;
+    int m_imPreeditSelStart;
+};
+
+#endif
+
+// kate: space-indent on; indent-width 2; replace-tabs on;