git.saurik.com Git - wxWidgets.git/blob - src/stc/scintilla/src/Editor.h

1 // Scintilla source code edit control

2 /** @file Editor.h

3 ** Defines the main editor class.

4 **/

6 // The License.txt file describes the conditions under which this software may be distributed.

8 #ifndef EDITOR_H

9 #define EDITOR_H

11 #ifdef SCI_NAMESPACE

12 namespace Scintilla {

13 #endif

15 /**

16 */

17 class Caret {

18 public:

19 bool active;

20 bool on;

21 int period;

23 Caret();

24 };

26 /**

27 */

28 class Timer {

29 public:

30 bool ticking;

31 int ticksToWait;

         enum {tickSize = 100};

33 TickerID tickerID;

35 Timer();

36 };

38 /**

39 */

40 class Idler {

41 public:

42 bool state;

43 IdlerID idlerID;

45 Idler();

46 };

48 /**

49 * When platform has a way to generate an event before painting,

50 * accumulate needed styling range in StyleNeeded to avoid unnecessary work.

51 */

52 class StyleNeeded {

53 public:

54 bool active;

55 Position upTo;

         StyleNeeded() : active(false), upTo(0) {}

58 void Reset() {

59 active = false;

60 upTo = 0;

61 }

62 void NeedUpTo(Position pos) {

63 if (upTo < pos)

64 upTo = pos;

65 }

66 };

68 /**

69 * Hold a piece of text selected for copying or dragging.

70 * The text is expected to hold a terminating '\0' and this is counted in len.

71 */

72 class SelectionText {

73 public:

74 char *s;

75 int len;

76 bool rectangular;

77 bool lineCopy;

78 int codePage;

79 int characterSet;

         SelectionText() : s(0), len(0), rectangular(false), lineCopy(false), codePage(0), characterSet(0) {}

81 ~SelectionText() {

82 Free();

83 }

84 void Free() {

                 Set(0, 0, 0, 0, false, false);

86 }

         void Set(char *s_, int len_, int codePage_, int characterSet_, bool rectangular_, bool lineCopy_) {

88 delete []s;

89 s = s_;

90 if (s)

91 len = len_;

92 else

93 len = 0;

94 codePage = codePage_;

95 characterSet = characterSet_;

96 rectangular = rectangular_;

97 lineCopy = lineCopy_;

98 }

         void Copy(const char *s_, int len_, int codePage_, int characterSet_, bool rectangular_, bool lineCopy_) {

100 delete []s;

101 s = 0;

                 s = new char[len_];

103 len = len_;

                 for (int i = 0; i < len_; i++) {

105 s[i] = s_[i];

106 }

107 codePage = codePage_;

108 characterSet = characterSet_;

109 rectangular = rectangular_;

110 lineCopy = lineCopy_;

111 }

         void Copy(const SelectionText &other) {

                 Copy(other.s, other.len, other.codePage, other.characterSet, other.rectangular, other.lineCopy);

114 }

115 };

116

117 /**

118 */

119 class Editor : public DocWatcher {

120 // Private so Editor objects can not be copied

121 Editor(const Editor &);

         Editor &operator=(const Editor &);

123

124 protected: // ScintillaBase subclass needs access to much of Editor

125

126 /** On GTK+, Scintilla is a container widget holding two scroll bars

127 * whereas on Windows there is just one window with both scroll bars turned on. */

128 Window wMain; ///< The Scintilla parent window

129

130 /** Style resources may be expensive to allocate so are cached between uses.

131 * When a style attribute is changed, this cache is flushed. */

132 bool stylesValid;

133 ViewStyle vs;

134 int technology;

135 Point sizeRGBAImage;

136

137 int printMagnification;

138 int printColourMode;

139 int printWrapState;

140 int cursorMode;

141 int controlCharSymbol;

142

143 // Highlight current folding block

144 HighlightDelimiter highlightDelimiter;

145

146 bool hasFocus;

147 bool hideSelection;

148 bool inOverstrike;

149 bool mouseDownCaptures;

150

151 /** In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to

152 * the screen. This avoids flashing but is about 30% slower. */

153 bool bufferedDraw;

154 /** In twoPhaseDraw mode, drawing is performed in two phases, first the background

155 * and then the foreground. This avoids chopping off characters that overlap the next run. */

156 bool twoPhaseDraw;

157

158 int xOffset; ///< Horizontal scrolled amount in pixels

159 int xCaretMargin; ///< Ensure this many pixels visible on both sides of caret

160 bool horizontalScrollBarVisible;

161 int scrollWidth;

162 bool trackLineWidth;

163 int lineWidthMaxSeen;

164 bool verticalScrollBarVisible;

165 bool endAtLastLine;

166 int caretSticky;

167 int marginOptions;

168 bool multipleSelection;

169 bool additionalSelectionTyping;

170 int multiPasteMode;

171 bool additionalCaretsBlink;

172 bool additionalCaretsVisible;

173

174 int virtualSpaceOptions;

175

176 Surface *pixmapLine;

177 Surface *pixmapSelMargin;

178 Surface *pixmapSelPattern;

179 Surface *pixmapIndentGuide;

180 Surface *pixmapIndentGuideHighlight;

181

182 LineLayoutCache llc;

183 PositionCache posCache;

184

185 KeyMap kmap;

186

187 Caret caret;

188 Timer timer;

189 Timer autoScrollTimer;

         enum { autoScrollDelay = 200 };

191

192 Idler idler;

193

194 Point lastClick;

195 unsigned int lastClickTime;

196 int dwellDelay;

197 int ticksToDwell;

198 bool dwelling;

         enum { selChar, selWord, selSubLine, selWholeLine } selectionType;

200 Point ptMouseLast;

         enum { ddNone, ddInitial, ddDragging } inDragDrop;

202 bool dropWentOutside;

203 SelectionPosition posDrag;

204 SelectionPosition posDrop;

205 int hotSpotClickPos;

206 int lastXChosen;

207 int lineAnchorPos;

208 int originalAnchorPos;

209 int wordSelectAnchorStartPos;

210 int wordSelectAnchorEndPos;

211 int wordSelectInitialCaretPos;

212 int targetStart;

213 int targetEnd;

214 int searchFlags;

215 int topLine;

216 int posTopLine;

217 int lengthForEncode;

218

219 int needUpdateUI;

220 Position braces[2];

221 int bracesMatchStyle;

222 int highlightGuideColumn;

223

224 int theEdge;

225

         enum { notPainting, painting, paintAbandoned } paintState;

227 PRectangle rcPaint;

228 bool paintingAllText;

229 bool willRedrawAll;

230 StyleNeeded styleNeeded;

231

232 int modEventMask;

233

234 SelectionText drag;

235 Selection sel;

236 bool primarySelection;

237

238 int caretXPolicy;

239 int caretXSlop; ///< Ensure this many pixels visible on both sides of caret

240

241 int caretYPolicy;

242 int caretYSlop; ///< Ensure this many lines visible on both sides of caret

243

244 int visiblePolicy;

245 int visibleSlop;

246

247 int searchAnchor;

248

249 bool recordingMacro;

250

251 int foldFlags;

252 ContractionState cs;

253

254 // Hotspot support

255 int hsStart;

256 int hsEnd;

257

258 // Wrapping support

         enum { eWrapNone, eWrapWord, eWrapChar } wrapState;

         enum { wrapLineLarge = 0x7ffffff };

261 int wrapWidth;

262 int wrapStart;

263 int wrapEnd;

264 int wrapVisualFlags;

265 int wrapVisualFlagsLocation;

266 int wrapVisualStartIndent;

267 int wrapIndentMode; // SC_WRAPINDENT_FIXED, _SAME, _INDENT

268

269 bool convertPastes;

270

271 Document *pdoc;

272

273 Editor();

274 virtual ~Editor();

         virtual void Initialise() = 0;

276 virtual void Finalise();

277

278 void InvalidateStyleData();

279 void InvalidateStyleRedraw();

280 void RefreshStyleData();

         void DropGraphics(bool freeObjects);

282 void AllocateGraphics();

283

284 virtual PRectangle GetClientRectangle();

285 PRectangle GetTextRectangle();

286

287 int LinesOnScreen();

288 int LinesToScroll();

289 int MaxScrollPos();

         SelectionPosition ClampPositionIntoDocument(SelectionPosition sp) const;

291 Point LocationFromPosition(SelectionPosition pos);

292 Point LocationFromPosition(int pos);

         int XFromPosition(int pos);

294 int XFromPosition(SelectionPosition sp);

         SelectionPosition SPositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false, bool virtualSpace=true);

         int PositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false);

         SelectionPosition SPositionFromLineX(int lineDoc, int x);

         int PositionFromLineX(int line, int x);

299 int LineFromLocation(Point pt);

         void SetTopLine(int topLineNew);

301

302 bool AbandonPaint();

303 void RedrawRect(PRectangle rc);

304 void Redraw();

         void RedrawSelMargin(int line=-1, bool allAfter=false);

         PRectangle RectangleFromRange(int start, int end);

         void InvalidateRange(int start, int end);

308

         bool UserVirtualSpace() const {

                 return ((virtualSpaceOptions & SCVS_USERACCESSIBLE) != 0);

311 }

312 int CurrentPosition();

313 bool SelectionEmpty();

314 SelectionPosition SelectionStart();

315 SelectionPosition SelectionEnd();

316 void SetRectangularRange();

317 void ThinRectangularRange();

         void InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection=false);

         void SetSelection(SelectionPosition currentPos_, SelectionPosition anchor_);

         void SetSelection(int currentPos_, int anchor_);

321 void SetSelection(SelectionPosition currentPos_);

         void SetSelection(int currentPos_);

323 void SetEmptySelection(SelectionPosition currentPos_);

         void SetEmptySelection(int currentPos_);

         bool RangeContainsProtected(int start, int end) const;

326 bool SelectionContainsProtected();

         int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true) const;

         SelectionPosition MovePositionOutsideChar(SelectionPosition pos, int moveDir, bool checkLineEnd=true) const;

         int MovePositionTo(SelectionPosition newPos, Selection::selTypes sel=Selection::noSel, bool ensureVisible=true);

         int MovePositionTo(int newPos, Selection::selTypes sel=Selection::noSel, bool ensureVisible=true);

         SelectionPosition MovePositionSoVisible(SelectionPosition pos, int moveDir);

         SelectionPosition MovePositionSoVisible(int pos, int moveDir);

333 Point PointMainCaret();

334 void SetLastXChosen();

335

         void ScrollTo(int line, bool moveThumb=true);

         virtual void ScrollText(int linesToMove);

         void HorizontalScrollTo(int xPos);

339 void VerticalCentreCaret();

         void MoveSelectedLines(int lineDelta);

341 void MoveSelectedLinesUp();

342 void MoveSelectedLinesDown();

         void MoveCaretInsideView(bool ensureVisible=true);

         int DisplayFromPosition(int pos);

345

346 struct XYScrollPosition {

347 int xOffset;

348 int topLine;

                 XYScrollPosition(int xOffset_, int topLine_) : xOffset(xOffset_), topLine(topLine_) {}

350 };

         XYScrollPosition XYScrollToMakeVisible(const bool useMargin, const bool vert, const bool horiz);

352 void SetXYScroll(XYScrollPosition newXY);

         void EnsureCaretVisible(bool useMargin=true, bool vert=true, bool horiz=true);

354 void ShowCaretAtCurrentPosition();

355 void DropCaret();

356 void InvalidateCaret();

357 virtual void UpdateSystemCaret();

358

         void NeedWrapping(int docLineStart = 0, int docLineEnd = wrapLineLarge);

         bool WrapOneLine(Surface *surface, int lineToWrap);

         bool WrapLines(bool fullWrap, int priorityWrapLineStart);

362 void LinesJoin();

         void LinesSplit(int pixelWidth);

364

         int SubstituteMarkerIfEmpty(int markerCheck, int markerDefault);

         void PaintSelMargin(Surface *surface, PRectangle &rc);

         LineLayout *RetrieveLineLayout(int lineNumber);

         void LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll,

                 int width=LineLayout::wrapWidthInfinite);

         ColourDesired SelectionBackground(ViewStyle &vsDraw, bool main);

         ColourDesired TextBackground(ViewStyle &vsDraw, bool overrideBackground, ColourDesired background, int inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll);

         void DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight);

         void DrawWrapMarker(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourDesired wrapColour);

         void DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,

                 int line, int lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,

376 bool overrideBackground, ColourDesired background,

377 bool drawWrapMark, ColourDesired wrapColour);

         void DrawIndicator(int indicNum, int startPos, int endPos, Surface *surface, ViewStyle &vsDraw,

                 int xStart, PRectangle rcLine, LineLayout *ll, int subLine);

         void DrawIndicators(Surface *surface, ViewStyle &vsDraw, int line, int xStart,

                 PRectangle rcLine, LineLayout *ll, int subLine, int lineEnd, bool under);

         void DrawAnnotation(Surface *surface, ViewStyle &vsDraw, int line, int xStart,

         PRectangle rcLine, LineLayout *ll, int subLine);

         void DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart,

                 PRectangle rcLine, LineLayout *ll, int subLine);

         void DrawBlockCaret(Surface *surface, ViewStyle &vsDraw, LineLayout *ll, int subLine,

                 int xStart, int offset, int posCaret, PRectangle rcCaret, ColourDesired caretColour);

         void DrawCarets(Surface *surface, ViewStyle &vsDraw, int line, int xStart,

                 PRectangle rcLine, LineLayout *ll, int subLine);

         void RefreshPixMaps(Surface *surfaceWindow);

         void Paint(Surface *surfaceWindow, PRectangle rcArea);

         long FormatRange(bool draw, Sci_RangeToFormat *pfr);

         int TextWidth(int style, const char *text);

394

         virtual void SetVerticalScrollPos() = 0;

         virtual void SetHorizontalScrollPos() = 0;

         virtual bool ModifyScrollBars(int nMax, int nPage) = 0;

398 virtual void ReconfigureScrollBars();

399 void SetScrollBars();

400 void ChangeSize();

401

402 void FilterSelections();

         int InsertSpace(int position, unsigned int spaces);

         void AddChar(char ch);

         virtual void AddCharUTF(char *s, unsigned int len, bool treatAsDBCS=false);

         void InsertPaste(SelectionPosition selStart, const char *text, int len);

         void ClearSelection(bool retainMultipleSelections=false);

408 void ClearAll();

409 void ClearDocumentStyle();

410 void Cut();

         void PasteRectangular(SelectionPosition pos, const char *ptr, int len);

         virtual void Copy() = 0;

413 virtual void CopyAllowLine();

414 virtual bool CanPaste();

         virtual void Paste() = 0;

416 void Clear();

417 void SelectAll();

418 void Undo();

419 void Redo();

420 void DelChar();

         void DelCharBack(bool allowLineStartDeletion);

         virtual void ClaimSelection() = 0;

423

         virtual void NotifyChange() = 0;

         virtual void NotifyFocus(bool focus);

         virtual void SetCtrlID(int identifier);

         virtual int GetCtrlID() { return ctrlID; }

         virtual void NotifyParent(SCNotification scn) = 0;

         virtual void NotifyStyleToNeeded(int endStyleNeeded);

         void NotifyChar(int ch);

         void NotifySavePoint(bool isSavePoint);

432 void NotifyModifyAttempt();

         virtual void NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt);

         void NotifyHotSpotClicked(int position, bool shift, bool ctrl, bool alt);

         void NotifyHotSpotDoubleClicked(int position, bool shift, bool ctrl, bool alt);

         void NotifyHotSpotReleaseClick(int position, bool shift, bool ctrl, bool alt);

437 void NotifyUpdateUI();

438 void NotifyPainted();

         void NotifyIndicatorClick(bool click, int position, bool shift, bool ctrl, bool alt);

         bool NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt);

         void NotifyNeedShown(int pos, int len);

         void NotifyDwelling(Point pt, bool state);

443 void NotifyZoom();

444

         void NotifyModifyAttempt(Document *document, void *userData);

         void NotifySavePoint(Document *document, void *userData, bool atSavePoint);

447 void CheckModificationForWrap(DocModification mh);

         void NotifyModified(Document *document, DocModification mh, void *userData);

         void NotifyDeleted(Document *document, void *userData);

         void NotifyStyleNeeded(Document *doc, void *userData, int endPos);

         void NotifyLexerChanged(Document *doc, void *userData);

         void NotifyErrorOccurred(Document *doc, void *userData, int status);

         void NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lParam);

454

         void ContainerNeedsUpdate(int flags);

         void PageMove(int direction, Selection::selTypes sel=Selection::noSel, bool stuttered = false);

         enum { cmSame, cmUpper, cmLower } caseMap;

         virtual std::string CaseMapString(const std::string &s, int caseMapping);

         void ChangeCaseOfSelection(int caseMapping);

460 void LineTranspose();

         void Duplicate(bool forLine);

462 virtual void CancelModes();

463 void NewLine();

         void CursorUpOrDown(int direction, Selection::selTypes sel=Selection::noSel);

         void ParaUpOrDown(int direction, Selection::selTypes sel=Selection::noSel);

         int StartEndDisplayLine(int pos, bool start);

         virtual int KeyCommand(unsigned int iMessage);

         virtual int KeyDefault(int /* key */, int /*modifiers*/);

         int KeyDownWithModifiers(int key, int modifiers, bool *consumed);

         int KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed=0);

471

         void Indent(bool forwards);

473

474 virtual CaseFolder *CaseFolderForEncoding();

         long FindText(uptr_t wParam, sptr_t lParam);

476 void SearchAnchor();

         long SearchText(unsigned int iMessage, uptr_t wParam, sptr_t lParam);

         long SearchInTarget(const char *text, int length);

         void GoToLine(int lineNo);

480

         virtual void CopyToClipboard(const SelectionText &selectedText) = 0;

         char *CopyRange(int start, int end);

         std::string RangeText(int start, int end) const;

         void CopySelectionRange(SelectionText *ss, bool allowLineCopy=false);

         void CopyRangeToClipboard(int start, int end);

         void CopyText(int length, const char *text);

487 void SetDragPosition(SelectionPosition newPos);

         virtual void DisplayCursor(Window::Cursor c);

         virtual bool DragThreshold(Point ptStart, Point ptNow);

490 virtual void StartDrag();

         void DropAt(SelectionPosition position, const char *value, bool moving, bool rectangular);

492 /** PositionInSelection returns true if position in selection. */

         bool PositionInSelection(int pos);

494 bool PointInSelection(Point pt);

495 bool PointInSelMargin(Point pt);

         Window::Cursor GetMarginCursor(Point pt);

         void TrimAndSetSelection(int currentPos_, int anchor_);

         void LineSelection(int lineCurrentPos_, int lineAnchorPos_, bool wholeLine);

         void WordSelection(int pos);

         void DwellEnd(bool mouseMoved);

501 void MouseLeave();

         virtual void ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt);

503 void ButtonMove(Point pt);

         void ButtonUp(Point pt, unsigned int curTime, bool ctrl);

505

506 void Tick();

507 bool Idle();

         virtual void SetTicking(bool on) = 0;

         virtual bool SetIdle(bool) { return false; }

         virtual void SetMouseCapture(bool on) = 0;

         virtual bool HaveMouseCapture() = 0;

         void SetFocusState(bool focusState);

513

514 int PositionAfterArea(PRectangle rcArea);

515 void StyleToPositionInView(Position pos);

516 void IdleStyling();

         virtual void QueueStyling(int upTo);

518

         virtual bool PaintContains(PRectangle rc);

520 bool PaintContainsMargin();

521 void CheckForChangeOutsidePaint(Range r);

         void SetBraceHighlight(Position pos0, Position pos1, int matchStyle);

523

         void SetAnnotationHeights(int start, int end);

         void SetDocPointer(Document *document);

526

         void SetAnnotationVisible(int visible);

528

         void Expand(int &line, bool doExpand);

         void ToggleContraction(int line);

         int ContractedFoldNext(int lineStart);

         void EnsureLineVisible(int lineDoc, bool enforcePolicy);

         int GetTag(char *tagValue, int tagNumber);

         int ReplaceTarget(bool replacePatterns, const char *text, int length=-1);

535

         bool PositionIsHotspot(int position);

537 bool PointIsHotspot(Point pt);

         void SetHotSpotRange(Point *pt);

         void GetHotSpotRange(int &hsStart, int &hsEnd);

540

         int CodePage() const;

         virtual bool ValidCodePage(int /* codePage */) const { return true; }

         int WrapCount(int line);

         void AddStyledText(char *buffer, int appendLength);

545

         virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) = 0;

         void StyleSetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);

         sptr_t StyleGetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);

549

         static const char *StringFromEOLMode(int eolMode);

551

         static sptr_t StringResult(sptr_t lParam, const char *val);

553

554 public:

555 // Public so the COM thunks can access it.

         bool IsUnicodeMode() const;

557 // Public so scintilla_send_message can use it.

         virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);

559 // Public so scintilla_set_id can use it.

560 int ctrlID;

561 // Public so COM methods for drag and drop can set it.

562 int errorStatus;

563 friend class AutoSurface;

564 friend class SelectionLineIterator;

565 };

566

567 /**

568 * A smart pointer class to ensure Surfaces are set up and deleted correctly.

569 */

570 class AutoSurface {

571 private:

572 Surface *surf;

573 public:

         AutoSurface(Editor *ed, int technology = -1) : surf(0) {

                 if (ed->wMain.GetID()) {

                         surf = Surface::Allocate(technology != -1 ? technology : ed->technology);

577 if (surf) {

                                 surf->Init(ed->wMain.GetID());

                                 surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage());

                                 surf->SetDBCSMode(ed->CodePage());

581 }

582 }

583 }

         AutoSurface(SurfaceID sid, Editor *ed, int technology = -1) : surf(0) {

                 if (ed->wMain.GetID()) {

                         surf = Surface::Allocate(technology != -1 ? technology : ed->technology);

587 if (surf) {

                                 surf->Init(sid, ed->wMain.GetID());

                                 surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage());

                                 surf->SetDBCSMode(ed->CodePage());

591 }

592 }

593 }

594 ~AutoSurface() {

595 delete surf;

596 }

         Surface *operator->() const {

598 return surf;

599 }

600 operator Surface *() const {

601 return surf;

602 }

603 };

604

605 #ifdef SCI_NAMESPACE

606 }

607 #endif

608

609 #endif