This commit was manufactured by cvs2svn to create tag

'BEFORE_LINEWRAP_OPTIMIZE'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/BEFORE_LINEWRAP_OPTIMIZE@8857 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/univ/textctrl.h

@@ -21,6 +21,8 @@ class WXDLLEXPORT wxTextCtrlCommandProcessor;
 
 #include "wx/scrolwin.h"    // for wxScrollHelper
 
+#include "wx/univ/inphand.h"
+
 // ----------------------------------------------------------------------------
 // wxTextCtrl actions
 // ----------------------------------------------------------------------------
@@ -64,16 +66,30 @@ class WXDLLEXPORT wxTextCtrlCommandProcessor;
 #define wxACTION_TEXT_UNDO          _T("undo")
 #define wxACTION_TEXT_REDO          _T("redo")
 
+// ----------------------------------------------------------------------------
+// wxTextCtrl types
+// ----------------------------------------------------------------------------
+
+// wxTextPos is the position in the text
+typedef long wxTextPos;
+
+// wxTextCoord is the line or row number (which should have been unsigned but
+// is long for backwards compatibility)
+typedef long wxTextCoord;
+
 // ----------------------------------------------------------------------------
 // wxTextCtrl::HitTest return values
 // ----------------------------------------------------------------------------
 
+// the point asked is ...
 enum wxTextCtrlHitTestResult
 {
-    wxTE_HT_BEFORE = -1,
+    wxTE_HT_BEFORE = -1,    // either to the left or upper
-    wxTE_HT_ON_TEXT,
+    wxTE_HT_ON_TEXT,        // directly on
-    wxTE_HT_AFTER
+    wxTE_HT_BELOW,          // below [the last line]
+    wxTE_HT_BEYOND          // after [the end of line]
 };
+// ... the character returned
 
 // ----------------------------------------------------------------------------
 // wxTextCtrl
@@ -118,23 +134,23 @@ public:
     virtual wxString GetValue() const;
     virtual void SetValue(const wxString& value);
 
-    virtual int GetLineLength(long lineNo) const;
+    virtual int GetLineLength(wxTextCoord lineNo) const;
-    virtual wxString GetLineText(long lineNo) const;
+    virtual wxString GetLineText(wxTextCoord lineNo) const;
     virtual int GetNumberOfLines() const;
 
     virtual bool IsModified() const;
     virtual bool IsEditable() const;
 
     // If the return values from and to are the same, there is no selection.
-    virtual void GetSelection(long* from, long* to) const;
+    virtual void GetSelection(wxTextPos* from, wxTextPos* to) const;
 
     // operations
     // ----------
 
     // editing
     virtual void Clear();
-    virtual void Replace(long from, long to, const wxString& value);
+    virtual void Replace(wxTextPos from, wxTextPos to, const wxString& value);
-    virtual void Remove(long from, long to);
+    virtual void Remove(wxTextPos from, wxTextPos to);
 
     // clears the dirty flag
     virtual void DiscardEdits();
@@ -146,11 +162,18 @@ public:
 
     // translate between the position (which is just an index in the text ctrl
     // considering all its contents as a single strings) and (x, y) coordinates
-    // which represent column and line.
+    // which represent (logical, i.e. unwrapped) column and line.
-    virtual long XYToPosition(long x, long y) const;
+    virtual wxTextPos XYToPosition(wxTextCoord x, wxTextCoord y) const;
-    virtual bool PositionToXY(long pos, long *x, long *y) const;
+    virtual bool PositionToXY(wxTextPos pos,
+                              wxTextCoord *x, wxTextCoord *y) const;
 
-    virtual void ShowPosition(long pos);
+    // wxUniv-specific: find a screen position (in client coordinates) of the
+    // given text position or of the caret
+    bool PositionToLogicalXY(wxTextPos pos, wxCoord *x, wxCoord *y) const;
+    bool PositionToDeviceXY(wxTextPos pos, wxCoord *x, wxCoord *y) const;
+    wxPoint GetCaretPosition() const;
+
+    virtual void ShowPosition(wxTextPos pos);
 
     // Clipboard operations
     virtual void Copy();
@@ -165,12 +188,12 @@ public:
     virtual bool CanRedo() const;
 
     // Insertion point
-    virtual void SetInsertionPoint(long pos);
+    virtual void SetInsertionPoint(wxTextPos pos);
     virtual void SetInsertionPointEnd();
-    virtual long GetInsertionPoint() const;
+    virtual wxTextPos GetInsertionPoint() const;
-    virtual long GetLastPosition() const;
+    virtual wxTextPos GetLastPosition() const;
 
-    virtual void SetSelection(long from, long to);
+    virtual void SetSelection(wxTextPos from, wxTextPos to);
     virtual void SetEditable(bool editable);
 
     // wxUniv-specific methods
@@ -180,11 +203,10 @@ public:
     virtual void ShowCaret(bool show = TRUE);
     void HideCaret() { ShowCaret(FALSE); }
     void CreateCaret(); // for the current font size
-    wxCoord GetCaretPosition(long pos = -1) const; // in pixels, def => current
 
     // helpers for cursor movement
-    long GetWordStart() const;
+    wxTextPos GetWordStart() const;
-    long GetWordEnd() const;
+    wxTextPos GetWordEnd() const;
 
     // selection helpers
     bool HasSelection() const
@@ -202,7 +224,7 @@ public:
     // NB: pt is in device coords (not adjusted for the client area origin nor
     //     for the scrolling)
     wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
-                                    long *col, long *row) const;
+                                    wxTextCoord *col, wxTextCoord *row) const;
 
     // find the character at this position in the given line, return value as
     // for HitTest()
@@ -210,14 +232,14 @@ public:
     // NB: x is the logical coord (client and unscrolled)
     wxTextCtrlHitTestResult HitTestLine(const wxString& line,
                                         wxCoord x,
-                                        long *colOut) const;
+                                        wxTextCoord *colOut) const;
 
     // bring the given position into view
     void ShowHorzPosition(wxCoord pos);
 
     // scroll the window horizontally so that the first character shown is in
     // position pos
-    void ScrollText(long col);
+    void ScrollText(wxTextCoord col);
 
     // adjust the DC for horz text control scrolling too
     virtual void DoPrepareDC(wxDC& dc);
@@ -228,7 +250,7 @@ public:
     // override this to take into account our scrollbar-less scrolling
     virtual void CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const;
 
-    // set the right colours
+    // set the right colours and border
     virtual bool IsContainerWindow() const { return TRUE; }
     virtual wxBorder GetDefaultBorder() const { return wxBORDER_SUNKEN; }
 
@@ -245,10 +267,12 @@ protected:
     // draw the text
     void DrawTextLine(wxDC& dc, const wxRect& rect,
                       const wxString& text,
-                      long selStart, long selEnd);
+                      wxTextPos selStart, wxTextPos selEnd);
 
     void DoDrawTextInRect(wxDC& dc, const wxRect& rectUpdate);
 
+    // override base class methods
+    virtual void DoDrawBorder(wxDC& dc, const wxRect& rect);
     virtual void DoDraw(wxControlRenderer *renderer);
 
     // calc the size from the text extent
@@ -263,7 +287,8 @@ protected:
     // more readable flag testing methods
     bool IsSingleLine() const { return !(GetWindowStyle() & wxTE_MULTILINE); }
     bool IsPassword() const { return (GetWindowStyle() & wxTE_PASSWORD) != 0; }
-    bool WrapLines() const { return !(GetWindowStyle() & wxHSCROLL); }
+    bool WrapLines() const
+        { return !IsSingleLine() && !(GetWindowStyle() & wxHSCROLL); }
 
     // get the extent (width) of the text
     wxCoord GetTextWidth(const wxString& text) const;
@@ -271,6 +296,12 @@ protected:
     // get the logical text width (accounting for scrolling)
     wxCoord GetTotalWidth() const;
 
+    // find the number of rows in this line (only if WrapLines())
+    wxTextCoord GetRowsPerLine(wxTextCoord line) const;
+
+    // get total number of rows before the given line
+    wxTextCoord GetNumberOfRowsBefore(wxTextCoord line) const;
+
     // the text area is the part of the window in which the text can be
     // displayed, i.e. part of it inside the margins and the real text area is
     // the area in which the text *is* currently displayed: for example, in the
@@ -280,29 +311,35 @@ protected:
     wxRect GetRealTextArea() const;
 
     // refresh the text in the given (in logical coords) rect
-    void RefreshTextRect(wxRect& rect);
+    void RefreshTextRect(const wxRect& rect);
 
     // refresh the text in the given range (in logical coords) of this line, if
     // width is 0, refresh to the end of line
-    void RefreshPixelRange(long line, wxCoord start, wxCoord width);
+    void RefreshPixelRange(wxTextCoord line, wxCoord start, wxCoord width);
 
     // refresh the text in the given range (in text coords) in this line
-    void RefreshColRange(long line, long start, long count);
+    void RefreshColRange(wxTextCoord line, wxTextPos start, size_t count);
 
     // refresh the text from in the given line range (inclusive)
-    void RefreshLineRange(long lineFirst, long lineLast);
+    void RefreshLineRange(wxTextCoord lineFirst, wxTextCoord lineLast);
 
     // refresh the text in the given range which can span multiple lines
     // (this method accepts arguments in any order)
-    void RefreshTextRange(long start, long end);
+    void RefreshTextRange(wxTextPos start, wxTextPos end);
 
     // get the text to show: either the text itself or the text replaced with
     // starts for wxTE_PASSWORD control
     wxString GetTextToShow(const wxString& text) const;
 
+    // find the number of characters of a line before it wraps
+    // (and optionally also the real width of the line)
+    size_t GetPartOfWrappedLine(const wxChar* text,
+                                wxCoord *widthReal = NULL) const;
+
     // get the start and end of the selection for this line: if the line is
     // outside the selection, both will be -1 and FALSE will be returned
-    bool GetSelectedPartOfLine(long line, int *start, int *end) const;
+    bool GetSelectedPartOfLine(wxTextCoord line,
+                               wxTextPos *start, wxTextPos *end) const;
 
     // update the text rect: the zone inside our client rect (its coords are
     // client coords) which contains the text
@@ -313,7 +350,7 @@ protected:
 
     // move caret to the given position unconditionally
     // (SetInsertionPoint() does nothing if the position didn't change)
-    void DoSetInsertionPoint(long pos);
+    void DoSetInsertionPoint(wxTextPos pos);
 
     // set the caret to its initial (default) position
     void InitInsertionPoint();
@@ -322,20 +359,58 @@ protected:
     wxCoord GetMaxWidth() const;
 
     // force recalculation of the max line width
-    void RecalcMaxWidth()
+    void RecalcMaxWidth();
-    {
-        m_widthMax = -1;
-        (void)GetMaxWidth();
-    }
 
     // update the max width after the given line was modified
-    void UpdateMaxWidth(long line);
+    void UpdateMaxWidth(wxTextCoord line);
+
+    // HitTest2() is more efficient than 2 consecutive HitTest()s with the same
+    // line (i.e. y) and it also returns the offset of the starting position in
+    // pixels
+    //
+    // as the last hack, this function accepts either logical or device (by
+    // default) coords depending on devCoords flag
+    wxTextCtrlHitTestResult HitTest2(wxCoord y,
+                                     wxCoord x1,
+                                     wxCoord x2,
+                                     wxTextCoord *row,
+                                     wxTextCoord *colStart,
+                                     wxTextCoord *colEnd,
+                                     wxTextCoord *colRowStart,
+                                     bool devCoords = TRUE) const;
+
+    // HitTest() version which takes the logical text coordinates and not the
+    // device ones
+    wxTextCtrlHitTestResult HitTestLogical(const wxPoint& pos,
+                                           wxTextCoord *col,
+                                           wxTextCoord *row) const;
+
+    // get the height of one line (the same for all lines)
+    wxCoord GetLineHeight() const
+    {
+        // this one should be already precalculated
+        wxASSERT_MSG( m_heightLine != -1, _T("should have line height") );
+
+        return m_heightLine;
+    }
+
+    // get the average char width
+    wxCoord GetAverageWidth() const { return m_widthAvg; }
+
+    // recalc the line height and char width (to call when the font changes)
+    void RecalcFontMetrics();
 
     // event handlers
     void OnIdle(wxIdleEvent& event);
     void OnChar(wxKeyEvent& event);
     void OnSize(wxSizeEvent& event);
 
+    // return the struct containing control-type dependent data
+    struct wxTextSingleLineData& SData() { return *m_data.sdata; }
+    struct wxTextMultiLineData& MData() { return *m_data.mdata; }
+    const wxTextSingleLineData& SData() const { return *m_data.sdata; }
+    const wxTextMultiLineData& MData() const { return *m_data.mdata; }
+
     // accessors for derived classes (SL stands for single line)
     const wxString& GetSLValue() const
     {
@@ -365,21 +440,18 @@ private:
     // the control text (only used for single line controls)
     wxString m_value;
 
-    // the lines of text (only used for multiline controls)
-    wxArrayString m_lines;
-
     // current position
-    long m_curPos,
+    wxTextPos m_curPos;
-         m_curCol,
+    wxTextCoord m_curCol,
-         m_curRow;
+                m_curRow;
 
     // last position (only used by GetLastPosition())
-    long m_posLast;
+    wxTextPos m_posLast;
 
     // selection
-    long m_selAnchor,
+    wxTextPos m_selAnchor,
-         m_selStart,
+              m_selStart,
-         m_selEnd;
+              m_selEnd;
 
     // flags
     bool m_isModified:1,
@@ -389,32 +461,20 @@ private:
     // the rectangle (in client coordinates) to draw text inside
     wxRect m_rectText;
 
-    // this section is for the controls without horz scrollbar only
+    // the height of one line (cached value of GetCharHeight)
+    wxCoord m_heightLine;
 
-    // the position of the first visible pixel and the first visible column
+    // and the average char width (cached value of GetCharWidth)
-    wxCoord m_ofsHorz;
+    wxCoord m_widthAvg;
-    long m_colStart;
 
-    // and the last ones (m_posLastVisible is the width but m_colLastVisible
+    // we have some data which depends on the kind of control (single or multi
-    // is an absolute value)
+    // line)
-    wxCoord m_posLastVisible;
+    union
-    long m_colLastVisible;
+    {
-
+        wxTextSingleLineData *sdata;
-    // this section is for the controls with scrollbar(s)
+        wxTextMultiLineData *mdata;
-
+        void *data;
-    // the current ranges of the scrollbars
+    } m_data;
-    int m_scrollRangeX,
-        m_scrollRangeY;
-
-    // should we adjust the horz/vert scrollbar?
-    bool m_updateScrollbarX,
-         m_updateScrollbarY;
-
-    // the max line length in pixels
-    wxCoord m_widthMax;
-
-    // the index of the line which has the length of m_widthMax
-    long m_lineLongest;
 
     // the object to which we delegate our undo/redo implementation
     wxTextCtrlCommandProcessor *m_cmdProcessor;
@@ -423,5 +483,32 @@ private:
     DECLARE_DYNAMIC_CLASS(wxTextCtrl)
 };
 
+// ----------------------------------------------------------------------------
+// wxStdTextCtrlInputHandler: this control handles only the mouse/kbd actions
+// common to Win32 and GTK, platform-specific things are implemented elsewhere
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStdTextCtrlInputHandler : public wxStdInputHandler
+{
+public:
+    wxStdTextCtrlInputHandler(wxInputHandler *inphand);
+
+    virtual bool HandleKey(wxControl *control,
+                           const wxKeyEvent& event,
+                           bool pressed);
+    virtual bool HandleMouse(wxControl *control,
+                             const wxMouseEvent& event);
+    virtual bool HandleMouseMove(wxControl *control,
+                                 const wxMouseEvent& event);
+    virtual bool HandleFocus(wxControl *control, const wxFocusEvent& event);
+
+protected:
+    // get the position of the mouse click
+    static wxTextPos HitTest(const wxTextCtrl *text, const wxPoint& pos);
+
+    // capture data
+    wxTextCtrl *m_winCapture;
+};
+
 #endif // _WX_UNIV_TEXTCTRL_H_