ext/scintilla/src/Editor.h

   1 // Scintilla source code edit control
   2 /** @file Editor.h
   3  ** Defines the main editor class.
   4  **/
   5 // Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
   6 // The License.txt file describes the conditions under which this software may be distributed.
   7
   8 #ifndef EDITOR_H
   9 #define EDITOR_H
  10
  11 #ifdef SCI_NAMESPACE
  12 namespace Scintilla {
  13 #endif
  14
  15 /**
  16  */
  17 class Caret {
  18 public:
  19         bool active;
  20         bool on;
  21         int period;
  22
  23         Caret();
  24 };
  25
  26 /**
  27  */
  28 class Timer {
  29 public:
  30         bool ticking;
  31         int ticksToWait;
  32         enum {tickSize = 100};
  33         TickerID tickerID;
  34
  35         Timer();
  36 };
  37
  38 /**
  39  */
  40 class Idler {
  41 public:
  42         bool state;
  43         IdlerID idlerID;
  44
  45         Idler();
  46 };
  47
  48 /**
  49  * When platform has a way to generate an event before painting,
  50  * accumulate needed styling range and other work items in
  51  * WorkNeeded to avoid unnecessary work inside paint handler
  52  */
  53 class WorkNeeded {
  54 public:
  55         enum workItems {
  56                 workNone=0,
  57                 workStyle=1,
  58                 workUpdateUI=2
  59         };
  60         bool active;
  61         enum workItems items;
  62         Position upTo;
  63
  64         WorkNeeded() : active(false), items(workNone), upTo(0) {}
  65         void Reset() {
  66                 active = false;
  67                 items = workNone;
  68                 upTo = 0;
  69         }
  70         void Need(workItems items_, Position pos) {
  71                 if ((items_ & workStyle) && (upTo < pos))
  72                         upTo = pos;
  73                 items = static_cast<workItems>(items | items_);
  74         }
  75 };
  76
  77 /**
  78  * Hold a piece of text selected for copying or dragging, along with encoding and selection format information.
  79  */
  80 class SelectionText {
  81         std::string s;
  82 public:
  83         bool rectangular;
  84         bool lineCopy;
  85         int codePage;
  86         int characterSet;
  87         SelectionText() : rectangular(false), lineCopy(false), codePage(0), characterSet(0) {}
  88         ~SelectionText() {
  89         }
  90         void Clear() {
  91                 s.clear();
  92                 rectangular = false;
  93                 lineCopy = false;
  94                 codePage = 0;
  95                 characterSet = 0;
  96         }
  97         void Copy(const std::string &s_, int codePage_, int characterSet_, bool rectangular_, bool lineCopy_) {
  98                 s = s_;
  99                 codePage = codePage_;
 100                 characterSet = characterSet_;
 101                 rectangular = rectangular_;
 102                 lineCopy = lineCopy_;
 103                 FixSelectionForClipboard();
 104         }
 105         void Copy(const SelectionText &other) {
 106                 Copy(other.s, other.codePage, other.characterSet, other.rectangular, other.lineCopy);
 107         }
 108         const char *Data() const {
 109                 return s.c_str();
 110         }
 111         size_t Length() const {
 112                 return s.length();
 113         }
 114         size_t LengthWithTerminator() const {
 115                 return s.length() + 1;
 116         }
 117         bool Empty() const {
 118                 return s.empty();
 119         }
 120 private:
 121         void FixSelectionForClipboard() {
 122                 // To avoid truncating the contents of the clipboard when pasted where the
 123                 // clipboard contains NUL characters, replace NUL characters by spaces.
 124                 std::replace(s.begin(), s.end(), '\0', ' ');
 125         }
 126 };
 127
 128 struct WrapPending {
 129         // The range of lines that need to be wrapped
 130         enum { lineLarge = 0x7ffffff };
 131         int start;      // When there are wraps pending, will be in document range
 132         int end;        // May be lineLarge to indicate all of document after start
 133         WrapPending() {
 134                 start = lineLarge;
 135                 end = lineLarge;
 136         }
 137         void Reset() {
 138                 start = lineLarge;
 139                 end = lineLarge;
 140         }
 141         void Wrapped(int line) {
 142                 if (start == line)
 143                         start++;
 144         }
 145         bool NeedsWrap() const {
 146                 return start < end;
 147         }
 148         bool AddRange(int lineStart, int lineEnd) {
 149                 const bool neededWrap = NeedsWrap();
 150                 bool changed = false;
 151                 if (start > lineStart) {
 152                         start = lineStart;
 153                         changed = true;
 154                 }
 155                 if ((end < lineEnd) || !neededWrap) {
 156                         end = lineEnd;
 157                         changed = true;
 158                 }
 159                 return changed;
 160         }
 161 };
 162
 163 struct PrintParameters {
 164         int magnification;
 165         int colourMode;
 166         WrapMode wrapState;
 167         PrintParameters();
 168 };
 169
 170 /**
 171  */
 172 class Editor : public DocWatcher {
 173         // Private so Editor objects can not be copied
 174         Editor(const Editor &);
 175         Editor &operator=(const Editor &);
 176
 177 protected:      // ScintillaBase subclass needs access to much of Editor
 178
 179         /** On GTK+, Scintilla is a container widget holding two scroll bars
 180          * whereas on Windows there is just one window with both scroll bars turned on. */
 181         Window wMain;   ///< The Scintilla parent window
 182         Window wMargin; ///< May be separate when using a scroll view for wMain
 183
 184         /** Style resources may be expensive to allocate so are cached between uses.
 185          * When a style attribute is changed, this cache is flushed. */
 186         bool stylesValid;
 187         ViewStyle vs;
 188         int technology;
 189         Point sizeRGBAImage;
 190         float scaleRGBAImage;
 191
 192         PrintParameters printParameters;
 193
 194         int cursorMode;
 195
 196         // Highlight current folding block
 197         HighlightDelimiter highlightDelimiter;
 198
 199         bool hasFocus;
 200         bool hideSelection;
 201         bool inOverstrike;
 202         bool drawOverstrikeCaret;
 203         bool mouseDownCaptures;
 204
 205         /** In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to
 206          * the screen. This avoids flashing but is about 30% slower. */
 207         bool bufferedDraw;
 208         /** In twoPhaseDraw mode, drawing is performed in two phases, first the background
 209         * and then the foreground. This avoids chopping off characters that overlap the next run. */
 210         bool twoPhaseDraw;
 211
 212         int xOffset;            ///< Horizontal scrolled amount in pixels
 213         int xCaretMargin;       ///< Ensure this many pixels visible on both sides of caret
 214         bool horizontalScrollBarVisible;
 215         int scrollWidth;
 216         bool trackLineWidth;
 217         int lineWidthMaxSeen;
 218         bool verticalScrollBarVisible;
 219         bool endAtLastLine;
 220         int caretSticky;
 221         int marginOptions;
 222         bool mouseSelectionRectangularSwitch;
 223         bool multipleSelection;
 224         bool additionalSelectionTyping;
 225         int multiPasteMode;
 226         bool additionalCaretsBlink;
 227         bool additionalCaretsVisible;
 228
 229         int virtualSpaceOptions;
 230
 231         Surface *pixmapLine;
 232         Surface *pixmapSelMargin;
 233         Surface *pixmapSelPattern;
 234         Surface *pixmapSelPatternOffset1;
 235         Surface *pixmapIndentGuide;
 236         Surface *pixmapIndentGuideHighlight;
 237
 238         LineLayoutCache llc;
 239         PositionCache posCache;
 240         SpecialRepresentations reprs;
 241
 242         KeyMap kmap;
 243
 244         Caret caret;
 245         Timer timer;
 246         Timer autoScrollTimer;
 247         enum { autoScrollDelay = 200 };
 248
 249         Idler idler;
 250
 251         Point lastClick;
 252         unsigned int lastClickTime;
 253         int dwellDelay;
 254         int ticksToDwell;
 255         bool dwelling;
 256         enum { selChar, selWord, selSubLine, selWholeLine } selectionType;
 257         Point ptMouseLast;
 258         enum { ddNone, ddInitial, ddDragging } inDragDrop;
 259         bool dropWentOutside;
 260         SelectionPosition posDrag;
 261         SelectionPosition posDrop;
 262         int hotSpotClickPos;
 263         int lastXChosen;
 264         int lineAnchorPos;
 265         int originalAnchorPos;
 266         int wordSelectAnchorStartPos;
 267         int wordSelectAnchorEndPos;
 268         int wordSelectInitialCaretPos;
 269         int targetStart;
 270         int targetEnd;
 271         int searchFlags;
 272         int topLine;
 273         int posTopLine;
 274         int lengthForEncode;
 275
 276         int needUpdateUI;
 277         Position braces[2];
 278         int bracesMatchStyle;
 279         int highlightGuideColumn;
 280
 281         enum { notPainting, painting, paintAbandoned } paintState;
 282         bool paintAbandonedByStyling;
 283         PRectangle rcPaint;
 284         bool paintingAllText;
 285         bool willRedrawAll;
 286         WorkNeeded workNeeded;
 287
 288         int modEventMask;
 289
 290         SelectionText drag;
 291         Selection sel;
 292         bool primarySelection;
 293
 294         int caretXPolicy;
 295         int caretXSlop; ///< Ensure this many pixels visible on both sides of caret
 296
 297         int caretYPolicy;
 298         int caretYSlop; ///< Ensure this many lines visible on both sides of caret
 299
 300         int visiblePolicy;
 301         int visibleSlop;
 302
 303         int searchAnchor;
 304
 305         bool recordingMacro;
 306
 307         int foldFlags;
 308         int foldAutomatic;
 309         ContractionState cs;
 310
 311         // Hotspot support
 312         Range hotspot;
 313
 314         // Wrapping support
 315         int wrapWidth;
 316         WrapPending wrapPending;
 317
 318         bool convertPastes;
 319
 320         Document *pdoc;
 321
 322         Editor();
 323         virtual ~Editor();
 324         virtual void Initialise() = 0;
 325         virtual void Finalise();
 326
 327         void InvalidateStyleData();
 328         void InvalidateStyleRedraw();
 329         void RefreshStyleData();
 330         void SetRepresentations();
 331         void DropGraphics(bool freeObjects);
 332         void AllocateGraphics();
 333
 334         // The top left visible point in main window coordinates. Will be 0,0 except for
 335         // scroll views where it will be equivalent to the current scroll position.
 336         virtual Point GetVisibleOriginInMain();
 337         Point DocumentPointFromView(Point ptView);  // Convert a point from view space to document
 338         int TopLineOfMain() const;   // Return the line at Main's y coordinate 0
 339         virtual PRectangle GetClientRectangle();
 340         virtual PRectangle GetClientDrawingRectangle();
 341         PRectangle GetTextRectangle();
 342
 343         int LinesOnScreen();
 344         int LinesToScroll();
 345         int MaxScrollPos();
 346         SelectionPosition ClampPositionIntoDocument(SelectionPosition sp) const;
 347         Point LocationFromPosition(SelectionPosition pos);
 348         Point LocationFromPosition(int pos);
 349         int XFromPosition(int pos);
 350         int XFromPosition(SelectionPosition sp);
 351         SelectionPosition SPositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false, bool virtualSpace=true);
 352         int PositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false);
 353         SelectionPosition SPositionFromLineX(int lineDoc, int x);
 354         int PositionFromLineX(int line, int x);
 355         int LineFromLocation(Point pt) const;
 356         void SetTopLine(int topLineNew);
 357
 358         virtual bool AbandonPaint();
 359         virtual void RedrawRect(PRectangle rc);
 360         virtual void DiscardOverdraw();
 361         virtual void Redraw();
 362         void RedrawSelMargin(int line=-1, bool allAfter=false);
 363         PRectangle RectangleFromRange(Range r);
 364         void InvalidateRange(int start, int end);
 365
 366         bool UserVirtualSpace() const {
 367                 return ((virtualSpaceOptions & SCVS_USERACCESSIBLE) != 0);
 368         }
 369         int CurrentPosition() const;
 370         bool SelectionEmpty() const;
 371         SelectionPosition SelectionStart();
 372         SelectionPosition SelectionEnd();
 373         void SetRectangularRange();
 374         void ThinRectangularRange();
 375         void InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection=false);
 376         void SetSelection(SelectionPosition currentPos_, SelectionPosition anchor_);
 377         void SetSelection(int currentPos_, int anchor_);
 378         void SetSelection(SelectionPosition currentPos_);
 379         void SetSelection(int currentPos_);
 380         void SetEmptySelection(SelectionPosition currentPos_);
 381         void SetEmptySelection(int currentPos_);
 382         bool RangeContainsProtected(int start, int end) const;
 383         bool SelectionContainsProtected();
 384         int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true) const;
 385         SelectionPosition MovePositionOutsideChar(SelectionPosition pos, int moveDir, bool checkLineEnd=true) const;
 386         int MovePositionTo(SelectionPosition newPos, Selection::selTypes sel=Selection::noSel, bool ensureVisible=true);
 387         int MovePositionTo(int newPos, Selection::selTypes sel=Selection::noSel, bool ensureVisible=true);
 388         SelectionPosition MovePositionSoVisible(SelectionPosition pos, int moveDir);
 389         SelectionPosition MovePositionSoVisible(int pos, int moveDir);
 390         Point PointMainCaret();
 391         void SetLastXChosen();
 392
 393         void ScrollTo(int line, bool moveThumb=true);
 394         virtual void ScrollText(int linesToMove);
 395         void HorizontalScrollTo(int xPos);
 396         void VerticalCentreCaret();
 397         void MoveSelectedLines(int lineDelta);
 398         void MoveSelectedLinesUp();
 399         void MoveSelectedLinesDown();
 400         void MoveCaretInsideView(bool ensureVisible=true);
 401         int DisplayFromPosition(int pos);
 402
 403         struct XYScrollPosition {
 404                 int xOffset;
 405                 int topLine;
 406                 XYScrollPosition(int xOffset_, int topLine_) : xOffset(xOffset_), topLine(topLine_) {}
 407                 bool operator==(const XYScrollPosition &other) const {
 408                         return (xOffset == other.xOffset) && (topLine == other.topLine);
 409                 }
 410         };
 411         enum XYScrollOptions {
 412                 xysUseMargin=0x1,
 413                 xysVertical=0x2,
 414                 xysHorizontal=0x4,
 415                 xysDefault=xysUseMargin|xysVertical|xysHorizontal};
 416         XYScrollPosition XYScrollToMakeVisible(const SelectionRange &range, const XYScrollOptions options);
 417         void SetXYScroll(XYScrollPosition newXY);
 418         void EnsureCaretVisible(bool useMargin=true, bool vert=true, bool horiz=true);
 419         void ScrollRange(SelectionRange range);
 420         void ShowCaretAtCurrentPosition();
 421         void DropCaret();
 422         void CaretSetPeriod(int period);
 423         void InvalidateCaret();
 424         virtual void UpdateSystemCaret();
 425
 426         bool Wrapping() const;
 427         void NeedWrapping(int docLineStart=0, int docLineEnd=WrapPending::lineLarge);
 428         bool WrapOneLine(Surface *surface, int lineToWrap);
 429         enum wrapScope {wsAll, wsVisible, wsIdle};
 430         bool WrapLines(enum wrapScope ws);
 431         void LinesJoin();
 432         void LinesSplit(int pixelWidth);
 433
 434         int SubstituteMarkerIfEmpty(int markerCheck, int markerDefault) const;
 435         void PaintSelMargin(Surface *surface, PRectangle &rc);
 436         LineLayout *RetrieveLineLayout(int lineNumber);
 437         void LayoutLine(int line, Surface *surface, const ViewStyle &vstyle, LineLayout *ll,
 438                 int width=LineLayout::wrapWidthInfinite);
 439         ColourDesired SelectionBackground(const ViewStyle &vsDraw, bool main) const;
 440         ColourDesired TextBackground(const ViewStyle &vsDraw, ColourOptional background, int inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll) const;
 441         void DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight);
 442         static void DrawWrapMarker(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourDesired wrapColour);
 443         void DrawEOL(Surface *surface, const ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
 444                 int line, int lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,
 445                 ColourOptional background);
 446         static void DrawIndicator(int indicNum, int startPos, int endPos, Surface *surface, const ViewStyle &vsDraw,
 447                 int xStart, PRectangle rcLine, LineLayout *ll, int subLine);
 448         void DrawIndicators(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
 449                 PRectangle rcLine, LineLayout *ll, int subLine, int lineEnd, bool under);
 450         void DrawAnnotation(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
 451         PRectangle rcLine, LineLayout *ll, int subLine);
 452         void DrawLine(Surface *surface, const ViewStyle &vsDraw, int line, int lineVisible, int xStart,
 453                 PRectangle rcLine, LineLayout *ll, int subLine);
 454         void DrawBlockCaret(Surface *surface, const ViewStyle &vsDraw, LineLayout *ll, int subLine,
 455                 int xStart, int offset, int posCaret, PRectangle rcCaret, ColourDesired caretColour) const;
 456         void DrawCarets(Surface *surface, const ViewStyle &vsDraw, int line, int xStart,
 457                 PRectangle rcLine, LineLayout *ll, int subLine);
 458         void RefreshPixMaps(Surface *surfaceWindow);
 459         void Paint(Surface *surfaceWindow, PRectangle rcArea);
 460         long FormatRange(bool draw, Sci_RangeToFormat *pfr);
 461         int TextWidth(int style, const char *text);
 462
 463         virtual void SetVerticalScrollPos() = 0;
 464         virtual void SetHorizontalScrollPos() = 0;
 465         virtual bool ModifyScrollBars(int nMax, int nPage) = 0;
 466         virtual void ReconfigureScrollBars();
 467         void SetScrollBars();
 468         void ChangeSize();
 469
 470         void FilterSelections();
 471         int InsertSpace(int position, unsigned int spaces);
 472         void AddChar(char ch);
 473         virtual void AddCharUTF(char *s, unsigned int len, bool treatAsDBCS=false);
 474         void InsertPaste(const char *text, int len);
 475         enum PasteShape { pasteStream=0, pasteRectangular = 1, pasteLine = 2 };
 476         void InsertPasteShape(const char *text, int len, PasteShape shape);
 477         void ClearSelection(bool retainMultipleSelections = false);
 478         void ClearAll();
 479         void ClearDocumentStyle();
 480         void Cut();
 481         void PasteRectangular(SelectionPosition pos, const char *ptr, int len);
 482         virtual void Copy() = 0;
 483         virtual void CopyAllowLine();
 484         virtual bool CanPaste();
 485         virtual void Paste() = 0;
 486         void Clear();
 487         void SelectAll();
 488         void Undo();
 489         void Redo();
 490         void DelChar();
 491         void DelCharBack(bool allowLineStartDeletion);
 492         virtual void ClaimSelection() = 0;
 493
 494         static int ModifierFlags(bool shift, bool ctrl, bool alt, bool meta=false);
 495         virtual void NotifyChange() = 0;
 496         virtual void NotifyFocus(bool focus);
 497         virtual void SetCtrlID(int identifier);
 498         virtual int GetCtrlID() { return ctrlID; }
 499         virtual void NotifyParent(SCNotification scn) = 0;
 500         virtual void NotifyStyleToNeeded(int endStyleNeeded);
 501         void NotifyChar(int ch);
 502         void NotifySavePoint(bool isSavePoint);
 503         void NotifyModifyAttempt();
 504         virtual void NotifyDoubleClick(Point pt, int modifiers);
 505         virtual void NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt);
 506         void NotifyHotSpotClicked(int position, int modifiers);
 507         void NotifyHotSpotClicked(int position, bool shift, bool ctrl, bool alt);
 508         void NotifyHotSpotDoubleClicked(int position, int modifiers);
 509         void NotifyHotSpotDoubleClicked(int position, bool shift, bool ctrl, bool alt);
 510         void NotifyHotSpotReleaseClick(int position, int modifiers);
 511         void NotifyHotSpotReleaseClick(int position, bool shift, bool ctrl, bool alt);
 512         bool NotifyUpdateUI();
 513         void NotifyPainted();
 514         void NotifyIndicatorClick(bool click, int position, int modifiers);
 515         void NotifyIndicatorClick(bool click, int position, bool shift, bool ctrl, bool alt);
 516         bool NotifyMarginClick(Point pt, int modifiers);
 517         bool NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt);
 518         void NotifyNeedShown(int pos, int len);
 519         void NotifyDwelling(Point pt, bool state);
 520         void NotifyZoom();
 521
 522         void NotifyModifyAttempt(Document *document, void *userData);
 523         void NotifySavePoint(Document *document, void *userData, bool atSavePoint);
 524         void CheckModificationForWrap(DocModification mh);
 525         void NotifyModified(Document *document, DocModification mh, void *userData);
 526         void NotifyDeleted(Document *document, void *userData);
 527         void NotifyStyleNeeded(Document *doc, void *userData, int endPos);
 528         void NotifyLexerChanged(Document *doc, void *userData);
 529         void NotifyErrorOccurred(Document *doc, void *userData, int status);
 530         void NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 531
 532         void ContainerNeedsUpdate(int flags);
 533         void PageMove(int direction, Selection::selTypes sel=Selection::noSel, bool stuttered = false);
 534         enum { cmSame, cmUpper, cmLower };
 535         virtual std::string CaseMapString(const std::string &s, int caseMapping);
 536         void ChangeCaseOfSelection(int caseMapping);
 537         void LineTranspose();
 538         void Duplicate(bool forLine);
 539         virtual void CancelModes();
 540         void NewLine();
 541         void CursorUpOrDown(int direction, Selection::selTypes sel=Selection::noSel);
 542         void ParaUpOrDown(int direction, Selection::selTypes sel=Selection::noSel);
 543         int StartEndDisplayLine(int pos, bool start);
 544         virtual int KeyCommand(unsigned int iMessage);
 545         virtual int KeyDefault(int /* key */, int /*modifiers*/);
 546         int KeyDownWithModifiers(int key, int modifiers, bool *consumed);
 547         int KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed=0);
 548
 549         void Indent(bool forwards);
 550
 551         virtual CaseFolder *CaseFolderForEncoding();
 552         long FindText(uptr_t wParam, sptr_t lParam);
 553         void SearchAnchor();
 554         long SearchText(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 555         long SearchInTarget(const char *text, int length);
 556         void GoToLine(int lineNo);
 557
 558         virtual void CopyToClipboard(const SelectionText &selectedText) = 0;
 559         std::string RangeText(int start, int end) const;
 560         void CopySelectionRange(SelectionText *ss, bool allowLineCopy=false);
 561         void CopyRangeToClipboard(int start, int end);
 562         void CopyText(int length, const char *text);
 563         void SetDragPosition(SelectionPosition newPos);
 564         virtual void DisplayCursor(Window::Cursor c);
 565         virtual bool DragThreshold(Point ptStart, Point ptNow);
 566         virtual void StartDrag();
 567         void DropAt(SelectionPosition position, const char *value, size_t lengthValue, bool moving, bool rectangular);
 568         void DropAt(SelectionPosition position, const char *value, bool moving, bool rectangular);
 569         /** PositionInSelection returns true if position in selection. */
 570         bool PositionInSelection(int pos);
 571         bool PointInSelection(Point pt);
 572         bool PointInSelMargin(Point pt);
 573         Window::Cursor GetMarginCursor(Point pt) const;
 574         void TrimAndSetSelection(int currentPos_, int anchor_);
 575         void LineSelection(int lineCurrentPos_, int lineAnchorPos_, bool wholeLine);
 576         void WordSelection(int pos);
 577         void DwellEnd(bool mouseMoved);
 578         void MouseLeave();
 579         virtual void ButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers);
 580         virtual void ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt);
 581         void ButtonMoveWithModifiers(Point pt, int modifiers);
 582         void ButtonMove(Point pt);
 583         void ButtonUp(Point pt, unsigned int curTime, bool ctrl);
 584
 585         void Tick();
 586         bool Idle();
 587         virtual void SetTicking(bool on) = 0;
 588         virtual bool SetIdle(bool) { return false; }
 589         virtual void SetMouseCapture(bool on) = 0;
 590         virtual bool HaveMouseCapture() = 0;
 591         void SetFocusState(bool focusState);
 592
 593         int PositionAfterArea(PRectangle rcArea) const;
 594         void StyleToPositionInView(Position pos);
 595         virtual void IdleWork();
 596         virtual void QueueIdleWork(WorkNeeded::workItems items, int upTo=0);
 597
 598         virtual bool PaintContains(PRectangle rc);
 599         bool PaintContainsMargin();
 600         void CheckForChangeOutsidePaint(Range r);
 601         void SetBraceHighlight(Position pos0, Position pos1, int matchStyle);
 602
 603         void SetAnnotationHeights(int start, int end);
 604         virtual void SetDocPointer(Document *document);
 605
 606         void SetAnnotationVisible(int visible);
 607
 608         int ExpandLine(int line);
 609         void SetFoldExpanded(int lineDoc, bool expanded);
 610         void FoldLine(int line, int action);
 611         void FoldExpand(int line, int action, int level);
 612         int ContractedFoldNext(int lineStart) const;
 613         void EnsureLineVisible(int lineDoc, bool enforcePolicy);
 614         void FoldChanged(int line, int levelNow, int levelPrev);
 615         void NeedShown(int pos, int len);
 616         void FoldAll(int action);
 617
 618         int GetTag(char *tagValue, int tagNumber);
 619         int ReplaceTarget(bool replacePatterns, const char *text, int length=-1);
 620
 621         bool PositionIsHotspot(int position) const;
 622         bool PointIsHotspot(Point pt);
 623         void SetHotSpotRange(Point *pt);
 624         Range GetHotSpotRange() const;
 625
 626         int CodePage() const;
 627         virtual bool ValidCodePage(int /* codePage */) const { return true; }
 628         int WrapCount(int line);
 629         void AddStyledText(char *buffer, int appendLength);
 630
 631         virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) = 0;
 632         void StyleSetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 633         sptr_t StyleGetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 634
 635         static const char *StringFromEOLMode(int eolMode);
 636
 637         static sptr_t StringResult(sptr_t lParam, const char *val);
 638         static sptr_t BytesResult(sptr_t lParam, const unsigned char *val, size_t len);
 639
 640 public:
 641         // Public so the COM thunks can access it.
 642         bool IsUnicodeMode() const;
 643         // Public so scintilla_send_message can use it.
 644         virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 645         // Public so scintilla_set_id can use it.
 646         int ctrlID;
 647         // Public so COM methods for drag and drop can set it.
 648         int errorStatus;
 649         friend class AutoSurface;
 650         friend class SelectionLineIterator;
 651 };
 652
 653 /**
 654  * A smart pointer class to ensure Surfaces are set up and deleted correctly.
 655  */
 656 class AutoSurface {
 657 private:
 658         Surface *surf;
 659 public:
 660         AutoSurface(Editor *ed, int technology = -1) : surf(0) {
 661                 if (ed->wMain.GetID()) {
 662                         surf = Surface::Allocate(technology != -1 ? technology : ed->technology);
 663                         if (surf) {
 664                                 surf->Init(ed->wMain.GetID());
 665                                 surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage());
 666                                 surf->SetDBCSMode(ed->CodePage());
 667                         }
 668                 }
 669         }
 670         AutoSurface(SurfaceID sid, Editor *ed, int technology = -1) : surf(0) {
 671                 if (ed->wMain.GetID()) {
 672                         surf = Surface::Allocate(technology != -1 ? technology : ed->technology);
 673                         if (surf) {
 674                                 surf->Init(sid, ed->wMain.GetID());
 675                                 surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage());
 676                                 surf->SetDBCSMode(ed->CodePage());
 677                         }
 678                 }
 679         }
 680         ~AutoSurface() {
 681                 delete surf;
 682         }
 683         Surface *operator->() const {
 684                 return surf;
 685         }
 686         operator Surface *() const {
 687                 return surf;
 688         }
 689 };
 690
 691 #ifdef SCI_NAMESPACE
 692 }
 693 #endif
 694
 695 #endif