1 // SciTE - Scintilla based Text Editor
2 /** @file ScintillaCall.cxx
3 ** Interface to calling a Scintilla instance.
4 **/
5 // Copyright 1998-2019 by Neil Hodgson <neilh@scintilla.org>
6 // The License.txt file describes the conditions under which this software may be distributed.
7
8 /* Most of this file is automatically generated from the Scintilla.iface interface definition
9 * file which contains any comments about the definitions. APIFacer.py does the generation. */
10
11 #include <cstdint>
12
13 #include <string>
14 #include <string_view>
15
16 #include "ScintillaTypes.h"
17 #include "ScintillaMessages.h"
18 #include "ScintillaCall.h"
19
20 namespace Scintilla::API {
21
ScintillaCall()22 ScintillaCall::ScintillaCall() noexcept : fn(nullptr), ptr(0), statusLastCall(Status::Ok) {
23 }
24
SetFnPtr(FunctionDirect fn_,intptr_t ptr_)25 void ScintillaCall::SetFnPtr(FunctionDirect fn_, intptr_t ptr_) noexcept {
26 fn = fn_;
27 ptr = ptr_;
28 }
29
IsValid() const30 bool ScintillaCall::IsValid() const noexcept {
31 return fn && ptr;
32 }
33
SetCallStatus()34 void ScintillaCall::SetCallStatus() {
35 statusLastCall = static_cast<API::Status>(fn(ptr, static_cast<unsigned int>(Message::GetStatus), 0, 0));
36 if (statusLastCall > Status::Ok && statusLastCall < Status::WarnStart)
37 throw Failure(statusLastCall);
38 }
39
Call(Message msg,uintptr_t wParam,intptr_t lParam)40 intptr_t ScintillaCall::Call(Message msg, uintptr_t wParam, intptr_t lParam) {
41 if (!fn)
42 throw Failure(Status::Failure);
43 const intptr_t retVal = fn(ptr, static_cast<unsigned int>(msg), wParam, lParam);
44 SetCallStatus();
45 return retVal;
46 }
47
CallPointer(Message msg,uintptr_t wParam,void * s)48 intptr_t ScintillaCall::CallPointer(Message msg, uintptr_t wParam, void *s) {
49 return Call(msg, wParam, reinterpret_cast<intptr_t>(s));
50 }
51
CallString(Message msg,uintptr_t wParam,const char * s)52 intptr_t ScintillaCall::CallString(Message msg, uintptr_t wParam, const char *s) {
53 return Call(msg, wParam, reinterpret_cast<intptr_t>(s));
54 }
55
CallReturnString(Message msg,uintptr_t wParam)56 std::string ScintillaCall::CallReturnString(Message msg, uintptr_t wParam) {
57 size_t len = CallPointer(msg, wParam, nullptr);
58 if (len) {
59 std::string value(len, '\0');
60 CallPointer(msg, wParam, value.data());
61 return value;
62 } else {
63 return std::string();
64 }
65 }
66
67 // Common APIs made more structured and type-safe
68
LineStart(Line line)69 Position ScintillaCall::LineStart(Line line) {
70 return Call(Message::PositionFromLine, line);
71 }
72
LineEnd(Line line)73 Position ScintillaCall::LineEnd(Line line) {
74 return Call(Message::GetLineEndPosition, line);
75 }
76
SelectionRange()77 Range ScintillaCall::SelectionRange() {
78 return Range(
79 Call(Message::GetSelectionStart),
80 Call(Message::GetSelectionEnd));
81 }
82
TargetRange()83 Range ScintillaCall::TargetRange() {
84 return Range(
85 Call(Message::GetTargetStart),
86 Call(Message::GetTargetEnd));
87 }
88
SetTarget(Range range)89 void ScintillaCall::SetTarget(Range range) {
90 Call(Message::SetTargetRange, range.start, range.end);
91 }
92
ColouriseAll()93 void ScintillaCall::ColouriseAll() {
94 Colourise(0, -1);
95 }
96
CharacterAt(Position position)97 char ScintillaCall::CharacterAt(Position position) {
98 return static_cast<char>(Call(Message::GetCharAt, position));
99 }
100
UnsignedStyleAt(Position position)101 int ScintillaCall::UnsignedStyleAt(Position position) {
102 // Returns signed value but easier to use as unsigned
103 return static_cast<unsigned char>(Call(Message::GetStyleAt, position));
104 }
105
StringOfRange(Range range)106 std::string ScintillaCall::StringOfRange(Range range) {
107 if (range.Length() == 0) {
108 return std::string();
109 } else {
110 std::string text(range.Length(), '\0');
111 SetTarget(range);
112 TargetText(text.data());
113 return text;
114 }
115 }
116
ReplaceTarget(std::string_view text)117 Position ScintillaCall::ReplaceTarget(std::string_view text) {
118 return ScintillaCall::CallString(Message::ReplaceTarget, text.length(), text.data());
119 }
120
ReplaceTargetRE(std::string_view text)121 Position ScintillaCall::ReplaceTargetRE(std::string_view text) {
122 return CallString(Message::ReplaceTargetRE, text.length(), text.data());
123 }
124
SearchInTarget(std::string_view text)125 Position ScintillaCall::SearchInTarget(std::string_view text) {
126 return CallString(Message::SearchInTarget, text.length(), text.data());
127 }
128
RangeSearchInTarget(std::string_view text)129 Range ScintillaCall::RangeSearchInTarget(std::string_view text) {
130 const Position posFound = SearchInTarget(text);
131 if (posFound >= 0)
132 return Range(posFound, TargetEnd());
133 else
134 return Range(posFound, 0);
135 }
136
137 // Generated methods
138
139 // ScintillaCall requires automatically generated casts as it is converting
140 // specific types to/from generic arguments and return values of 'Call'.
141 // Suppress Visual C++ Code Analysis warnings for these casts and pointer returns.
142 // 26472 = Don't use a static_cast for arithmetic conversions.
143 // 26487 = Don't return a pointer '*' that may be invalid (lifetime.4).
144 // 26490 = Don't use reinterpret_cast.
145 #if defined(_MSC_VER)
146 #pragma warning(disable: 26472 26487 26490)
147 #endif
148
149 //++Autogenerated -- start of section automatically generated from Scintilla.iface
AddText(Position length,const char * text)150 void ScintillaCall::AddText(Position length, const char *text) {
151 CallString(Message::AddText, length, text);
152 }
153
AddStyledText(Position length,const char * c)154 void ScintillaCall::AddStyledText(Position length, const char *c) {
155 CallString(Message::AddStyledText, length, c);
156 }
157
InsertText(Position pos,const char * text)158 void ScintillaCall::InsertText(Position pos, const char *text) {
159 CallString(Message::InsertText, pos, text);
160 }
161
ChangeInsertion(Position length,const char * text)162 void ScintillaCall::ChangeInsertion(Position length, const char *text) {
163 CallString(Message::ChangeInsertion, length, text);
164 }
165
ClearAll()166 void ScintillaCall::ClearAll() {
167 Call(Message::ClearAll);
168 }
169
DeleteRange(Position start,Position lengthDelete)170 void ScintillaCall::DeleteRange(Position start, Position lengthDelete) {
171 Call(Message::DeleteRange, start, lengthDelete);
172 }
173
ClearDocumentStyle()174 void ScintillaCall::ClearDocumentStyle() {
175 Call(Message::ClearDocumentStyle);
176 }
177
Length()178 Position ScintillaCall::Length() {
179 return Call(Message::GetLength);
180 }
181
CharAt(Position pos)182 int ScintillaCall::CharAt(Position pos) {
183 return static_cast<int>(Call(Message::GetCharAt, pos));
184 }
185
CurrentPos()186 Position ScintillaCall::CurrentPos() {
187 return Call(Message::GetCurrentPos);
188 }
189
Anchor()190 Position ScintillaCall::Anchor() {
191 return Call(Message::GetAnchor);
192 }
193
StyleAt(Position pos)194 int ScintillaCall::StyleAt(Position pos) {
195 return static_cast<int>(Call(Message::GetStyleAt, pos));
196 }
197
Redo()198 void ScintillaCall::Redo() {
199 Call(Message::Redo);
200 }
201
SetUndoCollection(bool collectUndo)202 void ScintillaCall::SetUndoCollection(bool collectUndo) {
203 Call(Message::SetUndoCollection, collectUndo);
204 }
205
SelectAll()206 void ScintillaCall::SelectAll() {
207 Call(Message::SelectAll);
208 }
209
SetSavePoint()210 void ScintillaCall::SetSavePoint() {
211 Call(Message::SetSavePoint);
212 }
213
GetStyledText(void * tr)214 Position ScintillaCall::GetStyledText(void *tr) {
215 return CallPointer(Message::GetStyledText, 0, tr);
216 }
217
CanRedo()218 bool ScintillaCall::CanRedo() {
219 return Call(Message::CanRedo);
220 }
221
MarkerLineFromHandle(int markerHandle)222 Line ScintillaCall::MarkerLineFromHandle(int markerHandle) {
223 return Call(Message::MarkerLineFromHandle, markerHandle);
224 }
225
MarkerDeleteHandle(int markerHandle)226 void ScintillaCall::MarkerDeleteHandle(int markerHandle) {
227 Call(Message::MarkerDeleteHandle, markerHandle);
228 }
229
MarkerHandleFromLine(Line line,int which)230 int ScintillaCall::MarkerHandleFromLine(Line line, int which) {
231 return static_cast<int>(Call(Message::MarkerHandleFromLine, line, which));
232 }
233
MarkerNumberFromLine(Line line,int which)234 int ScintillaCall::MarkerNumberFromLine(Line line, int which) {
235 return static_cast<int>(Call(Message::MarkerNumberFromLine, line, which));
236 }
237
UndoCollection()238 bool ScintillaCall::UndoCollection() {
239 return Call(Message::GetUndoCollection);
240 }
241
ViewWS()242 WhiteSpace ScintillaCall::ViewWS() {
243 return static_cast<API::WhiteSpace>(Call(Message::GetViewWS));
244 }
245
SetViewWS(API::WhiteSpace viewWS)246 void ScintillaCall::SetViewWS(API::WhiteSpace viewWS) {
247 Call(Message::SetViewWS, static_cast<uintptr_t>(viewWS));
248 }
249
TabDrawMode()250 TabDrawMode ScintillaCall::TabDrawMode() {
251 return static_cast<API::TabDrawMode>(Call(Message::GetTabDrawMode));
252 }
253
SetTabDrawMode(API::TabDrawMode tabDrawMode)254 void ScintillaCall::SetTabDrawMode(API::TabDrawMode tabDrawMode) {
255 Call(Message::SetTabDrawMode, static_cast<uintptr_t>(tabDrawMode));
256 }
257
PositionFromPoint(int x,int y)258 Position ScintillaCall::PositionFromPoint(int x, int y) {
259 return Call(Message::PositionFromPoint, x, y);
260 }
261
PositionFromPointClose(int x,int y)262 Position ScintillaCall::PositionFromPointClose(int x, int y) {
263 return Call(Message::PositionFromPointClose, x, y);
264 }
265
GotoLine(Line line)266 void ScintillaCall::GotoLine(Line line) {
267 Call(Message::GotoLine, line);
268 }
269
GotoPos(Position caret)270 void ScintillaCall::GotoPos(Position caret) {
271 Call(Message::GotoPos, caret);
272 }
273
SetAnchor(Position anchor)274 void ScintillaCall::SetAnchor(Position anchor) {
275 Call(Message::SetAnchor, anchor);
276 }
277
GetCurLine(Position length,char * text)278 Position ScintillaCall::GetCurLine(Position length, char *text) {
279 return CallPointer(Message::GetCurLine, length, text);
280 }
281
GetCurLine(Position length)282 std::string ScintillaCall::GetCurLine(Position length) {
283 return CallReturnString(Message::GetCurLine, length);
284 }
285
EndStyled()286 Position ScintillaCall::EndStyled() {
287 return Call(Message::GetEndStyled);
288 }
289
ConvertEOLs(API::EndOfLine eolMode)290 void ScintillaCall::ConvertEOLs(API::EndOfLine eolMode) {
291 Call(Message::ConvertEOLs, static_cast<uintptr_t>(eolMode));
292 }
293
EOLMode()294 EndOfLine ScintillaCall::EOLMode() {
295 return static_cast<API::EndOfLine>(Call(Message::GetEOLMode));
296 }
297
SetEOLMode(API::EndOfLine eolMode)298 void ScintillaCall::SetEOLMode(API::EndOfLine eolMode) {
299 Call(Message::SetEOLMode, static_cast<uintptr_t>(eolMode));
300 }
301
StartStyling(Position start,int unused)302 void ScintillaCall::StartStyling(Position start, int unused) {
303 Call(Message::StartStyling, start, unused);
304 }
305
SetStyling(Position length,int style)306 void ScintillaCall::SetStyling(Position length, int style) {
307 Call(Message::SetStyling, length, style);
308 }
309
BufferedDraw()310 bool ScintillaCall::BufferedDraw() {
311 return Call(Message::GetBufferedDraw);
312 }
313
SetBufferedDraw(bool buffered)314 void ScintillaCall::SetBufferedDraw(bool buffered) {
315 Call(Message::SetBufferedDraw, buffered);
316 }
317
SetTabWidth(int tabWidth)318 void ScintillaCall::SetTabWidth(int tabWidth) {
319 Call(Message::SetTabWidth, tabWidth);
320 }
321
TabWidth()322 int ScintillaCall::TabWidth() {
323 return static_cast<int>(Call(Message::GetTabWidth));
324 }
325
SetTabMinimumWidth(int pixels)326 void ScintillaCall::SetTabMinimumWidth(int pixels) {
327 Call(Message::SetTabMinimumWidth, pixels);
328 }
329
TabMinimumWidth()330 int ScintillaCall::TabMinimumWidth() {
331 return static_cast<int>(Call(Message::GetTabMinimumWidth));
332 }
333
ClearTabStops(Line line)334 void ScintillaCall::ClearTabStops(Line line) {
335 Call(Message::ClearTabStops, line);
336 }
337
AddTabStop(Line line,int x)338 void ScintillaCall::AddTabStop(Line line, int x) {
339 Call(Message::AddTabStop, line, x);
340 }
341
GetNextTabStop(Line line,int x)342 int ScintillaCall::GetNextTabStop(Line line, int x) {
343 return static_cast<int>(Call(Message::GetNextTabStop, line, x));
344 }
345
SetCodePage(int codePage)346 void ScintillaCall::SetCodePage(int codePage) {
347 Call(Message::SetCodePage, codePage);
348 }
349
IMEInteraction()350 IMEInteraction ScintillaCall::IMEInteraction() {
351 return static_cast<API::IMEInteraction>(Call(Message::GetIMEInteraction));
352 }
353
SetIMEInteraction(API::IMEInteraction imeInteraction)354 void ScintillaCall::SetIMEInteraction(API::IMEInteraction imeInteraction) {
355 Call(Message::SetIMEInteraction, static_cast<uintptr_t>(imeInteraction));
356 }
357
MarkerDefine(int markerNumber,API::MarkerSymbol markerSymbol)358 void ScintillaCall::MarkerDefine(int markerNumber, API::MarkerSymbol markerSymbol) {
359 Call(Message::MarkerDefine, markerNumber, static_cast<intptr_t>(markerSymbol));
360 }
361
MarkerSetFore(int markerNumber,Colour fore)362 void ScintillaCall::MarkerSetFore(int markerNumber, Colour fore) {
363 Call(Message::MarkerSetFore, markerNumber, fore);
364 }
365
MarkerSetBack(int markerNumber,Colour back)366 void ScintillaCall::MarkerSetBack(int markerNumber, Colour back) {
367 Call(Message::MarkerSetBack, markerNumber, back);
368 }
369
MarkerSetBackSelected(int markerNumber,Colour back)370 void ScintillaCall::MarkerSetBackSelected(int markerNumber, Colour back) {
371 Call(Message::MarkerSetBackSelected, markerNumber, back);
372 }
373
MarkerEnableHighlight(bool enabled)374 void ScintillaCall::MarkerEnableHighlight(bool enabled) {
375 Call(Message::MarkerEnableHighlight, enabled);
376 }
377
MarkerAdd(Line line,int markerNumber)378 int ScintillaCall::MarkerAdd(Line line, int markerNumber) {
379 return static_cast<int>(Call(Message::MarkerAdd, line, markerNumber));
380 }
381
MarkerDelete(Line line,int markerNumber)382 void ScintillaCall::MarkerDelete(Line line, int markerNumber) {
383 Call(Message::MarkerDelete, line, markerNumber);
384 }
385
MarkerDeleteAll(int markerNumber)386 void ScintillaCall::MarkerDeleteAll(int markerNumber) {
387 Call(Message::MarkerDeleteAll, markerNumber);
388 }
389
MarkerGet(Line line)390 int ScintillaCall::MarkerGet(Line line) {
391 return static_cast<int>(Call(Message::MarkerGet, line));
392 }
393
MarkerNext(Line lineStart,int markerMask)394 Line ScintillaCall::MarkerNext(Line lineStart, int markerMask) {
395 return Call(Message::MarkerNext, lineStart, markerMask);
396 }
397
MarkerPrevious(Line lineStart,int markerMask)398 Line ScintillaCall::MarkerPrevious(Line lineStart, int markerMask) {
399 return Call(Message::MarkerPrevious, lineStart, markerMask);
400 }
401
MarkerDefinePixmap(int markerNumber,const char * pixmap)402 void ScintillaCall::MarkerDefinePixmap(int markerNumber, const char *pixmap) {
403 CallString(Message::MarkerDefinePixmap, markerNumber, pixmap);
404 }
405
MarkerAddSet(Line line,int markerSet)406 void ScintillaCall::MarkerAddSet(Line line, int markerSet) {
407 Call(Message::MarkerAddSet, line, markerSet);
408 }
409
MarkerSetAlpha(int markerNumber,API::Alpha alpha)410 void ScintillaCall::MarkerSetAlpha(int markerNumber, API::Alpha alpha) {
411 Call(Message::MarkerSetAlpha, markerNumber, static_cast<intptr_t>(alpha));
412 }
413
SetMarginTypeN(int margin,API::MarginType marginType)414 void ScintillaCall::SetMarginTypeN(int margin, API::MarginType marginType) {
415 Call(Message::SetMarginTypeN, margin, static_cast<intptr_t>(marginType));
416 }
417
MarginTypeN(int margin)418 MarginType ScintillaCall::MarginTypeN(int margin) {
419 return static_cast<API::MarginType>(Call(Message::GetMarginTypeN, margin));
420 }
421
SetMarginWidthN(int margin,int pixelWidth)422 void ScintillaCall::SetMarginWidthN(int margin, int pixelWidth) {
423 Call(Message::SetMarginWidthN, margin, pixelWidth);
424 }
425
MarginWidthN(int margin)426 int ScintillaCall::MarginWidthN(int margin) {
427 return static_cast<int>(Call(Message::GetMarginWidthN, margin));
428 }
429
SetMarginMaskN(int margin,int mask)430 void ScintillaCall::SetMarginMaskN(int margin, int mask) {
431 Call(Message::SetMarginMaskN, margin, mask);
432 }
433
MarginMaskN(int margin)434 int ScintillaCall::MarginMaskN(int margin) {
435 return static_cast<int>(Call(Message::GetMarginMaskN, margin));
436 }
437
SetMarginSensitiveN(int margin,bool sensitive)438 void ScintillaCall::SetMarginSensitiveN(int margin, bool sensitive) {
439 Call(Message::SetMarginSensitiveN, margin, sensitive);
440 }
441
MarginSensitiveN(int margin)442 bool ScintillaCall::MarginSensitiveN(int margin) {
443 return Call(Message::GetMarginSensitiveN, margin);
444 }
445
SetMarginCursorN(int margin,API::CursorShape cursor)446 void ScintillaCall::SetMarginCursorN(int margin, API::CursorShape cursor) {
447 Call(Message::SetMarginCursorN, margin, static_cast<intptr_t>(cursor));
448 }
449
MarginCursorN(int margin)450 CursorShape ScintillaCall::MarginCursorN(int margin) {
451 return static_cast<API::CursorShape>(Call(Message::GetMarginCursorN, margin));
452 }
453
SetMarginBackN(int margin,Colour back)454 void ScintillaCall::SetMarginBackN(int margin, Colour back) {
455 Call(Message::SetMarginBackN, margin, back);
456 }
457
MarginBackN(int margin)458 Colour ScintillaCall::MarginBackN(int margin) {
459 return static_cast<Colour>(Call(Message::GetMarginBackN, margin));
460 }
461
SetMargins(int margins)462 void ScintillaCall::SetMargins(int margins) {
463 Call(Message::SetMargins, margins);
464 }
465
Margins()466 int ScintillaCall::Margins() {
467 return static_cast<int>(Call(Message::GetMargins));
468 }
469
StyleClearAll()470 void ScintillaCall::StyleClearAll() {
471 Call(Message::StyleClearAll);
472 }
473
StyleSetFore(int style,Colour fore)474 void ScintillaCall::StyleSetFore(int style, Colour fore) {
475 Call(Message::StyleSetFore, style, fore);
476 }
477
StyleSetBack(int style,Colour back)478 void ScintillaCall::StyleSetBack(int style, Colour back) {
479 Call(Message::StyleSetBack, style, back);
480 }
481
StyleSetBold(int style,bool bold)482 void ScintillaCall::StyleSetBold(int style, bool bold) {
483 Call(Message::StyleSetBold, style, bold);
484 }
485
StyleSetItalic(int style,bool italic)486 void ScintillaCall::StyleSetItalic(int style, bool italic) {
487 Call(Message::StyleSetItalic, style, italic);
488 }
489
StyleSetSize(int style,int sizePoints)490 void ScintillaCall::StyleSetSize(int style, int sizePoints) {
491 Call(Message::StyleSetSize, style, sizePoints);
492 }
493
StyleSetFont(int style,const char * fontName)494 void ScintillaCall::StyleSetFont(int style, const char *fontName) {
495 CallString(Message::StyleSetFont, style, fontName);
496 }
497
StyleSetEOLFilled(int style,bool eolFilled)498 void ScintillaCall::StyleSetEOLFilled(int style, bool eolFilled) {
499 Call(Message::StyleSetEOLFilled, style, eolFilled);
500 }
501
StyleResetDefault()502 void ScintillaCall::StyleResetDefault() {
503 Call(Message::StyleResetDefault);
504 }
505
StyleSetUnderline(int style,bool underline)506 void ScintillaCall::StyleSetUnderline(int style, bool underline) {
507 Call(Message::StyleSetUnderline, style, underline);
508 }
509
StyleGetFore(int style)510 Colour ScintillaCall::StyleGetFore(int style) {
511 return static_cast<Colour>(Call(Message::StyleGetFore, style));
512 }
513
StyleGetBack(int style)514 Colour ScintillaCall::StyleGetBack(int style) {
515 return static_cast<Colour>(Call(Message::StyleGetBack, style));
516 }
517
StyleGetBold(int style)518 bool ScintillaCall::StyleGetBold(int style) {
519 return Call(Message::StyleGetBold, style);
520 }
521
StyleGetItalic(int style)522 bool ScintillaCall::StyleGetItalic(int style) {
523 return Call(Message::StyleGetItalic, style);
524 }
525
StyleGetSize(int style)526 int ScintillaCall::StyleGetSize(int style) {
527 return static_cast<int>(Call(Message::StyleGetSize, style));
528 }
529
StyleGetFont(int style,char * fontName)530 int ScintillaCall::StyleGetFont(int style, char *fontName) {
531 return static_cast<int>(CallPointer(Message::StyleGetFont, style, fontName));
532 }
533
StyleGetFont(int style)534 std::string ScintillaCall::StyleGetFont(int style) {
535 return CallReturnString(Message::StyleGetFont, style);
536 }
537
StyleGetEOLFilled(int style)538 bool ScintillaCall::StyleGetEOLFilled(int style) {
539 return Call(Message::StyleGetEOLFilled, style);
540 }
541
StyleGetUnderline(int style)542 bool ScintillaCall::StyleGetUnderline(int style) {
543 return Call(Message::StyleGetUnderline, style);
544 }
545
StyleGetCase(int style)546 CaseVisible ScintillaCall::StyleGetCase(int style) {
547 return static_cast<API::CaseVisible>(Call(Message::StyleGetCase, style));
548 }
549
StyleGetCharacterSet(int style)550 CharacterSet ScintillaCall::StyleGetCharacterSet(int style) {
551 return static_cast<API::CharacterSet>(Call(Message::StyleGetCharacterSet, style));
552 }
553
StyleGetVisible(int style)554 bool ScintillaCall::StyleGetVisible(int style) {
555 return Call(Message::StyleGetVisible, style);
556 }
557
StyleGetChangeable(int style)558 bool ScintillaCall::StyleGetChangeable(int style) {
559 return Call(Message::StyleGetChangeable, style);
560 }
561
StyleGetHotSpot(int style)562 bool ScintillaCall::StyleGetHotSpot(int style) {
563 return Call(Message::StyleGetHotSpot, style);
564 }
565
StyleSetCase(int style,API::CaseVisible caseVisible)566 void ScintillaCall::StyleSetCase(int style, API::CaseVisible caseVisible) {
567 Call(Message::StyleSetCase, style, static_cast<intptr_t>(caseVisible));
568 }
569
StyleSetSizeFractional(int style,int sizeHundredthPoints)570 void ScintillaCall::StyleSetSizeFractional(int style, int sizeHundredthPoints) {
571 Call(Message::StyleSetSizeFractional, style, sizeHundredthPoints);
572 }
573
StyleGetSizeFractional(int style)574 int ScintillaCall::StyleGetSizeFractional(int style) {
575 return static_cast<int>(Call(Message::StyleGetSizeFractional, style));
576 }
577
StyleSetWeight(int style,API::FontWeight weight)578 void ScintillaCall::StyleSetWeight(int style, API::FontWeight weight) {
579 Call(Message::StyleSetWeight, style, static_cast<intptr_t>(weight));
580 }
581
StyleGetWeight(int style)582 FontWeight ScintillaCall::StyleGetWeight(int style) {
583 return static_cast<API::FontWeight>(Call(Message::StyleGetWeight, style));
584 }
585
StyleSetCharacterSet(int style,API::CharacterSet characterSet)586 void ScintillaCall::StyleSetCharacterSet(int style, API::CharacterSet characterSet) {
587 Call(Message::StyleSetCharacterSet, style, static_cast<intptr_t>(characterSet));
588 }
589
StyleSetHotSpot(int style,bool hotspot)590 void ScintillaCall::StyleSetHotSpot(int style, bool hotspot) {
591 Call(Message::StyleSetHotSpot, style, hotspot);
592 }
593
SetSelFore(bool useSetting,Colour fore)594 void ScintillaCall::SetSelFore(bool useSetting, Colour fore) {
595 Call(Message::SetSelFore, useSetting, fore);
596 }
597
SetSelBack(bool useSetting,Colour back)598 void ScintillaCall::SetSelBack(bool useSetting, Colour back) {
599 Call(Message::SetSelBack, useSetting, back);
600 }
601
SelAlpha()602 Alpha ScintillaCall::SelAlpha() {
603 return static_cast<API::Alpha>(Call(Message::GetSelAlpha));
604 }
605
SetSelAlpha(API::Alpha alpha)606 void ScintillaCall::SetSelAlpha(API::Alpha alpha) {
607 Call(Message::SetSelAlpha, static_cast<uintptr_t>(alpha));
608 }
609
SelEOLFilled()610 bool ScintillaCall::SelEOLFilled() {
611 return Call(Message::GetSelEOLFilled);
612 }
613
SetSelEOLFilled(bool filled)614 void ScintillaCall::SetSelEOLFilled(bool filled) {
615 Call(Message::SetSelEOLFilled, filled);
616 }
617
SetCaretFore(Colour fore)618 void ScintillaCall::SetCaretFore(Colour fore) {
619 Call(Message::SetCaretFore, fore);
620 }
621
AssignCmdKey(int keyDefinition,int sciCommand)622 void ScintillaCall::AssignCmdKey(int keyDefinition, int sciCommand) {
623 Call(Message::AssignCmdKey, keyDefinition, sciCommand);
624 }
625
ClearCmdKey(int keyDefinition)626 void ScintillaCall::ClearCmdKey(int keyDefinition) {
627 Call(Message::ClearCmdKey, keyDefinition);
628 }
629
ClearAllCmdKeys()630 void ScintillaCall::ClearAllCmdKeys() {
631 Call(Message::ClearAllCmdKeys);
632 }
633
SetStylingEx(Position length,const char * styles)634 void ScintillaCall::SetStylingEx(Position length, const char *styles) {
635 CallString(Message::SetStylingEx, length, styles);
636 }
637
StyleSetVisible(int style,bool visible)638 void ScintillaCall::StyleSetVisible(int style, bool visible) {
639 Call(Message::StyleSetVisible, style, visible);
640 }
641
CaretPeriod()642 int ScintillaCall::CaretPeriod() {
643 return static_cast<int>(Call(Message::GetCaretPeriod));
644 }
645
SetCaretPeriod(int periodMilliseconds)646 void ScintillaCall::SetCaretPeriod(int periodMilliseconds) {
647 Call(Message::SetCaretPeriod, periodMilliseconds);
648 }
649
SetWordChars(const char * characters)650 void ScintillaCall::SetWordChars(const char *characters) {
651 CallString(Message::SetWordChars, 0, characters);
652 }
653
WordChars(char * characters)654 int ScintillaCall::WordChars(char *characters) {
655 return static_cast<int>(CallPointer(Message::GetWordChars, 0, characters));
656 }
657
WordChars()658 std::string ScintillaCall::WordChars() {
659 return CallReturnString(Message::GetWordChars, 0);
660 }
661
SetCharacterCategoryOptimization(int countCharacters)662 void ScintillaCall::SetCharacterCategoryOptimization(int countCharacters) {
663 Call(Message::SetCharacterCategoryOptimization, countCharacters);
664 }
665
CharacterCategoryOptimization()666 int ScintillaCall::CharacterCategoryOptimization() {
667 return static_cast<int>(Call(Message::GetCharacterCategoryOptimization));
668 }
669
BeginUndoAction()670 void ScintillaCall::BeginUndoAction() {
671 Call(Message::BeginUndoAction);
672 }
673
EndUndoAction()674 void ScintillaCall::EndUndoAction() {
675 Call(Message::EndUndoAction);
676 }
677
IndicSetStyle(int indicator,API::IndicatorStyle indicatorStyle)678 void ScintillaCall::IndicSetStyle(int indicator, API::IndicatorStyle indicatorStyle) {
679 Call(Message::IndicSetStyle, indicator, static_cast<intptr_t>(indicatorStyle));
680 }
681
IndicGetStyle(int indicator)682 IndicatorStyle ScintillaCall::IndicGetStyle(int indicator) {
683 return static_cast<API::IndicatorStyle>(Call(Message::IndicGetStyle, indicator));
684 }
685
IndicSetFore(int indicator,Colour fore)686 void ScintillaCall::IndicSetFore(int indicator, Colour fore) {
687 Call(Message::IndicSetFore, indicator, fore);
688 }
689
IndicGetFore(int indicator)690 Colour ScintillaCall::IndicGetFore(int indicator) {
691 return static_cast<Colour>(Call(Message::IndicGetFore, indicator));
692 }
693
IndicSetUnder(int indicator,bool under)694 void ScintillaCall::IndicSetUnder(int indicator, bool under) {
695 Call(Message::IndicSetUnder, indicator, under);
696 }
697
IndicGetUnder(int indicator)698 bool ScintillaCall::IndicGetUnder(int indicator) {
699 return Call(Message::IndicGetUnder, indicator);
700 }
701
IndicSetHoverStyle(int indicator,API::IndicatorStyle indicatorStyle)702 void ScintillaCall::IndicSetHoverStyle(int indicator, API::IndicatorStyle indicatorStyle) {
703 Call(Message::IndicSetHoverStyle, indicator, static_cast<intptr_t>(indicatorStyle));
704 }
705
IndicGetHoverStyle(int indicator)706 IndicatorStyle ScintillaCall::IndicGetHoverStyle(int indicator) {
707 return static_cast<API::IndicatorStyle>(Call(Message::IndicGetHoverStyle, indicator));
708 }
709
IndicSetHoverFore(int indicator,Colour fore)710 void ScintillaCall::IndicSetHoverFore(int indicator, Colour fore) {
711 Call(Message::IndicSetHoverFore, indicator, fore);
712 }
713
IndicGetHoverFore(int indicator)714 Colour ScintillaCall::IndicGetHoverFore(int indicator) {
715 return static_cast<Colour>(Call(Message::IndicGetHoverFore, indicator));
716 }
717
IndicSetFlags(int indicator,API::IndicFlag flags)718 void ScintillaCall::IndicSetFlags(int indicator, API::IndicFlag flags) {
719 Call(Message::IndicSetFlags, indicator, static_cast<intptr_t>(flags));
720 }
721
IndicGetFlags(int indicator)722 IndicFlag ScintillaCall::IndicGetFlags(int indicator) {
723 return static_cast<API::IndicFlag>(Call(Message::IndicGetFlags, indicator));
724 }
725
SetWhitespaceFore(bool useSetting,Colour fore)726 void ScintillaCall::SetWhitespaceFore(bool useSetting, Colour fore) {
727 Call(Message::SetWhitespaceFore, useSetting, fore);
728 }
729
SetWhitespaceBack(bool useSetting,Colour back)730 void ScintillaCall::SetWhitespaceBack(bool useSetting, Colour back) {
731 Call(Message::SetWhitespaceBack, useSetting, back);
732 }
733
SetWhitespaceSize(int size)734 void ScintillaCall::SetWhitespaceSize(int size) {
735 Call(Message::SetWhitespaceSize, size);
736 }
737
WhitespaceSize()738 int ScintillaCall::WhitespaceSize() {
739 return static_cast<int>(Call(Message::GetWhitespaceSize));
740 }
741
SetLineState(Line line,int state)742 void ScintillaCall::SetLineState(Line line, int state) {
743 Call(Message::SetLineState, line, state);
744 }
745
LineState(Line line)746 int ScintillaCall::LineState(Line line) {
747 return static_cast<int>(Call(Message::GetLineState, line));
748 }
749
MaxLineState()750 int ScintillaCall::MaxLineState() {
751 return static_cast<int>(Call(Message::GetMaxLineState));
752 }
753
CaretLineVisible()754 bool ScintillaCall::CaretLineVisible() {
755 return Call(Message::GetCaretLineVisible);
756 }
757
SetCaretLineVisible(bool show)758 void ScintillaCall::SetCaretLineVisible(bool show) {
759 Call(Message::SetCaretLineVisible, show);
760 }
761
CaretLineBack()762 Colour ScintillaCall::CaretLineBack() {
763 return static_cast<Colour>(Call(Message::GetCaretLineBack));
764 }
765
SetCaretLineBack(Colour back)766 void ScintillaCall::SetCaretLineBack(Colour back) {
767 Call(Message::SetCaretLineBack, back);
768 }
769
CaretLineFrame()770 int ScintillaCall::CaretLineFrame() {
771 return static_cast<int>(Call(Message::GetCaretLineFrame));
772 }
773
SetCaretLineFrame(int width)774 void ScintillaCall::SetCaretLineFrame(int width) {
775 Call(Message::SetCaretLineFrame, width);
776 }
777
StyleSetChangeable(int style,bool changeable)778 void ScintillaCall::StyleSetChangeable(int style, bool changeable) {
779 Call(Message::StyleSetChangeable, style, changeable);
780 }
781
AutoCShow(Position lengthEntered,const char * itemList)782 void ScintillaCall::AutoCShow(Position lengthEntered, const char *itemList) {
783 CallString(Message::AutoCShow, lengthEntered, itemList);
784 }
785
AutoCCancel()786 void ScintillaCall::AutoCCancel() {
787 Call(Message::AutoCCancel);
788 }
789
AutoCActive()790 bool ScintillaCall::AutoCActive() {
791 return Call(Message::AutoCActive);
792 }
793
AutoCPosStart()794 Position ScintillaCall::AutoCPosStart() {
795 return Call(Message::AutoCPosStart);
796 }
797
AutoCComplete()798 void ScintillaCall::AutoCComplete() {
799 Call(Message::AutoCComplete);
800 }
801
AutoCStops(const char * characterSet)802 void ScintillaCall::AutoCStops(const char *characterSet) {
803 CallString(Message::AutoCStops, 0, characterSet);
804 }
805
AutoCSetSeparator(int separatorCharacter)806 void ScintillaCall::AutoCSetSeparator(int separatorCharacter) {
807 Call(Message::AutoCSetSeparator, separatorCharacter);
808 }
809
AutoCGetSeparator()810 int ScintillaCall::AutoCGetSeparator() {
811 return static_cast<int>(Call(Message::AutoCGetSeparator));
812 }
813
AutoCSelect(const char * select)814 void ScintillaCall::AutoCSelect(const char *select) {
815 CallString(Message::AutoCSelect, 0, select);
816 }
817
AutoCSetCancelAtStart(bool cancel)818 void ScintillaCall::AutoCSetCancelAtStart(bool cancel) {
819 Call(Message::AutoCSetCancelAtStart, cancel);
820 }
821
AutoCGetCancelAtStart()822 bool ScintillaCall::AutoCGetCancelAtStart() {
823 return Call(Message::AutoCGetCancelAtStart);
824 }
825
AutoCSetFillUps(const char * characterSet)826 void ScintillaCall::AutoCSetFillUps(const char *characterSet) {
827 CallString(Message::AutoCSetFillUps, 0, characterSet);
828 }
829
AutoCSetChooseSingle(bool chooseSingle)830 void ScintillaCall::AutoCSetChooseSingle(bool chooseSingle) {
831 Call(Message::AutoCSetChooseSingle, chooseSingle);
832 }
833
AutoCGetChooseSingle()834 bool ScintillaCall::AutoCGetChooseSingle() {
835 return Call(Message::AutoCGetChooseSingle);
836 }
837
AutoCSetIgnoreCase(bool ignoreCase)838 void ScintillaCall::AutoCSetIgnoreCase(bool ignoreCase) {
839 Call(Message::AutoCSetIgnoreCase, ignoreCase);
840 }
841
AutoCGetIgnoreCase()842 bool ScintillaCall::AutoCGetIgnoreCase() {
843 return Call(Message::AutoCGetIgnoreCase);
844 }
845
UserListShow(int listType,const char * itemList)846 void ScintillaCall::UserListShow(int listType, const char *itemList) {
847 CallString(Message::UserListShow, listType, itemList);
848 }
849
AutoCSetAutoHide(bool autoHide)850 void ScintillaCall::AutoCSetAutoHide(bool autoHide) {
851 Call(Message::AutoCSetAutoHide, autoHide);
852 }
853
AutoCGetAutoHide()854 bool ScintillaCall::AutoCGetAutoHide() {
855 return Call(Message::AutoCGetAutoHide);
856 }
857
AutoCSetDropRestOfWord(bool dropRestOfWord)858 void ScintillaCall::AutoCSetDropRestOfWord(bool dropRestOfWord) {
859 Call(Message::AutoCSetDropRestOfWord, dropRestOfWord);
860 }
861
AutoCGetDropRestOfWord()862 bool ScintillaCall::AutoCGetDropRestOfWord() {
863 return Call(Message::AutoCGetDropRestOfWord);
864 }
865
RegisterImage(int type,const char * xpmData)866 void ScintillaCall::RegisterImage(int type, const char *xpmData) {
867 CallString(Message::RegisterImage, type, xpmData);
868 }
869
ClearRegisteredImages()870 void ScintillaCall::ClearRegisteredImages() {
871 Call(Message::ClearRegisteredImages);
872 }
873
AutoCGetTypeSeparator()874 int ScintillaCall::AutoCGetTypeSeparator() {
875 return static_cast<int>(Call(Message::AutoCGetTypeSeparator));
876 }
877
AutoCSetTypeSeparator(int separatorCharacter)878 void ScintillaCall::AutoCSetTypeSeparator(int separatorCharacter) {
879 Call(Message::AutoCSetTypeSeparator, separatorCharacter);
880 }
881
AutoCSetMaxWidth(int characterCount)882 void ScintillaCall::AutoCSetMaxWidth(int characterCount) {
883 Call(Message::AutoCSetMaxWidth, characterCount);
884 }
885
AutoCGetMaxWidth()886 int ScintillaCall::AutoCGetMaxWidth() {
887 return static_cast<int>(Call(Message::AutoCGetMaxWidth));
888 }
889
AutoCSetMaxHeight(int rowCount)890 void ScintillaCall::AutoCSetMaxHeight(int rowCount) {
891 Call(Message::AutoCSetMaxHeight, rowCount);
892 }
893
AutoCGetMaxHeight()894 int ScintillaCall::AutoCGetMaxHeight() {
895 return static_cast<int>(Call(Message::AutoCGetMaxHeight));
896 }
897
SetIndent(int indentSize)898 void ScintillaCall::SetIndent(int indentSize) {
899 Call(Message::SetIndent, indentSize);
900 }
901
Indent()902 int ScintillaCall::Indent() {
903 return static_cast<int>(Call(Message::GetIndent));
904 }
905
SetUseTabs(bool useTabs)906 void ScintillaCall::SetUseTabs(bool useTabs) {
907 Call(Message::SetUseTabs, useTabs);
908 }
909
UseTabs()910 bool ScintillaCall::UseTabs() {
911 return Call(Message::GetUseTabs);
912 }
913
SetLineIndentation(Line line,int indentation)914 void ScintillaCall::SetLineIndentation(Line line, int indentation) {
915 Call(Message::SetLineIndentation, line, indentation);
916 }
917
LineIndentation(Line line)918 int ScintillaCall::LineIndentation(Line line) {
919 return static_cast<int>(Call(Message::GetLineIndentation, line));
920 }
921
LineIndentPosition(Line line)922 Position ScintillaCall::LineIndentPosition(Line line) {
923 return Call(Message::GetLineIndentPosition, line);
924 }
925
Column(Position pos)926 Position ScintillaCall::Column(Position pos) {
927 return Call(Message::GetColumn, pos);
928 }
929
CountCharacters(Position start,Position end)930 Position ScintillaCall::CountCharacters(Position start, Position end) {
931 return Call(Message::CountCharacters, start, end);
932 }
933
CountCodeUnits(Position start,Position end)934 Position ScintillaCall::CountCodeUnits(Position start, Position end) {
935 return Call(Message::CountCodeUnits, start, end);
936 }
937
SetHScrollBar(bool visible)938 void ScintillaCall::SetHScrollBar(bool visible) {
939 Call(Message::SetHScrollBar, visible);
940 }
941
HScrollBar()942 bool ScintillaCall::HScrollBar() {
943 return Call(Message::GetHScrollBar);
944 }
945
SetIndentationGuides(API::IndentView indentView)946 void ScintillaCall::SetIndentationGuides(API::IndentView indentView) {
947 Call(Message::SetIndentationGuides, static_cast<uintptr_t>(indentView));
948 }
949
IndentationGuides()950 IndentView ScintillaCall::IndentationGuides() {
951 return static_cast<API::IndentView>(Call(Message::GetIndentationGuides));
952 }
953
SetHighlightGuide(Position column)954 void ScintillaCall::SetHighlightGuide(Position column) {
955 Call(Message::SetHighlightGuide, column);
956 }
957
HighlightGuide()958 Position ScintillaCall::HighlightGuide() {
959 return Call(Message::GetHighlightGuide);
960 }
961
LineEndPosition(Line line)962 Position ScintillaCall::LineEndPosition(Line line) {
963 return Call(Message::GetLineEndPosition, line);
964 }
965
CodePage()966 int ScintillaCall::CodePage() {
967 return static_cast<int>(Call(Message::GetCodePage));
968 }
969
CaretFore()970 Colour ScintillaCall::CaretFore() {
971 return static_cast<Colour>(Call(Message::GetCaretFore));
972 }
973
ReadOnly()974 bool ScintillaCall::ReadOnly() {
975 return Call(Message::GetReadOnly);
976 }
977
SetCurrentPos(Position caret)978 void ScintillaCall::SetCurrentPos(Position caret) {
979 Call(Message::SetCurrentPos, caret);
980 }
981
SetSelectionStart(Position anchor)982 void ScintillaCall::SetSelectionStart(Position anchor) {
983 Call(Message::SetSelectionStart, anchor);
984 }
985
SelectionStart()986 Position ScintillaCall::SelectionStart() {
987 return Call(Message::GetSelectionStart);
988 }
989
SetSelectionEnd(Position caret)990 void ScintillaCall::SetSelectionEnd(Position caret) {
991 Call(Message::SetSelectionEnd, caret);
992 }
993
SelectionEnd()994 Position ScintillaCall::SelectionEnd() {
995 return Call(Message::GetSelectionEnd);
996 }
997
SetEmptySelection(Position caret)998 void ScintillaCall::SetEmptySelection(Position caret) {
999 Call(Message::SetEmptySelection, caret);
1000 }
1001
SetPrintMagnification(int magnification)1002 void ScintillaCall::SetPrintMagnification(int magnification) {
1003 Call(Message::SetPrintMagnification, magnification);
1004 }
1005
PrintMagnification()1006 int ScintillaCall::PrintMagnification() {
1007 return static_cast<int>(Call(Message::GetPrintMagnification));
1008 }
1009
SetPrintColourMode(API::PrintOption mode)1010 void ScintillaCall::SetPrintColourMode(API::PrintOption mode) {
1011 Call(Message::SetPrintColourMode, static_cast<uintptr_t>(mode));
1012 }
1013
PrintColourMode()1014 PrintOption ScintillaCall::PrintColourMode() {
1015 return static_cast<API::PrintOption>(Call(Message::GetPrintColourMode));
1016 }
1017
FindText(API::FindOption searchFlags,void * ft)1018 Position ScintillaCall::FindText(API::FindOption searchFlags, void *ft) {
1019 return CallPointer(Message::FindText, static_cast<uintptr_t>(searchFlags), ft);
1020 }
1021
FormatRange(bool draw,void * fr)1022 Position ScintillaCall::FormatRange(bool draw, void *fr) {
1023 return CallPointer(Message::FormatRange, draw, fr);
1024 }
1025
FirstVisibleLine()1026 Line ScintillaCall::FirstVisibleLine() {
1027 return Call(Message::GetFirstVisibleLine);
1028 }
1029
GetLine(Line line,char * text)1030 Position ScintillaCall::GetLine(Line line, char *text) {
1031 return CallPointer(Message::GetLine, line, text);
1032 }
1033
GetLine(Line line)1034 std::string ScintillaCall::GetLine(Line line) {
1035 return CallReturnString(Message::GetLine, line);
1036 }
1037
LineCount()1038 Line ScintillaCall::LineCount() {
1039 return Call(Message::GetLineCount);
1040 }
1041
SetMarginLeft(int pixelWidth)1042 void ScintillaCall::SetMarginLeft(int pixelWidth) {
1043 Call(Message::SetMarginLeft, 0, pixelWidth);
1044 }
1045
MarginLeft()1046 int ScintillaCall::MarginLeft() {
1047 return static_cast<int>(Call(Message::GetMarginLeft));
1048 }
1049
SetMarginRight(int pixelWidth)1050 void ScintillaCall::SetMarginRight(int pixelWidth) {
1051 Call(Message::SetMarginRight, 0, pixelWidth);
1052 }
1053
MarginRight()1054 int ScintillaCall::MarginRight() {
1055 return static_cast<int>(Call(Message::GetMarginRight));
1056 }
1057
Modify()1058 bool ScintillaCall::Modify() {
1059 return Call(Message::GetModify);
1060 }
1061
SetSel(Position anchor,Position caret)1062 void ScintillaCall::SetSel(Position anchor, Position caret) {
1063 Call(Message::SetSel, anchor, caret);
1064 }
1065
GetSelText(char * text)1066 Position ScintillaCall::GetSelText(char *text) {
1067 return CallPointer(Message::GetSelText, 0, text);
1068 }
1069
GetSelText()1070 std::string ScintillaCall::GetSelText() {
1071 return CallReturnString(Message::GetSelText, 0);
1072 }
1073
GetTextRange(void * tr)1074 Position ScintillaCall::GetTextRange(void *tr) {
1075 return CallPointer(Message::GetTextRange, 0, tr);
1076 }
1077
HideSelection(bool hide)1078 void ScintillaCall::HideSelection(bool hide) {
1079 Call(Message::HideSelection, hide);
1080 }
1081
PointXFromPosition(Position pos)1082 int ScintillaCall::PointXFromPosition(Position pos) {
1083 return static_cast<int>(Call(Message::PointXFromPosition, 0, pos));
1084 }
1085
PointYFromPosition(Position pos)1086 int ScintillaCall::PointYFromPosition(Position pos) {
1087 return static_cast<int>(Call(Message::PointYFromPosition, 0, pos));
1088 }
1089
LineFromPosition(Position pos)1090 Line ScintillaCall::LineFromPosition(Position pos) {
1091 return Call(Message::LineFromPosition, pos);
1092 }
1093
PositionFromLine(Line line)1094 Position ScintillaCall::PositionFromLine(Line line) {
1095 return Call(Message::PositionFromLine, line);
1096 }
1097
LineScroll(Position columns,Line lines)1098 void ScintillaCall::LineScroll(Position columns, Line lines) {
1099 Call(Message::LineScroll, columns, lines);
1100 }
1101
ScrollCaret()1102 void ScintillaCall::ScrollCaret() {
1103 Call(Message::ScrollCaret);
1104 }
1105
ScrollRange(Position secondary,Position primary)1106 void ScintillaCall::ScrollRange(Position secondary, Position primary) {
1107 Call(Message::ScrollRange, secondary, primary);
1108 }
1109
ReplaceSel(const char * text)1110 void ScintillaCall::ReplaceSel(const char *text) {
1111 CallString(Message::ReplaceSel, 0, text);
1112 }
1113
SetReadOnly(bool readOnly)1114 void ScintillaCall::SetReadOnly(bool readOnly) {
1115 Call(Message::SetReadOnly, readOnly);
1116 }
1117
Null()1118 void ScintillaCall::Null() {
1119 Call(Message::Null);
1120 }
1121
CanPaste()1122 bool ScintillaCall::CanPaste() {
1123 return Call(Message::CanPaste);
1124 }
1125
CanUndo()1126 bool ScintillaCall::CanUndo() {
1127 return Call(Message::CanUndo);
1128 }
1129
EmptyUndoBuffer()1130 void ScintillaCall::EmptyUndoBuffer() {
1131 Call(Message::EmptyUndoBuffer);
1132 }
1133
Undo()1134 void ScintillaCall::Undo() {
1135 Call(Message::Undo);
1136 }
1137
Cut()1138 void ScintillaCall::Cut() {
1139 Call(Message::Cut);
1140 }
1141
Copy()1142 void ScintillaCall::Copy() {
1143 Call(Message::Copy);
1144 }
1145
Paste()1146 void ScintillaCall::Paste() {
1147 Call(Message::Paste);
1148 }
1149
Clear()1150 void ScintillaCall::Clear() {
1151 Call(Message::Clear);
1152 }
1153
SetText(const char * text)1154 void ScintillaCall::SetText(const char *text) {
1155 CallString(Message::SetText, 0, text);
1156 }
1157
GetText(Position length,char * text)1158 Position ScintillaCall::GetText(Position length, char *text) {
1159 return CallPointer(Message::GetText, length, text);
1160 }
1161
GetText(Position length)1162 std::string ScintillaCall::GetText(Position length) {
1163 return CallReturnString(Message::GetText, length);
1164 }
1165
TextLength()1166 Position ScintillaCall::TextLength() {
1167 return Call(Message::GetTextLength);
1168 }
1169
DirectFunction()1170 void *ScintillaCall::DirectFunction() {
1171 return reinterpret_cast<void *>(Call(Message::GetDirectFunction));
1172 }
1173
DirectPointer()1174 void *ScintillaCall::DirectPointer() {
1175 return reinterpret_cast<void *>(Call(Message::GetDirectPointer));
1176 }
1177
SetOvertype(bool overType)1178 void ScintillaCall::SetOvertype(bool overType) {
1179 Call(Message::SetOvertype, overType);
1180 }
1181
Overtype()1182 bool ScintillaCall::Overtype() {
1183 return Call(Message::GetOvertype);
1184 }
1185
SetCaretWidth(int pixelWidth)1186 void ScintillaCall::SetCaretWidth(int pixelWidth) {
1187 Call(Message::SetCaretWidth, pixelWidth);
1188 }
1189
CaretWidth()1190 int ScintillaCall::CaretWidth() {
1191 return static_cast<int>(Call(Message::GetCaretWidth));
1192 }
1193
SetTargetStart(Position start)1194 void ScintillaCall::SetTargetStart(Position start) {
1195 Call(Message::SetTargetStart, start);
1196 }
1197
TargetStart()1198 Position ScintillaCall::TargetStart() {
1199 return Call(Message::GetTargetStart);
1200 }
1201
SetTargetStartVirtualSpace(Position space)1202 void ScintillaCall::SetTargetStartVirtualSpace(Position space) {
1203 Call(Message::SetTargetStartVirtualSpace, space);
1204 }
1205
TargetStartVirtualSpace()1206 Position ScintillaCall::TargetStartVirtualSpace() {
1207 return Call(Message::GetTargetStartVirtualSpace);
1208 }
1209
SetTargetEnd(Position end)1210 void ScintillaCall::SetTargetEnd(Position end) {
1211 Call(Message::SetTargetEnd, end);
1212 }
1213
TargetEnd()1214 Position ScintillaCall::TargetEnd() {
1215 return Call(Message::GetTargetEnd);
1216 }
1217
SetTargetEndVirtualSpace(Position space)1218 void ScintillaCall::SetTargetEndVirtualSpace(Position space) {
1219 Call(Message::SetTargetEndVirtualSpace, space);
1220 }
1221
TargetEndVirtualSpace()1222 Position ScintillaCall::TargetEndVirtualSpace() {
1223 return Call(Message::GetTargetEndVirtualSpace);
1224 }
1225
SetTargetRange(Position start,Position end)1226 void ScintillaCall::SetTargetRange(Position start, Position end) {
1227 Call(Message::SetTargetRange, start, end);
1228 }
1229
TargetText(char * text)1230 Position ScintillaCall::TargetText(char *text) {
1231 return CallPointer(Message::GetTargetText, 0, text);
1232 }
1233
TargetText()1234 std::string ScintillaCall::TargetText() {
1235 return CallReturnString(Message::GetTargetText, 0);
1236 }
1237
TargetFromSelection()1238 void ScintillaCall::TargetFromSelection() {
1239 Call(Message::TargetFromSelection);
1240 }
1241
TargetWholeDocument()1242 void ScintillaCall::TargetWholeDocument() {
1243 Call(Message::TargetWholeDocument);
1244 }
1245
ReplaceTarget(Position length,const char * text)1246 Position ScintillaCall::ReplaceTarget(Position length, const char *text) {
1247 return CallString(Message::ReplaceTarget, length, text);
1248 }
1249
ReplaceTargetRE(Position length,const char * text)1250 Position ScintillaCall::ReplaceTargetRE(Position length, const char *text) {
1251 return CallString(Message::ReplaceTargetRE, length, text);
1252 }
1253
SearchInTarget(Position length,const char * text)1254 Position ScintillaCall::SearchInTarget(Position length, const char *text) {
1255 return CallString(Message::SearchInTarget, length, text);
1256 }
1257
SetSearchFlags(API::FindOption searchFlags)1258 void ScintillaCall::SetSearchFlags(API::FindOption searchFlags) {
1259 Call(Message::SetSearchFlags, static_cast<uintptr_t>(searchFlags));
1260 }
1261
SearchFlags()1262 FindOption ScintillaCall::SearchFlags() {
1263 return static_cast<API::FindOption>(Call(Message::GetSearchFlags));
1264 }
1265
CallTipShow(Position pos,const char * definition)1266 void ScintillaCall::CallTipShow(Position pos, const char *definition) {
1267 CallString(Message::CallTipShow, pos, definition);
1268 }
1269
CallTipCancel()1270 void ScintillaCall::CallTipCancel() {
1271 Call(Message::CallTipCancel);
1272 }
1273
CallTipActive()1274 bool ScintillaCall::CallTipActive() {
1275 return Call(Message::CallTipActive);
1276 }
1277
CallTipPosStart()1278 Position ScintillaCall::CallTipPosStart() {
1279 return Call(Message::CallTipPosStart);
1280 }
1281
CallTipSetPosStart(Position posStart)1282 void ScintillaCall::CallTipSetPosStart(Position posStart) {
1283 Call(Message::CallTipSetPosStart, posStart);
1284 }
1285
CallTipSetHlt(Position highlightStart,Position highlightEnd)1286 void ScintillaCall::CallTipSetHlt(Position highlightStart, Position highlightEnd) {
1287 Call(Message::CallTipSetHlt, highlightStart, highlightEnd);
1288 }
1289
CallTipSetBack(Colour back)1290 void ScintillaCall::CallTipSetBack(Colour back) {
1291 Call(Message::CallTipSetBack, back);
1292 }
1293
CallTipSetFore(Colour fore)1294 void ScintillaCall::CallTipSetFore(Colour fore) {
1295 Call(Message::CallTipSetFore, fore);
1296 }
1297
CallTipSetForeHlt(Colour fore)1298 void ScintillaCall::CallTipSetForeHlt(Colour fore) {
1299 Call(Message::CallTipSetForeHlt, fore);
1300 }
1301
CallTipUseStyle(int tabSize)1302 void ScintillaCall::CallTipUseStyle(int tabSize) {
1303 Call(Message::CallTipUseStyle, tabSize);
1304 }
1305
CallTipSetPosition(bool above)1306 void ScintillaCall::CallTipSetPosition(bool above) {
1307 Call(Message::CallTipSetPosition, above);
1308 }
1309
VisibleFromDocLine(Line docLine)1310 Line ScintillaCall::VisibleFromDocLine(Line docLine) {
1311 return Call(Message::VisibleFromDocLine, docLine);
1312 }
1313
DocLineFromVisible(Line displayLine)1314 Line ScintillaCall::DocLineFromVisible(Line displayLine) {
1315 return Call(Message::DocLineFromVisible, displayLine);
1316 }
1317
WrapCount(Line docLine)1318 Line ScintillaCall::WrapCount(Line docLine) {
1319 return Call(Message::WrapCount, docLine);
1320 }
1321
SetFoldLevel(Line line,API::FoldLevel level)1322 void ScintillaCall::SetFoldLevel(Line line, API::FoldLevel level) {
1323 Call(Message::SetFoldLevel, line, static_cast<intptr_t>(level));
1324 }
1325
FoldLevel(Line line)1326 FoldLevel ScintillaCall::FoldLevel(Line line) {
1327 return static_cast<API::FoldLevel>(Call(Message::GetFoldLevel, line));
1328 }
1329
LastChild(Line line,API::FoldLevel level)1330 Line ScintillaCall::LastChild(Line line, API::FoldLevel level) {
1331 return Call(Message::GetLastChild, line, static_cast<intptr_t>(level));
1332 }
1333
FoldParent(Line line)1334 Line ScintillaCall::FoldParent(Line line) {
1335 return Call(Message::GetFoldParent, line);
1336 }
1337
ShowLines(Line lineStart,Line lineEnd)1338 void ScintillaCall::ShowLines(Line lineStart, Line lineEnd) {
1339 Call(Message::ShowLines, lineStart, lineEnd);
1340 }
1341
HideLines(Line lineStart,Line lineEnd)1342 void ScintillaCall::HideLines(Line lineStart, Line lineEnd) {
1343 Call(Message::HideLines, lineStart, lineEnd);
1344 }
1345
LineVisible(Line line)1346 bool ScintillaCall::LineVisible(Line line) {
1347 return Call(Message::GetLineVisible, line);
1348 }
1349
AllLinesVisible()1350 bool ScintillaCall::AllLinesVisible() {
1351 return Call(Message::GetAllLinesVisible);
1352 }
1353
SetFoldExpanded(Line line,bool expanded)1354 void ScintillaCall::SetFoldExpanded(Line line, bool expanded) {
1355 Call(Message::SetFoldExpanded, line, expanded);
1356 }
1357
FoldExpanded(Line line)1358 bool ScintillaCall::FoldExpanded(Line line) {
1359 return Call(Message::GetFoldExpanded, line);
1360 }
1361
ToggleFold(Line line)1362 void ScintillaCall::ToggleFold(Line line) {
1363 Call(Message::ToggleFold, line);
1364 }
1365
ToggleFoldShowText(Line line,const char * text)1366 void ScintillaCall::ToggleFoldShowText(Line line, const char *text) {
1367 CallString(Message::ToggleFoldShowText, line, text);
1368 }
1369
FoldDisplayTextSetStyle(API::FoldDisplayTextStyle style)1370 void ScintillaCall::FoldDisplayTextSetStyle(API::FoldDisplayTextStyle style) {
1371 Call(Message::FoldDisplayTextSetStyle, static_cast<uintptr_t>(style));
1372 }
1373
FoldDisplayTextGetStyle()1374 FoldDisplayTextStyle ScintillaCall::FoldDisplayTextGetStyle() {
1375 return static_cast<API::FoldDisplayTextStyle>(Call(Message::FoldDisplayTextGetStyle));
1376 }
1377
SetDefaultFoldDisplayText(const char * text)1378 void ScintillaCall::SetDefaultFoldDisplayText(const char *text) {
1379 CallString(Message::SetDefaultFoldDisplayText, 0, text);
1380 }
1381
GetDefaultFoldDisplayText(char * text)1382 int ScintillaCall::GetDefaultFoldDisplayText(char *text) {
1383 return static_cast<int>(CallPointer(Message::GetDefaultFoldDisplayText, 0, text));
1384 }
1385
GetDefaultFoldDisplayText()1386 std::string ScintillaCall::GetDefaultFoldDisplayText() {
1387 return CallReturnString(Message::GetDefaultFoldDisplayText, 0);
1388 }
1389
FoldLine(Line line,API::FoldAction action)1390 void ScintillaCall::FoldLine(Line line, API::FoldAction action) {
1391 Call(Message::FoldLine, line, static_cast<intptr_t>(action));
1392 }
1393
FoldChildren(Line line,API::FoldAction action)1394 void ScintillaCall::FoldChildren(Line line, API::FoldAction action) {
1395 Call(Message::FoldChildren, line, static_cast<intptr_t>(action));
1396 }
1397
ExpandChildren(Line line,API::FoldLevel level)1398 void ScintillaCall::ExpandChildren(Line line, API::FoldLevel level) {
1399 Call(Message::ExpandChildren, line, static_cast<intptr_t>(level));
1400 }
1401
FoldAll(API::FoldAction action)1402 void ScintillaCall::FoldAll(API::FoldAction action) {
1403 Call(Message::FoldAll, static_cast<uintptr_t>(action));
1404 }
1405
EnsureVisible(Line line)1406 void ScintillaCall::EnsureVisible(Line line) {
1407 Call(Message::EnsureVisible, line);
1408 }
1409
SetAutomaticFold(API::AutomaticFold automaticFold)1410 void ScintillaCall::SetAutomaticFold(API::AutomaticFold automaticFold) {
1411 Call(Message::SetAutomaticFold, static_cast<uintptr_t>(automaticFold));
1412 }
1413
AutomaticFold()1414 AutomaticFold ScintillaCall::AutomaticFold() {
1415 return static_cast<API::AutomaticFold>(Call(Message::GetAutomaticFold));
1416 }
1417
SetFoldFlags(API::FoldFlag flags)1418 void ScintillaCall::SetFoldFlags(API::FoldFlag flags) {
1419 Call(Message::SetFoldFlags, static_cast<uintptr_t>(flags));
1420 }
1421
EnsureVisibleEnforcePolicy(Line line)1422 void ScintillaCall::EnsureVisibleEnforcePolicy(Line line) {
1423 Call(Message::EnsureVisibleEnforcePolicy, line);
1424 }
1425
SetTabIndents(bool tabIndents)1426 void ScintillaCall::SetTabIndents(bool tabIndents) {
1427 Call(Message::SetTabIndents, tabIndents);
1428 }
1429
TabIndents()1430 bool ScintillaCall::TabIndents() {
1431 return Call(Message::GetTabIndents);
1432 }
1433
SetBackSpaceUnIndents(bool bsUnIndents)1434 void ScintillaCall::SetBackSpaceUnIndents(bool bsUnIndents) {
1435 Call(Message::SetBackSpaceUnIndents, bsUnIndents);
1436 }
1437
BackSpaceUnIndents()1438 bool ScintillaCall::BackSpaceUnIndents() {
1439 return Call(Message::GetBackSpaceUnIndents);
1440 }
1441
SetMouseDwellTime(int periodMilliseconds)1442 void ScintillaCall::SetMouseDwellTime(int periodMilliseconds) {
1443 Call(Message::SetMouseDwellTime, periodMilliseconds);
1444 }
1445
MouseDwellTime()1446 int ScintillaCall::MouseDwellTime() {
1447 return static_cast<int>(Call(Message::GetMouseDwellTime));
1448 }
1449
WordStartPosition(Position pos,bool onlyWordCharacters)1450 Position ScintillaCall::WordStartPosition(Position pos, bool onlyWordCharacters) {
1451 return Call(Message::WordStartPosition, pos, onlyWordCharacters);
1452 }
1453
WordEndPosition(Position pos,bool onlyWordCharacters)1454 Position ScintillaCall::WordEndPosition(Position pos, bool onlyWordCharacters) {
1455 return Call(Message::WordEndPosition, pos, onlyWordCharacters);
1456 }
1457
IsRangeWord(Position start,Position end)1458 bool ScintillaCall::IsRangeWord(Position start, Position end) {
1459 return Call(Message::IsRangeWord, start, end);
1460 }
1461
SetIdleStyling(API::IdleStyling idleStyling)1462 void ScintillaCall::SetIdleStyling(API::IdleStyling idleStyling) {
1463 Call(Message::SetIdleStyling, static_cast<uintptr_t>(idleStyling));
1464 }
1465
IdleStyling()1466 IdleStyling ScintillaCall::IdleStyling() {
1467 return static_cast<API::IdleStyling>(Call(Message::GetIdleStyling));
1468 }
1469
SetWrapMode(API::Wrap wrapMode)1470 void ScintillaCall::SetWrapMode(API::Wrap wrapMode) {
1471 Call(Message::SetWrapMode, static_cast<uintptr_t>(wrapMode));
1472 }
1473
WrapMode()1474 Wrap ScintillaCall::WrapMode() {
1475 return static_cast<API::Wrap>(Call(Message::GetWrapMode));
1476 }
1477
SetWrapVisualFlags(API::WrapVisualFlag wrapVisualFlags)1478 void ScintillaCall::SetWrapVisualFlags(API::WrapVisualFlag wrapVisualFlags) {
1479 Call(Message::SetWrapVisualFlags, static_cast<uintptr_t>(wrapVisualFlags));
1480 }
1481
WrapVisualFlags()1482 WrapVisualFlag ScintillaCall::WrapVisualFlags() {
1483 return static_cast<API::WrapVisualFlag>(Call(Message::GetWrapVisualFlags));
1484 }
1485
SetWrapVisualFlagsLocation(API::WrapVisualLocation wrapVisualFlagsLocation)1486 void ScintillaCall::SetWrapVisualFlagsLocation(API::WrapVisualLocation wrapVisualFlagsLocation) {
1487 Call(Message::SetWrapVisualFlagsLocation, static_cast<uintptr_t>(wrapVisualFlagsLocation));
1488 }
1489
WrapVisualFlagsLocation()1490 WrapVisualLocation ScintillaCall::WrapVisualFlagsLocation() {
1491 return static_cast<API::WrapVisualLocation>(Call(Message::GetWrapVisualFlagsLocation));
1492 }
1493
SetWrapStartIndent(int indent)1494 void ScintillaCall::SetWrapStartIndent(int indent) {
1495 Call(Message::SetWrapStartIndent, indent);
1496 }
1497
WrapStartIndent()1498 int ScintillaCall::WrapStartIndent() {
1499 return static_cast<int>(Call(Message::GetWrapStartIndent));
1500 }
1501
SetWrapIndentMode(API::WrapIndentMode wrapIndentMode)1502 void ScintillaCall::SetWrapIndentMode(API::WrapIndentMode wrapIndentMode) {
1503 Call(Message::SetWrapIndentMode, static_cast<uintptr_t>(wrapIndentMode));
1504 }
1505
WrapIndentMode()1506 WrapIndentMode ScintillaCall::WrapIndentMode() {
1507 return static_cast<API::WrapIndentMode>(Call(Message::GetWrapIndentMode));
1508 }
1509
SetLayoutCache(API::LineCache cacheMode)1510 void ScintillaCall::SetLayoutCache(API::LineCache cacheMode) {
1511 Call(Message::SetLayoutCache, static_cast<uintptr_t>(cacheMode));
1512 }
1513
LayoutCache()1514 LineCache ScintillaCall::LayoutCache() {
1515 return static_cast<API::LineCache>(Call(Message::GetLayoutCache));
1516 }
1517
SetScrollWidth(int pixelWidth)1518 void ScintillaCall::SetScrollWidth(int pixelWidth) {
1519 Call(Message::SetScrollWidth, pixelWidth);
1520 }
1521
ScrollWidth()1522 int ScintillaCall::ScrollWidth() {
1523 return static_cast<int>(Call(Message::GetScrollWidth));
1524 }
1525
SetScrollWidthTracking(bool tracking)1526 void ScintillaCall::SetScrollWidthTracking(bool tracking) {
1527 Call(Message::SetScrollWidthTracking, tracking);
1528 }
1529
ScrollWidthTracking()1530 bool ScintillaCall::ScrollWidthTracking() {
1531 return Call(Message::GetScrollWidthTracking);
1532 }
1533
TextWidth(int style,const char * text)1534 int ScintillaCall::TextWidth(int style, const char *text) {
1535 return static_cast<int>(CallString(Message::TextWidth, style, text));
1536 }
1537
SetEndAtLastLine(bool endAtLastLine)1538 void ScintillaCall::SetEndAtLastLine(bool endAtLastLine) {
1539 Call(Message::SetEndAtLastLine, endAtLastLine);
1540 }
1541
EndAtLastLine()1542 bool ScintillaCall::EndAtLastLine() {
1543 return Call(Message::GetEndAtLastLine);
1544 }
1545
TextHeight(Line line)1546 int ScintillaCall::TextHeight(Line line) {
1547 return static_cast<int>(Call(Message::TextHeight, line));
1548 }
1549
SetVScrollBar(bool visible)1550 void ScintillaCall::SetVScrollBar(bool visible) {
1551 Call(Message::SetVScrollBar, visible);
1552 }
1553
VScrollBar()1554 bool ScintillaCall::VScrollBar() {
1555 return Call(Message::GetVScrollBar);
1556 }
1557
AppendText(Position length,const char * text)1558 void ScintillaCall::AppendText(Position length, const char *text) {
1559 CallString(Message::AppendText, length, text);
1560 }
1561
PhasesDraw()1562 PhasesDraw ScintillaCall::PhasesDraw() {
1563 return static_cast<API::PhasesDraw>(Call(Message::GetPhasesDraw));
1564 }
1565
SetPhasesDraw(API::PhasesDraw phases)1566 void ScintillaCall::SetPhasesDraw(API::PhasesDraw phases) {
1567 Call(Message::SetPhasesDraw, static_cast<uintptr_t>(phases));
1568 }
1569
SetFontQuality(API::FontQuality fontQuality)1570 void ScintillaCall::SetFontQuality(API::FontQuality fontQuality) {
1571 Call(Message::SetFontQuality, static_cast<uintptr_t>(fontQuality));
1572 }
1573
FontQuality()1574 FontQuality ScintillaCall::FontQuality() {
1575 return static_cast<API::FontQuality>(Call(Message::GetFontQuality));
1576 }
1577
SetFirstVisibleLine(Line displayLine)1578 void ScintillaCall::SetFirstVisibleLine(Line displayLine) {
1579 Call(Message::SetFirstVisibleLine, displayLine);
1580 }
1581
SetMultiPaste(API::MultiPaste multiPaste)1582 void ScintillaCall::SetMultiPaste(API::MultiPaste multiPaste) {
1583 Call(Message::SetMultiPaste, static_cast<uintptr_t>(multiPaste));
1584 }
1585
MultiPaste()1586 MultiPaste ScintillaCall::MultiPaste() {
1587 return static_cast<API::MultiPaste>(Call(Message::GetMultiPaste));
1588 }
1589
Tag(int tagNumber,char * tagValue)1590 int ScintillaCall::Tag(int tagNumber, char *tagValue) {
1591 return static_cast<int>(CallPointer(Message::GetTag, tagNumber, tagValue));
1592 }
1593
Tag(int tagNumber)1594 std::string ScintillaCall::Tag(int tagNumber) {
1595 return CallReturnString(Message::GetTag, tagNumber);
1596 }
1597
LinesJoin()1598 void ScintillaCall::LinesJoin() {
1599 Call(Message::LinesJoin);
1600 }
1601
LinesSplit(int pixelWidth)1602 void ScintillaCall::LinesSplit(int pixelWidth) {
1603 Call(Message::LinesSplit, pixelWidth);
1604 }
1605
SetFoldMarginColour(bool useSetting,Colour back)1606 void ScintillaCall::SetFoldMarginColour(bool useSetting, Colour back) {
1607 Call(Message::SetFoldMarginColour, useSetting, back);
1608 }
1609
SetFoldMarginHiColour(bool useSetting,Colour fore)1610 void ScintillaCall::SetFoldMarginHiColour(bool useSetting, Colour fore) {
1611 Call(Message::SetFoldMarginHiColour, useSetting, fore);
1612 }
1613
SetAccessibility(API::Accessibility accessibility)1614 void ScintillaCall::SetAccessibility(API::Accessibility accessibility) {
1615 Call(Message::SetAccessibility, static_cast<uintptr_t>(accessibility));
1616 }
1617
Accessibility()1618 Accessibility ScintillaCall::Accessibility() {
1619 return static_cast<API::Accessibility>(Call(Message::GetAccessibility));
1620 }
1621
LineDown()1622 void ScintillaCall::LineDown() {
1623 Call(Message::LineDown);
1624 }
1625
LineDownExtend()1626 void ScintillaCall::LineDownExtend() {
1627 Call(Message::LineDownExtend);
1628 }
1629
LineUp()1630 void ScintillaCall::LineUp() {
1631 Call(Message::LineUp);
1632 }
1633
LineUpExtend()1634 void ScintillaCall::LineUpExtend() {
1635 Call(Message::LineUpExtend);
1636 }
1637
CharLeft()1638 void ScintillaCall::CharLeft() {
1639 Call(Message::CharLeft);
1640 }
1641
CharLeftExtend()1642 void ScintillaCall::CharLeftExtend() {
1643 Call(Message::CharLeftExtend);
1644 }
1645
CharRight()1646 void ScintillaCall::CharRight() {
1647 Call(Message::CharRight);
1648 }
1649
CharRightExtend()1650 void ScintillaCall::CharRightExtend() {
1651 Call(Message::CharRightExtend);
1652 }
1653
WordLeft()1654 void ScintillaCall::WordLeft() {
1655 Call(Message::WordLeft);
1656 }
1657
WordLeftExtend()1658 void ScintillaCall::WordLeftExtend() {
1659 Call(Message::WordLeftExtend);
1660 }
1661
WordRight()1662 void ScintillaCall::WordRight() {
1663 Call(Message::WordRight);
1664 }
1665
WordRightExtend()1666 void ScintillaCall::WordRightExtend() {
1667 Call(Message::WordRightExtend);
1668 }
1669
Home()1670 void ScintillaCall::Home() {
1671 Call(Message::Home);
1672 }
1673
HomeExtend()1674 void ScintillaCall::HomeExtend() {
1675 Call(Message::HomeExtend);
1676 }
1677
LineEnd()1678 void ScintillaCall::LineEnd() {
1679 Call(Message::LineEnd);
1680 }
1681
LineEndExtend()1682 void ScintillaCall::LineEndExtend() {
1683 Call(Message::LineEndExtend);
1684 }
1685
DocumentStart()1686 void ScintillaCall::DocumentStart() {
1687 Call(Message::DocumentStart);
1688 }
1689
DocumentStartExtend()1690 void ScintillaCall::DocumentStartExtend() {
1691 Call(Message::DocumentStartExtend);
1692 }
1693
DocumentEnd()1694 void ScintillaCall::DocumentEnd() {
1695 Call(Message::DocumentEnd);
1696 }
1697
DocumentEndExtend()1698 void ScintillaCall::DocumentEndExtend() {
1699 Call(Message::DocumentEndExtend);
1700 }
1701
PageUp()1702 void ScintillaCall::PageUp() {
1703 Call(Message::PageUp);
1704 }
1705
PageUpExtend()1706 void ScintillaCall::PageUpExtend() {
1707 Call(Message::PageUpExtend);
1708 }
1709
PageDown()1710 void ScintillaCall::PageDown() {
1711 Call(Message::PageDown);
1712 }
1713
PageDownExtend()1714 void ScintillaCall::PageDownExtend() {
1715 Call(Message::PageDownExtend);
1716 }
1717
EditToggleOvertype()1718 void ScintillaCall::EditToggleOvertype() {
1719 Call(Message::EditToggleOvertype);
1720 }
1721
Cancel()1722 void ScintillaCall::Cancel() {
1723 Call(Message::Cancel);
1724 }
1725
DeleteBack()1726 void ScintillaCall::DeleteBack() {
1727 Call(Message::DeleteBack);
1728 }
1729
Tab()1730 void ScintillaCall::Tab() {
1731 Call(Message::Tab);
1732 }
1733
BackTab()1734 void ScintillaCall::BackTab() {
1735 Call(Message::BackTab);
1736 }
1737
NewLine()1738 void ScintillaCall::NewLine() {
1739 Call(Message::NewLine);
1740 }
1741
FormFeed()1742 void ScintillaCall::FormFeed() {
1743 Call(Message::FormFeed);
1744 }
1745
VCHome()1746 void ScintillaCall::VCHome() {
1747 Call(Message::VCHome);
1748 }
1749
VCHomeExtend()1750 void ScintillaCall::VCHomeExtend() {
1751 Call(Message::VCHomeExtend);
1752 }
1753
ZoomIn()1754 void ScintillaCall::ZoomIn() {
1755 Call(Message::ZoomIn);
1756 }
1757
ZoomOut()1758 void ScintillaCall::ZoomOut() {
1759 Call(Message::ZoomOut);
1760 }
1761
DelWordLeft()1762 void ScintillaCall::DelWordLeft() {
1763 Call(Message::DelWordLeft);
1764 }
1765
DelWordRight()1766 void ScintillaCall::DelWordRight() {
1767 Call(Message::DelWordRight);
1768 }
1769
DelWordRightEnd()1770 void ScintillaCall::DelWordRightEnd() {
1771 Call(Message::DelWordRightEnd);
1772 }
1773
LineCut()1774 void ScintillaCall::LineCut() {
1775 Call(Message::LineCut);
1776 }
1777
LineDelete()1778 void ScintillaCall::LineDelete() {
1779 Call(Message::LineDelete);
1780 }
1781
LineTranspose()1782 void ScintillaCall::LineTranspose() {
1783 Call(Message::LineTranspose);
1784 }
1785
LineReverse()1786 void ScintillaCall::LineReverse() {
1787 Call(Message::LineReverse);
1788 }
1789
LineDuplicate()1790 void ScintillaCall::LineDuplicate() {
1791 Call(Message::LineDuplicate);
1792 }
1793
LowerCase()1794 void ScintillaCall::LowerCase() {
1795 Call(Message::LowerCase);
1796 }
1797
UpperCase()1798 void ScintillaCall::UpperCase() {
1799 Call(Message::UpperCase);
1800 }
1801
LineScrollDown()1802 void ScintillaCall::LineScrollDown() {
1803 Call(Message::LineScrollDown);
1804 }
1805
LineScrollUp()1806 void ScintillaCall::LineScrollUp() {
1807 Call(Message::LineScrollUp);
1808 }
1809
DeleteBackNotLine()1810 void ScintillaCall::DeleteBackNotLine() {
1811 Call(Message::DeleteBackNotLine);
1812 }
1813
HomeDisplay()1814 void ScintillaCall::HomeDisplay() {
1815 Call(Message::HomeDisplay);
1816 }
1817
HomeDisplayExtend()1818 void ScintillaCall::HomeDisplayExtend() {
1819 Call(Message::HomeDisplayExtend);
1820 }
1821
LineEndDisplay()1822 void ScintillaCall::LineEndDisplay() {
1823 Call(Message::LineEndDisplay);
1824 }
1825
LineEndDisplayExtend()1826 void ScintillaCall::LineEndDisplayExtend() {
1827 Call(Message::LineEndDisplayExtend);
1828 }
1829
HomeWrap()1830 void ScintillaCall::HomeWrap() {
1831 Call(Message::HomeWrap);
1832 }
1833
HomeWrapExtend()1834 void ScintillaCall::HomeWrapExtend() {
1835 Call(Message::HomeWrapExtend);
1836 }
1837
LineEndWrap()1838 void ScintillaCall::LineEndWrap() {
1839 Call(Message::LineEndWrap);
1840 }
1841
LineEndWrapExtend()1842 void ScintillaCall::LineEndWrapExtend() {
1843 Call(Message::LineEndWrapExtend);
1844 }
1845
VCHomeWrap()1846 void ScintillaCall::VCHomeWrap() {
1847 Call(Message::VCHomeWrap);
1848 }
1849
VCHomeWrapExtend()1850 void ScintillaCall::VCHomeWrapExtend() {
1851 Call(Message::VCHomeWrapExtend);
1852 }
1853
LineCopy()1854 void ScintillaCall::LineCopy() {
1855 Call(Message::LineCopy);
1856 }
1857
MoveCaretInsideView()1858 void ScintillaCall::MoveCaretInsideView() {
1859 Call(Message::MoveCaretInsideView);
1860 }
1861
LineLength(Line line)1862 Position ScintillaCall::LineLength(Line line) {
1863 return Call(Message::LineLength, line);
1864 }
1865
BraceHighlight(Position posA,Position posB)1866 void ScintillaCall::BraceHighlight(Position posA, Position posB) {
1867 Call(Message::BraceHighlight, posA, posB);
1868 }
1869
BraceHighlightIndicator(bool useSetting,int indicator)1870 void ScintillaCall::BraceHighlightIndicator(bool useSetting, int indicator) {
1871 Call(Message::BraceHighlightIndicator, useSetting, indicator);
1872 }
1873
BraceBadLight(Position pos)1874 void ScintillaCall::BraceBadLight(Position pos) {
1875 Call(Message::BraceBadLight, pos);
1876 }
1877
BraceBadLightIndicator(bool useSetting,int indicator)1878 void ScintillaCall::BraceBadLightIndicator(bool useSetting, int indicator) {
1879 Call(Message::BraceBadLightIndicator, useSetting, indicator);
1880 }
1881
BraceMatch(Position pos,int maxReStyle)1882 Position ScintillaCall::BraceMatch(Position pos, int maxReStyle) {
1883 return Call(Message::BraceMatch, pos, maxReStyle);
1884 }
1885
BraceMatchNext(Position pos,Position startPos)1886 Position ScintillaCall::BraceMatchNext(Position pos, Position startPos) {
1887 return Call(Message::BraceMatchNext, pos, startPos);
1888 }
1889
ViewEOL()1890 bool ScintillaCall::ViewEOL() {
1891 return Call(Message::GetViewEOL);
1892 }
1893
SetViewEOL(bool visible)1894 void ScintillaCall::SetViewEOL(bool visible) {
1895 Call(Message::SetViewEOL, visible);
1896 }
1897
DocPointer()1898 void *ScintillaCall::DocPointer() {
1899 return reinterpret_cast<void *>(Call(Message::GetDocPointer));
1900 }
1901
SetDocPointer(void * doc)1902 void ScintillaCall::SetDocPointer(void *doc) {
1903 CallPointer(Message::SetDocPointer, 0, doc);
1904 }
1905
SetModEventMask(API::ModificationFlags eventMask)1906 void ScintillaCall::SetModEventMask(API::ModificationFlags eventMask) {
1907 Call(Message::SetModEventMask, static_cast<uintptr_t>(eventMask));
1908 }
1909
EdgeColumn()1910 Position ScintillaCall::EdgeColumn() {
1911 return Call(Message::GetEdgeColumn);
1912 }
1913
SetEdgeColumn(Position column)1914 void ScintillaCall::SetEdgeColumn(Position column) {
1915 Call(Message::SetEdgeColumn, column);
1916 }
1917
EdgeMode()1918 EdgeVisualStyle ScintillaCall::EdgeMode() {
1919 return static_cast<API::EdgeVisualStyle>(Call(Message::GetEdgeMode));
1920 }
1921
SetEdgeMode(API::EdgeVisualStyle edgeMode)1922 void ScintillaCall::SetEdgeMode(API::EdgeVisualStyle edgeMode) {
1923 Call(Message::SetEdgeMode, static_cast<uintptr_t>(edgeMode));
1924 }
1925
EdgeColour()1926 Colour ScintillaCall::EdgeColour() {
1927 return static_cast<Colour>(Call(Message::GetEdgeColour));
1928 }
1929
SetEdgeColour(Colour edgeColour)1930 void ScintillaCall::SetEdgeColour(Colour edgeColour) {
1931 Call(Message::SetEdgeColour, edgeColour);
1932 }
1933
MultiEdgeAddLine(Position column,Colour edgeColour)1934 void ScintillaCall::MultiEdgeAddLine(Position column, Colour edgeColour) {
1935 Call(Message::MultiEdgeAddLine, column, edgeColour);
1936 }
1937
MultiEdgeClearAll()1938 void ScintillaCall::MultiEdgeClearAll() {
1939 Call(Message::MultiEdgeClearAll);
1940 }
1941
MultiEdgeColumn(int which)1942 Position ScintillaCall::MultiEdgeColumn(int which) {
1943 return Call(Message::GetMultiEdgeColumn, which);
1944 }
1945
SearchAnchor()1946 void ScintillaCall::SearchAnchor() {
1947 Call(Message::SearchAnchor);
1948 }
1949
SearchNext(API::FindOption searchFlags,const char * text)1950 Position ScintillaCall::SearchNext(API::FindOption searchFlags, const char *text) {
1951 return CallString(Message::SearchNext, static_cast<uintptr_t>(searchFlags), text);
1952 }
1953
SearchPrev(API::FindOption searchFlags,const char * text)1954 Position ScintillaCall::SearchPrev(API::FindOption searchFlags, const char *text) {
1955 return CallString(Message::SearchPrev, static_cast<uintptr_t>(searchFlags), text);
1956 }
1957
LinesOnScreen()1958 Line ScintillaCall::LinesOnScreen() {
1959 return Call(Message::LinesOnScreen);
1960 }
1961
UsePopUp(API::PopUp popUpMode)1962 void ScintillaCall::UsePopUp(API::PopUp popUpMode) {
1963 Call(Message::UsePopUp, static_cast<uintptr_t>(popUpMode));
1964 }
1965
SelectionIsRectangle()1966 bool ScintillaCall::SelectionIsRectangle() {
1967 return Call(Message::SelectionIsRectangle);
1968 }
1969
SetZoom(int zoomInPoints)1970 void ScintillaCall::SetZoom(int zoomInPoints) {
1971 Call(Message::SetZoom, zoomInPoints);
1972 }
1973
Zoom()1974 int ScintillaCall::Zoom() {
1975 return static_cast<int>(Call(Message::GetZoom));
1976 }
1977
CreateDocument(Position bytes,API::DocumentOption documentOptions)1978 void *ScintillaCall::CreateDocument(Position bytes, API::DocumentOption documentOptions) {
1979 return reinterpret_cast<void *>(Call(Message::CreateDocument, bytes, static_cast<intptr_t>(documentOptions)));
1980 }
1981
AddRefDocument(void * doc)1982 void ScintillaCall::AddRefDocument(void *doc) {
1983 CallPointer(Message::AddRefDocument, 0, doc);
1984 }
1985
ReleaseDocument(void * doc)1986 void ScintillaCall::ReleaseDocument(void *doc) {
1987 CallPointer(Message::ReleaseDocument, 0, doc);
1988 }
1989
DocumentOptions()1990 DocumentOption ScintillaCall::DocumentOptions() {
1991 return static_cast<API::DocumentOption>(Call(Message::GetDocumentOptions));
1992 }
1993
ModEventMask()1994 ModificationFlags ScintillaCall::ModEventMask() {
1995 return static_cast<API::ModificationFlags>(Call(Message::GetModEventMask));
1996 }
1997
SetCommandEvents(bool commandEvents)1998 void ScintillaCall::SetCommandEvents(bool commandEvents) {
1999 Call(Message::SetCommandEvents, commandEvents);
2000 }
2001
CommandEvents()2002 bool ScintillaCall::CommandEvents() {
2003 return Call(Message::GetCommandEvents);
2004 }
2005
SetFocus(bool focus)2006 void ScintillaCall::SetFocus(bool focus) {
2007 Call(Message::SetFocus, focus);
2008 }
2009
Focus()2010 bool ScintillaCall::Focus() {
2011 return Call(Message::GetFocus);
2012 }
2013
SetStatus(API::Status status)2014 void ScintillaCall::SetStatus(API::Status status) {
2015 Call(Message::SetStatus, static_cast<uintptr_t>(status));
2016 }
2017
Status()2018 Status ScintillaCall::Status() {
2019 return static_cast<API::Status>(Call(Message::GetStatus));
2020 }
2021
SetMouseDownCaptures(bool captures)2022 void ScintillaCall::SetMouseDownCaptures(bool captures) {
2023 Call(Message::SetMouseDownCaptures, captures);
2024 }
2025
MouseDownCaptures()2026 bool ScintillaCall::MouseDownCaptures() {
2027 return Call(Message::GetMouseDownCaptures);
2028 }
2029
SetMouseWheelCaptures(bool captures)2030 void ScintillaCall::SetMouseWheelCaptures(bool captures) {
2031 Call(Message::SetMouseWheelCaptures, captures);
2032 }
2033
MouseWheelCaptures()2034 bool ScintillaCall::MouseWheelCaptures() {
2035 return Call(Message::GetMouseWheelCaptures);
2036 }
2037
SetCursor(API::CursorShape cursorType)2038 void ScintillaCall::SetCursor(API::CursorShape cursorType) {
2039 Call(Message::SetCursor, static_cast<uintptr_t>(cursorType));
2040 }
2041
Cursor()2042 CursorShape ScintillaCall::Cursor() {
2043 return static_cast<API::CursorShape>(Call(Message::GetCursor));
2044 }
2045
SetControlCharSymbol(int symbol)2046 void ScintillaCall::SetControlCharSymbol(int symbol) {
2047 Call(Message::SetControlCharSymbol, symbol);
2048 }
2049
ControlCharSymbol()2050 int ScintillaCall::ControlCharSymbol() {
2051 return static_cast<int>(Call(Message::GetControlCharSymbol));
2052 }
2053
WordPartLeft()2054 void ScintillaCall::WordPartLeft() {
2055 Call(Message::WordPartLeft);
2056 }
2057
WordPartLeftExtend()2058 void ScintillaCall::WordPartLeftExtend() {
2059 Call(Message::WordPartLeftExtend);
2060 }
2061
WordPartRight()2062 void ScintillaCall::WordPartRight() {
2063 Call(Message::WordPartRight);
2064 }
2065
WordPartRightExtend()2066 void ScintillaCall::WordPartRightExtend() {
2067 Call(Message::WordPartRightExtend);
2068 }
2069
SetVisiblePolicy(API::VisiblePolicy visiblePolicy,int visibleSlop)2070 void ScintillaCall::SetVisiblePolicy(API::VisiblePolicy visiblePolicy, int visibleSlop) {
2071 Call(Message::SetVisiblePolicy, static_cast<uintptr_t>(visiblePolicy), visibleSlop);
2072 }
2073
DelLineLeft()2074 void ScintillaCall::DelLineLeft() {
2075 Call(Message::DelLineLeft);
2076 }
2077
DelLineRight()2078 void ScintillaCall::DelLineRight() {
2079 Call(Message::DelLineRight);
2080 }
2081
SetXOffset(int xOffset)2082 void ScintillaCall::SetXOffset(int xOffset) {
2083 Call(Message::SetXOffset, xOffset);
2084 }
2085
XOffset()2086 int ScintillaCall::XOffset() {
2087 return static_cast<int>(Call(Message::GetXOffset));
2088 }
2089
ChooseCaretX()2090 void ScintillaCall::ChooseCaretX() {
2091 Call(Message::ChooseCaretX);
2092 }
2093
GrabFocus()2094 void ScintillaCall::GrabFocus() {
2095 Call(Message::GrabFocus);
2096 }
2097
SetXCaretPolicy(API::CaretPolicy caretPolicy,int caretSlop)2098 void ScintillaCall::SetXCaretPolicy(API::CaretPolicy caretPolicy, int caretSlop) {
2099 Call(Message::SetXCaretPolicy, static_cast<uintptr_t>(caretPolicy), caretSlop);
2100 }
2101
SetYCaretPolicy(API::CaretPolicy caretPolicy,int caretSlop)2102 void ScintillaCall::SetYCaretPolicy(API::CaretPolicy caretPolicy, int caretSlop) {
2103 Call(Message::SetYCaretPolicy, static_cast<uintptr_t>(caretPolicy), caretSlop);
2104 }
2105
SetPrintWrapMode(API::Wrap wrapMode)2106 void ScintillaCall::SetPrintWrapMode(API::Wrap wrapMode) {
2107 Call(Message::SetPrintWrapMode, static_cast<uintptr_t>(wrapMode));
2108 }
2109
PrintWrapMode()2110 Wrap ScintillaCall::PrintWrapMode() {
2111 return static_cast<API::Wrap>(Call(Message::GetPrintWrapMode));
2112 }
2113
SetHotspotActiveFore(bool useSetting,Colour fore)2114 void ScintillaCall::SetHotspotActiveFore(bool useSetting, Colour fore) {
2115 Call(Message::SetHotspotActiveFore, useSetting, fore);
2116 }
2117
HotspotActiveFore()2118 Colour ScintillaCall::HotspotActiveFore() {
2119 return static_cast<Colour>(Call(Message::GetHotspotActiveFore));
2120 }
2121
SetHotspotActiveBack(bool useSetting,Colour back)2122 void ScintillaCall::SetHotspotActiveBack(bool useSetting, Colour back) {
2123 Call(Message::SetHotspotActiveBack, useSetting, back);
2124 }
2125
HotspotActiveBack()2126 Colour ScintillaCall::HotspotActiveBack() {
2127 return static_cast<Colour>(Call(Message::GetHotspotActiveBack));
2128 }
2129
SetHotspotActiveUnderline(bool underline)2130 void ScintillaCall::SetHotspotActiveUnderline(bool underline) {
2131 Call(Message::SetHotspotActiveUnderline, underline);
2132 }
2133
HotspotActiveUnderline()2134 bool ScintillaCall::HotspotActiveUnderline() {
2135 return Call(Message::GetHotspotActiveUnderline);
2136 }
2137
SetHotspotSingleLine(bool singleLine)2138 void ScintillaCall::SetHotspotSingleLine(bool singleLine) {
2139 Call(Message::SetHotspotSingleLine, singleLine);
2140 }
2141
HotspotSingleLine()2142 bool ScintillaCall::HotspotSingleLine() {
2143 return Call(Message::GetHotspotSingleLine);
2144 }
2145
ParaDown()2146 void ScintillaCall::ParaDown() {
2147 Call(Message::ParaDown);
2148 }
2149
ParaDownExtend()2150 void ScintillaCall::ParaDownExtend() {
2151 Call(Message::ParaDownExtend);
2152 }
2153
ParaUp()2154 void ScintillaCall::ParaUp() {
2155 Call(Message::ParaUp);
2156 }
2157
ParaUpExtend()2158 void ScintillaCall::ParaUpExtend() {
2159 Call(Message::ParaUpExtend);
2160 }
2161
PositionBefore(Position pos)2162 Position ScintillaCall::PositionBefore(Position pos) {
2163 return Call(Message::PositionBefore, pos);
2164 }
2165
PositionAfter(Position pos)2166 Position ScintillaCall::PositionAfter(Position pos) {
2167 return Call(Message::PositionAfter, pos);
2168 }
2169
PositionRelative(Position pos,Position relative)2170 Position ScintillaCall::PositionRelative(Position pos, Position relative) {
2171 return Call(Message::PositionRelative, pos, relative);
2172 }
2173
PositionRelativeCodeUnits(Position pos,Position relative)2174 Position ScintillaCall::PositionRelativeCodeUnits(Position pos, Position relative) {
2175 return Call(Message::PositionRelativeCodeUnits, pos, relative);
2176 }
2177
CopyRange(Position start,Position end)2178 void ScintillaCall::CopyRange(Position start, Position end) {
2179 Call(Message::CopyRange, start, end);
2180 }
2181
CopyText(Position length,const char * text)2182 void ScintillaCall::CopyText(Position length, const char *text) {
2183 CallString(Message::CopyText, length, text);
2184 }
2185
SetSelectionMode(API::SelectionMode selectionMode)2186 void ScintillaCall::SetSelectionMode(API::SelectionMode selectionMode) {
2187 Call(Message::SetSelectionMode, static_cast<uintptr_t>(selectionMode));
2188 }
2189
SelectionMode()2190 SelectionMode ScintillaCall::SelectionMode() {
2191 return static_cast<API::SelectionMode>(Call(Message::GetSelectionMode));
2192 }
2193
MoveExtendsSelection()2194 bool ScintillaCall::MoveExtendsSelection() {
2195 return Call(Message::GetMoveExtendsSelection);
2196 }
2197
GetLineSelStartPosition(Line line)2198 Position ScintillaCall::GetLineSelStartPosition(Line line) {
2199 return Call(Message::GetLineSelStartPosition, line);
2200 }
2201
GetLineSelEndPosition(Line line)2202 Position ScintillaCall::GetLineSelEndPosition(Line line) {
2203 return Call(Message::GetLineSelEndPosition, line);
2204 }
2205
LineDownRectExtend()2206 void ScintillaCall::LineDownRectExtend() {
2207 Call(Message::LineDownRectExtend);
2208 }
2209
LineUpRectExtend()2210 void ScintillaCall::LineUpRectExtend() {
2211 Call(Message::LineUpRectExtend);
2212 }
2213
CharLeftRectExtend()2214 void ScintillaCall::CharLeftRectExtend() {
2215 Call(Message::CharLeftRectExtend);
2216 }
2217
CharRightRectExtend()2218 void ScintillaCall::CharRightRectExtend() {
2219 Call(Message::CharRightRectExtend);
2220 }
2221
HomeRectExtend()2222 void ScintillaCall::HomeRectExtend() {
2223 Call(Message::HomeRectExtend);
2224 }
2225
VCHomeRectExtend()2226 void ScintillaCall::VCHomeRectExtend() {
2227 Call(Message::VCHomeRectExtend);
2228 }
2229
LineEndRectExtend()2230 void ScintillaCall::LineEndRectExtend() {
2231 Call(Message::LineEndRectExtend);
2232 }
2233
PageUpRectExtend()2234 void ScintillaCall::PageUpRectExtend() {
2235 Call(Message::PageUpRectExtend);
2236 }
2237
PageDownRectExtend()2238 void ScintillaCall::PageDownRectExtend() {
2239 Call(Message::PageDownRectExtend);
2240 }
2241
StutteredPageUp()2242 void ScintillaCall::StutteredPageUp() {
2243 Call(Message::StutteredPageUp);
2244 }
2245
StutteredPageUpExtend()2246 void ScintillaCall::StutteredPageUpExtend() {
2247 Call(Message::StutteredPageUpExtend);
2248 }
2249
StutteredPageDown()2250 void ScintillaCall::StutteredPageDown() {
2251 Call(Message::StutteredPageDown);
2252 }
2253
StutteredPageDownExtend()2254 void ScintillaCall::StutteredPageDownExtend() {
2255 Call(Message::StutteredPageDownExtend);
2256 }
2257
WordLeftEnd()2258 void ScintillaCall::WordLeftEnd() {
2259 Call(Message::WordLeftEnd);
2260 }
2261
WordLeftEndExtend()2262 void ScintillaCall::WordLeftEndExtend() {
2263 Call(Message::WordLeftEndExtend);
2264 }
2265
WordRightEnd()2266 void ScintillaCall::WordRightEnd() {
2267 Call(Message::WordRightEnd);
2268 }
2269
WordRightEndExtend()2270 void ScintillaCall::WordRightEndExtend() {
2271 Call(Message::WordRightEndExtend);
2272 }
2273
SetWhitespaceChars(const char * characters)2274 void ScintillaCall::SetWhitespaceChars(const char *characters) {
2275 CallString(Message::SetWhitespaceChars, 0, characters);
2276 }
2277
WhitespaceChars(char * characters)2278 int ScintillaCall::WhitespaceChars(char *characters) {
2279 return static_cast<int>(CallPointer(Message::GetWhitespaceChars, 0, characters));
2280 }
2281
WhitespaceChars()2282 std::string ScintillaCall::WhitespaceChars() {
2283 return CallReturnString(Message::GetWhitespaceChars, 0);
2284 }
2285
SetPunctuationChars(const char * characters)2286 void ScintillaCall::SetPunctuationChars(const char *characters) {
2287 CallString(Message::SetPunctuationChars, 0, characters);
2288 }
2289
PunctuationChars(char * characters)2290 int ScintillaCall::PunctuationChars(char *characters) {
2291 return static_cast<int>(CallPointer(Message::GetPunctuationChars, 0, characters));
2292 }
2293
PunctuationChars()2294 std::string ScintillaCall::PunctuationChars() {
2295 return CallReturnString(Message::GetPunctuationChars, 0);
2296 }
2297
SetCharsDefault()2298 void ScintillaCall::SetCharsDefault() {
2299 Call(Message::SetCharsDefault);
2300 }
2301
AutoCGetCurrent()2302 int ScintillaCall::AutoCGetCurrent() {
2303 return static_cast<int>(Call(Message::AutoCGetCurrent));
2304 }
2305
AutoCGetCurrentText(char * text)2306 int ScintillaCall::AutoCGetCurrentText(char *text) {
2307 return static_cast<int>(CallPointer(Message::AutoCGetCurrentText, 0, text));
2308 }
2309
AutoCGetCurrentText()2310 std::string ScintillaCall::AutoCGetCurrentText() {
2311 return CallReturnString(Message::AutoCGetCurrentText, 0);
2312 }
2313
AutoCSetCaseInsensitiveBehaviour(API::CaseInsensitiveBehaviour behaviour)2314 void ScintillaCall::AutoCSetCaseInsensitiveBehaviour(API::CaseInsensitiveBehaviour behaviour) {
2315 Call(Message::AutoCSetCaseInsensitiveBehaviour, static_cast<uintptr_t>(behaviour));
2316 }
2317
AutoCGetCaseInsensitiveBehaviour()2318 CaseInsensitiveBehaviour ScintillaCall::AutoCGetCaseInsensitiveBehaviour() {
2319 return static_cast<API::CaseInsensitiveBehaviour>(Call(Message::AutoCGetCaseInsensitiveBehaviour));
2320 }
2321
AutoCSetMulti(API::MultiAutoComplete multi)2322 void ScintillaCall::AutoCSetMulti(API::MultiAutoComplete multi) {
2323 Call(Message::AutoCSetMulti, static_cast<uintptr_t>(multi));
2324 }
2325
AutoCGetMulti()2326 MultiAutoComplete ScintillaCall::AutoCGetMulti() {
2327 return static_cast<API::MultiAutoComplete>(Call(Message::AutoCGetMulti));
2328 }
2329
AutoCSetOrder(API::Ordering order)2330 void ScintillaCall::AutoCSetOrder(API::Ordering order) {
2331 Call(Message::AutoCSetOrder, static_cast<uintptr_t>(order));
2332 }
2333
AutoCGetOrder()2334 Ordering ScintillaCall::AutoCGetOrder() {
2335 return static_cast<API::Ordering>(Call(Message::AutoCGetOrder));
2336 }
2337
Allocate(Position bytes)2338 void ScintillaCall::Allocate(Position bytes) {
2339 Call(Message::Allocate, bytes);
2340 }
2341
TargetAsUTF8(char * s)2342 Position ScintillaCall::TargetAsUTF8(char *s) {
2343 return CallPointer(Message::TargetAsUTF8, 0, s);
2344 }
2345
TargetAsUTF8()2346 std::string ScintillaCall::TargetAsUTF8() {
2347 return CallReturnString(Message::TargetAsUTF8, 0);
2348 }
2349
SetLengthForEncode(Position bytes)2350 void ScintillaCall::SetLengthForEncode(Position bytes) {
2351 Call(Message::SetLengthForEncode, bytes);
2352 }
2353
EncodedFromUTF8(const char * utf8,char * encoded)2354 Position ScintillaCall::EncodedFromUTF8(const char *utf8, char *encoded) {
2355 return CallPointer(Message::EncodedFromUTF8, reinterpret_cast<uintptr_t>(utf8), encoded);
2356 }
2357
EncodedFromUTF8(const char * utf8)2358 std::string ScintillaCall::EncodedFromUTF8(const char *utf8) {
2359 return CallReturnString(Message::EncodedFromUTF8, reinterpret_cast<uintptr_t>(utf8));
2360 }
2361
FindColumn(Line line,Position column)2362 Position ScintillaCall::FindColumn(Line line, Position column) {
2363 return Call(Message::FindColumn, line, column);
2364 }
2365
CaretSticky()2366 CaretSticky ScintillaCall::CaretSticky() {
2367 return static_cast<API::CaretSticky>(Call(Message::GetCaretSticky));
2368 }
2369
SetCaretSticky(API::CaretSticky useCaretStickyBehaviour)2370 void ScintillaCall::SetCaretSticky(API::CaretSticky useCaretStickyBehaviour) {
2371 Call(Message::SetCaretSticky, static_cast<uintptr_t>(useCaretStickyBehaviour));
2372 }
2373
ToggleCaretSticky()2374 void ScintillaCall::ToggleCaretSticky() {
2375 Call(Message::ToggleCaretSticky);
2376 }
2377
SetPasteConvertEndings(bool convert)2378 void ScintillaCall::SetPasteConvertEndings(bool convert) {
2379 Call(Message::SetPasteConvertEndings, convert);
2380 }
2381
PasteConvertEndings()2382 bool ScintillaCall::PasteConvertEndings() {
2383 return Call(Message::GetPasteConvertEndings);
2384 }
2385
SelectionDuplicate()2386 void ScintillaCall::SelectionDuplicate() {
2387 Call(Message::SelectionDuplicate);
2388 }
2389
SetCaretLineBackAlpha(API::Alpha alpha)2390 void ScintillaCall::SetCaretLineBackAlpha(API::Alpha alpha) {
2391 Call(Message::SetCaretLineBackAlpha, static_cast<uintptr_t>(alpha));
2392 }
2393
CaretLineBackAlpha()2394 Alpha ScintillaCall::CaretLineBackAlpha() {
2395 return static_cast<API::Alpha>(Call(Message::GetCaretLineBackAlpha));
2396 }
2397
SetCaretStyle(API::CaretStyle caretStyle)2398 void ScintillaCall::SetCaretStyle(API::CaretStyle caretStyle) {
2399 Call(Message::SetCaretStyle, static_cast<uintptr_t>(caretStyle));
2400 }
2401
CaretStyle()2402 CaretStyle ScintillaCall::CaretStyle() {
2403 return static_cast<API::CaretStyle>(Call(Message::GetCaretStyle));
2404 }
2405
SetIndicatorCurrent(int indicator)2406 void ScintillaCall::SetIndicatorCurrent(int indicator) {
2407 Call(Message::SetIndicatorCurrent, indicator);
2408 }
2409
IndicatorCurrent()2410 int ScintillaCall::IndicatorCurrent() {
2411 return static_cast<int>(Call(Message::GetIndicatorCurrent));
2412 }
2413
SetIndicatorValue(int value)2414 void ScintillaCall::SetIndicatorValue(int value) {
2415 Call(Message::SetIndicatorValue, value);
2416 }
2417
IndicatorValue()2418 int ScintillaCall::IndicatorValue() {
2419 return static_cast<int>(Call(Message::GetIndicatorValue));
2420 }
2421
IndicatorFillRange(Position start,Position lengthFill)2422 void ScintillaCall::IndicatorFillRange(Position start, Position lengthFill) {
2423 Call(Message::IndicatorFillRange, start, lengthFill);
2424 }
2425
IndicatorClearRange(Position start,Position lengthClear)2426 void ScintillaCall::IndicatorClearRange(Position start, Position lengthClear) {
2427 Call(Message::IndicatorClearRange, start, lengthClear);
2428 }
2429
IndicatorAllOnFor(Position pos)2430 int ScintillaCall::IndicatorAllOnFor(Position pos) {
2431 return static_cast<int>(Call(Message::IndicatorAllOnFor, pos));
2432 }
2433
IndicatorValueAt(int indicator,Position pos)2434 int ScintillaCall::IndicatorValueAt(int indicator, Position pos) {
2435 return static_cast<int>(Call(Message::IndicatorValueAt, indicator, pos));
2436 }
2437
IndicatorStart(int indicator,Position pos)2438 Position ScintillaCall::IndicatorStart(int indicator, Position pos) {
2439 return Call(Message::IndicatorStart, indicator, pos);
2440 }
2441
IndicatorEnd(int indicator,Position pos)2442 Position ScintillaCall::IndicatorEnd(int indicator, Position pos) {
2443 return Call(Message::IndicatorEnd, indicator, pos);
2444 }
2445
SetPositionCache(int size)2446 void ScintillaCall::SetPositionCache(int size) {
2447 Call(Message::SetPositionCache, size);
2448 }
2449
PositionCache()2450 int ScintillaCall::PositionCache() {
2451 return static_cast<int>(Call(Message::GetPositionCache));
2452 }
2453
CopyAllowLine()2454 void ScintillaCall::CopyAllowLine() {
2455 Call(Message::CopyAllowLine);
2456 }
2457
CharacterPointer()2458 void *ScintillaCall::CharacterPointer() {
2459 return reinterpret_cast<void *>(Call(Message::GetCharacterPointer));
2460 }
2461
RangePointer(Position start,Position lengthRange)2462 void *ScintillaCall::RangePointer(Position start, Position lengthRange) {
2463 return reinterpret_cast<void *>(Call(Message::GetRangePointer, start, lengthRange));
2464 }
2465
GapPosition()2466 Position ScintillaCall::GapPosition() {
2467 return Call(Message::GetGapPosition);
2468 }
2469
IndicSetAlpha(int indicator,API::Alpha alpha)2470 void ScintillaCall::IndicSetAlpha(int indicator, API::Alpha alpha) {
2471 Call(Message::IndicSetAlpha, indicator, static_cast<intptr_t>(alpha));
2472 }
2473
IndicGetAlpha(int indicator)2474 Alpha ScintillaCall::IndicGetAlpha(int indicator) {
2475 return static_cast<API::Alpha>(Call(Message::IndicGetAlpha, indicator));
2476 }
2477
IndicSetOutlineAlpha(int indicator,API::Alpha alpha)2478 void ScintillaCall::IndicSetOutlineAlpha(int indicator, API::Alpha alpha) {
2479 Call(Message::IndicSetOutlineAlpha, indicator, static_cast<intptr_t>(alpha));
2480 }
2481
IndicGetOutlineAlpha(int indicator)2482 Alpha ScintillaCall::IndicGetOutlineAlpha(int indicator) {
2483 return static_cast<API::Alpha>(Call(Message::IndicGetOutlineAlpha, indicator));
2484 }
2485
SetExtraAscent(int extraAscent)2486 void ScintillaCall::SetExtraAscent(int extraAscent) {
2487 Call(Message::SetExtraAscent, extraAscent);
2488 }
2489
ExtraAscent()2490 int ScintillaCall::ExtraAscent() {
2491 return static_cast<int>(Call(Message::GetExtraAscent));
2492 }
2493
SetExtraDescent(int extraDescent)2494 void ScintillaCall::SetExtraDescent(int extraDescent) {
2495 Call(Message::SetExtraDescent, extraDescent);
2496 }
2497
ExtraDescent()2498 int ScintillaCall::ExtraDescent() {
2499 return static_cast<int>(Call(Message::GetExtraDescent));
2500 }
2501
MarkerSymbolDefined(int markerNumber)2502 int ScintillaCall::MarkerSymbolDefined(int markerNumber) {
2503 return static_cast<int>(Call(Message::MarkerSymbolDefined, markerNumber));
2504 }
2505
MarginSetText(Line line,const char * text)2506 void ScintillaCall::MarginSetText(Line line, const char *text) {
2507 CallString(Message::MarginSetText, line, text);
2508 }
2509
MarginGetText(Line line,char * text)2510 int ScintillaCall::MarginGetText(Line line, char *text) {
2511 return static_cast<int>(CallPointer(Message::MarginGetText, line, text));
2512 }
2513
MarginGetText(Line line)2514 std::string ScintillaCall::MarginGetText(Line line) {
2515 return CallReturnString(Message::MarginGetText, line);
2516 }
2517
MarginSetStyle(Line line,int style)2518 void ScintillaCall::MarginSetStyle(Line line, int style) {
2519 Call(Message::MarginSetStyle, line, style);
2520 }
2521
MarginGetStyle(Line line)2522 int ScintillaCall::MarginGetStyle(Line line) {
2523 return static_cast<int>(Call(Message::MarginGetStyle, line));
2524 }
2525
MarginSetStyles(Line line,const char * styles)2526 void ScintillaCall::MarginSetStyles(Line line, const char *styles) {
2527 CallString(Message::MarginSetStyles, line, styles);
2528 }
2529
MarginGetStyles(Line line,char * styles)2530 int ScintillaCall::MarginGetStyles(Line line, char *styles) {
2531 return static_cast<int>(CallPointer(Message::MarginGetStyles, line, styles));
2532 }
2533
MarginGetStyles(Line line)2534 std::string ScintillaCall::MarginGetStyles(Line line) {
2535 return CallReturnString(Message::MarginGetStyles, line);
2536 }
2537
MarginTextClearAll()2538 void ScintillaCall::MarginTextClearAll() {
2539 Call(Message::MarginTextClearAll);
2540 }
2541
MarginSetStyleOffset(int style)2542 void ScintillaCall::MarginSetStyleOffset(int style) {
2543 Call(Message::MarginSetStyleOffset, style);
2544 }
2545
MarginGetStyleOffset()2546 int ScintillaCall::MarginGetStyleOffset() {
2547 return static_cast<int>(Call(Message::MarginGetStyleOffset));
2548 }
2549
SetMarginOptions(API::MarginOption marginOptions)2550 void ScintillaCall::SetMarginOptions(API::MarginOption marginOptions) {
2551 Call(Message::SetMarginOptions, static_cast<uintptr_t>(marginOptions));
2552 }
2553
MarginOptions()2554 MarginOption ScintillaCall::MarginOptions() {
2555 return static_cast<API::MarginOption>(Call(Message::GetMarginOptions));
2556 }
2557
AnnotationSetText(Line line,const char * text)2558 void ScintillaCall::AnnotationSetText(Line line, const char *text) {
2559 CallString(Message::AnnotationSetText, line, text);
2560 }
2561
AnnotationGetText(Line line,char * text)2562 int ScintillaCall::AnnotationGetText(Line line, char *text) {
2563 return static_cast<int>(CallPointer(Message::AnnotationGetText, line, text));
2564 }
2565
AnnotationGetText(Line line)2566 std::string ScintillaCall::AnnotationGetText(Line line) {
2567 return CallReturnString(Message::AnnotationGetText, line);
2568 }
2569
AnnotationSetStyle(Line line,int style)2570 void ScintillaCall::AnnotationSetStyle(Line line, int style) {
2571 Call(Message::AnnotationSetStyle, line, style);
2572 }
2573
AnnotationGetStyle(Line line)2574 int ScintillaCall::AnnotationGetStyle(Line line) {
2575 return static_cast<int>(Call(Message::AnnotationGetStyle, line));
2576 }
2577
AnnotationSetStyles(Line line,const char * styles)2578 void ScintillaCall::AnnotationSetStyles(Line line, const char *styles) {
2579 CallString(Message::AnnotationSetStyles, line, styles);
2580 }
2581
AnnotationGetStyles(Line line,char * styles)2582 int ScintillaCall::AnnotationGetStyles(Line line, char *styles) {
2583 return static_cast<int>(CallPointer(Message::AnnotationGetStyles, line, styles));
2584 }
2585
AnnotationGetStyles(Line line)2586 std::string ScintillaCall::AnnotationGetStyles(Line line) {
2587 return CallReturnString(Message::AnnotationGetStyles, line);
2588 }
2589
AnnotationGetLines(Line line)2590 int ScintillaCall::AnnotationGetLines(Line line) {
2591 return static_cast<int>(Call(Message::AnnotationGetLines, line));
2592 }
2593
AnnotationClearAll()2594 void ScintillaCall::AnnotationClearAll() {
2595 Call(Message::AnnotationClearAll);
2596 }
2597
AnnotationSetVisible(API::AnnotationVisible visible)2598 void ScintillaCall::AnnotationSetVisible(API::AnnotationVisible visible) {
2599 Call(Message::AnnotationSetVisible, static_cast<uintptr_t>(visible));
2600 }
2601
AnnotationGetVisible()2602 AnnotationVisible ScintillaCall::AnnotationGetVisible() {
2603 return static_cast<API::AnnotationVisible>(Call(Message::AnnotationGetVisible));
2604 }
2605
AnnotationSetStyleOffset(int style)2606 void ScintillaCall::AnnotationSetStyleOffset(int style) {
2607 Call(Message::AnnotationSetStyleOffset, style);
2608 }
2609
AnnotationGetStyleOffset()2610 int ScintillaCall::AnnotationGetStyleOffset() {
2611 return static_cast<int>(Call(Message::AnnotationGetStyleOffset));
2612 }
2613
ReleaseAllExtendedStyles()2614 void ScintillaCall::ReleaseAllExtendedStyles() {
2615 Call(Message::ReleaseAllExtendedStyles);
2616 }
2617
AllocateExtendedStyles(int numberStyles)2618 int ScintillaCall::AllocateExtendedStyles(int numberStyles) {
2619 return static_cast<int>(Call(Message::AllocateExtendedStyles, numberStyles));
2620 }
2621
AddUndoAction(int token,API::UndoFlags flags)2622 void ScintillaCall::AddUndoAction(int token, API::UndoFlags flags) {
2623 Call(Message::AddUndoAction, token, static_cast<intptr_t>(flags));
2624 }
2625
CharPositionFromPoint(int x,int y)2626 Position ScintillaCall::CharPositionFromPoint(int x, int y) {
2627 return Call(Message::CharPositionFromPoint, x, y);
2628 }
2629
CharPositionFromPointClose(int x,int y)2630 Position ScintillaCall::CharPositionFromPointClose(int x, int y) {
2631 return Call(Message::CharPositionFromPointClose, x, y);
2632 }
2633
SetMouseSelectionRectangularSwitch(bool mouseSelectionRectangularSwitch)2634 void ScintillaCall::SetMouseSelectionRectangularSwitch(bool mouseSelectionRectangularSwitch) {
2635 Call(Message::SetMouseSelectionRectangularSwitch, mouseSelectionRectangularSwitch);
2636 }
2637
MouseSelectionRectangularSwitch()2638 bool ScintillaCall::MouseSelectionRectangularSwitch() {
2639 return Call(Message::GetMouseSelectionRectangularSwitch);
2640 }
2641
SetMultipleSelection(bool multipleSelection)2642 void ScintillaCall::SetMultipleSelection(bool multipleSelection) {
2643 Call(Message::SetMultipleSelection, multipleSelection);
2644 }
2645
MultipleSelection()2646 bool ScintillaCall::MultipleSelection() {
2647 return Call(Message::GetMultipleSelection);
2648 }
2649
SetAdditionalSelectionTyping(bool additionalSelectionTyping)2650 void ScintillaCall::SetAdditionalSelectionTyping(bool additionalSelectionTyping) {
2651 Call(Message::SetAdditionalSelectionTyping, additionalSelectionTyping);
2652 }
2653
AdditionalSelectionTyping()2654 bool ScintillaCall::AdditionalSelectionTyping() {
2655 return Call(Message::GetAdditionalSelectionTyping);
2656 }
2657
SetAdditionalCaretsBlink(bool additionalCaretsBlink)2658 void ScintillaCall::SetAdditionalCaretsBlink(bool additionalCaretsBlink) {
2659 Call(Message::SetAdditionalCaretsBlink, additionalCaretsBlink);
2660 }
2661
AdditionalCaretsBlink()2662 bool ScintillaCall::AdditionalCaretsBlink() {
2663 return Call(Message::GetAdditionalCaretsBlink);
2664 }
2665
SetAdditionalCaretsVisible(bool additionalCaretsVisible)2666 void ScintillaCall::SetAdditionalCaretsVisible(bool additionalCaretsVisible) {
2667 Call(Message::SetAdditionalCaretsVisible, additionalCaretsVisible);
2668 }
2669
AdditionalCaretsVisible()2670 bool ScintillaCall::AdditionalCaretsVisible() {
2671 return Call(Message::GetAdditionalCaretsVisible);
2672 }
2673
Selections()2674 int ScintillaCall::Selections() {
2675 return static_cast<int>(Call(Message::GetSelections));
2676 }
2677
SelectionEmpty()2678 bool ScintillaCall::SelectionEmpty() {
2679 return Call(Message::GetSelectionEmpty);
2680 }
2681
ClearSelections()2682 void ScintillaCall::ClearSelections() {
2683 Call(Message::ClearSelections);
2684 }
2685
SetSelection(Position caret,Position anchor)2686 void ScintillaCall::SetSelection(Position caret, Position anchor) {
2687 Call(Message::SetSelection, caret, anchor);
2688 }
2689
AddSelection(Position caret,Position anchor)2690 void ScintillaCall::AddSelection(Position caret, Position anchor) {
2691 Call(Message::AddSelection, caret, anchor);
2692 }
2693
DropSelectionN(int selection)2694 void ScintillaCall::DropSelectionN(int selection) {
2695 Call(Message::DropSelectionN, selection);
2696 }
2697
SetMainSelection(int selection)2698 void ScintillaCall::SetMainSelection(int selection) {
2699 Call(Message::SetMainSelection, selection);
2700 }
2701
MainSelection()2702 int ScintillaCall::MainSelection() {
2703 return static_cast<int>(Call(Message::GetMainSelection));
2704 }
2705
SetSelectionNCaret(int selection,Position caret)2706 void ScintillaCall::SetSelectionNCaret(int selection, Position caret) {
2707 Call(Message::SetSelectionNCaret, selection, caret);
2708 }
2709
SelectionNCaret(int selection)2710 Position ScintillaCall::SelectionNCaret(int selection) {
2711 return Call(Message::GetSelectionNCaret, selection);
2712 }
2713
SetSelectionNAnchor(int selection,Position anchor)2714 void ScintillaCall::SetSelectionNAnchor(int selection, Position anchor) {
2715 Call(Message::SetSelectionNAnchor, selection, anchor);
2716 }
2717
SelectionNAnchor(int selection)2718 Position ScintillaCall::SelectionNAnchor(int selection) {
2719 return Call(Message::GetSelectionNAnchor, selection);
2720 }
2721
SetSelectionNCaretVirtualSpace(int selection,Position space)2722 void ScintillaCall::SetSelectionNCaretVirtualSpace(int selection, Position space) {
2723 Call(Message::SetSelectionNCaretVirtualSpace, selection, space);
2724 }
2725
SelectionNCaretVirtualSpace(int selection)2726 Position ScintillaCall::SelectionNCaretVirtualSpace(int selection) {
2727 return Call(Message::GetSelectionNCaretVirtualSpace, selection);
2728 }
2729
SetSelectionNAnchorVirtualSpace(int selection,Position space)2730 void ScintillaCall::SetSelectionNAnchorVirtualSpace(int selection, Position space) {
2731 Call(Message::SetSelectionNAnchorVirtualSpace, selection, space);
2732 }
2733
SelectionNAnchorVirtualSpace(int selection)2734 Position ScintillaCall::SelectionNAnchorVirtualSpace(int selection) {
2735 return Call(Message::GetSelectionNAnchorVirtualSpace, selection);
2736 }
2737
SetSelectionNStart(int selection,Position anchor)2738 void ScintillaCall::SetSelectionNStart(int selection, Position anchor) {
2739 Call(Message::SetSelectionNStart, selection, anchor);
2740 }
2741
SelectionNStart(int selection)2742 Position ScintillaCall::SelectionNStart(int selection) {
2743 return Call(Message::GetSelectionNStart, selection);
2744 }
2745
SelectionNStartVirtualSpace(int selection)2746 Position ScintillaCall::SelectionNStartVirtualSpace(int selection) {
2747 return Call(Message::GetSelectionNStartVirtualSpace, selection);
2748 }
2749
SetSelectionNEnd(int selection,Position caret)2750 void ScintillaCall::SetSelectionNEnd(int selection, Position caret) {
2751 Call(Message::SetSelectionNEnd, selection, caret);
2752 }
2753
SelectionNEndVirtualSpace(int selection)2754 Position ScintillaCall::SelectionNEndVirtualSpace(int selection) {
2755 return Call(Message::GetSelectionNEndVirtualSpace, selection);
2756 }
2757
SelectionNEnd(int selection)2758 Position ScintillaCall::SelectionNEnd(int selection) {
2759 return Call(Message::GetSelectionNEnd, selection);
2760 }
2761
SetRectangularSelectionCaret(Position caret)2762 void ScintillaCall::SetRectangularSelectionCaret(Position caret) {
2763 Call(Message::SetRectangularSelectionCaret, caret);
2764 }
2765
RectangularSelectionCaret()2766 Position ScintillaCall::RectangularSelectionCaret() {
2767 return Call(Message::GetRectangularSelectionCaret);
2768 }
2769
SetRectangularSelectionAnchor(Position anchor)2770 void ScintillaCall::SetRectangularSelectionAnchor(Position anchor) {
2771 Call(Message::SetRectangularSelectionAnchor, anchor);
2772 }
2773
RectangularSelectionAnchor()2774 Position ScintillaCall::RectangularSelectionAnchor() {
2775 return Call(Message::GetRectangularSelectionAnchor);
2776 }
2777
SetRectangularSelectionCaretVirtualSpace(Position space)2778 void ScintillaCall::SetRectangularSelectionCaretVirtualSpace(Position space) {
2779 Call(Message::SetRectangularSelectionCaretVirtualSpace, space);
2780 }
2781
RectangularSelectionCaretVirtualSpace()2782 Position ScintillaCall::RectangularSelectionCaretVirtualSpace() {
2783 return Call(Message::GetRectangularSelectionCaretVirtualSpace);
2784 }
2785
SetRectangularSelectionAnchorVirtualSpace(Position space)2786 void ScintillaCall::SetRectangularSelectionAnchorVirtualSpace(Position space) {
2787 Call(Message::SetRectangularSelectionAnchorVirtualSpace, space);
2788 }
2789
RectangularSelectionAnchorVirtualSpace()2790 Position ScintillaCall::RectangularSelectionAnchorVirtualSpace() {
2791 return Call(Message::GetRectangularSelectionAnchorVirtualSpace);
2792 }
2793
SetVirtualSpaceOptions(API::VirtualSpace virtualSpaceOptions)2794 void ScintillaCall::SetVirtualSpaceOptions(API::VirtualSpace virtualSpaceOptions) {
2795 Call(Message::SetVirtualSpaceOptions, static_cast<uintptr_t>(virtualSpaceOptions));
2796 }
2797
VirtualSpaceOptions()2798 VirtualSpace ScintillaCall::VirtualSpaceOptions() {
2799 return static_cast<API::VirtualSpace>(Call(Message::GetVirtualSpaceOptions));
2800 }
2801
SetRectangularSelectionModifier(int modifier)2802 void ScintillaCall::SetRectangularSelectionModifier(int modifier) {
2803 Call(Message::SetRectangularSelectionModifier, modifier);
2804 }
2805
RectangularSelectionModifier()2806 int ScintillaCall::RectangularSelectionModifier() {
2807 return static_cast<int>(Call(Message::GetRectangularSelectionModifier));
2808 }
2809
SetAdditionalSelFore(Colour fore)2810 void ScintillaCall::SetAdditionalSelFore(Colour fore) {
2811 Call(Message::SetAdditionalSelFore, fore);
2812 }
2813
SetAdditionalSelBack(Colour back)2814 void ScintillaCall::SetAdditionalSelBack(Colour back) {
2815 Call(Message::SetAdditionalSelBack, back);
2816 }
2817
SetAdditionalSelAlpha(API::Alpha alpha)2818 void ScintillaCall::SetAdditionalSelAlpha(API::Alpha alpha) {
2819 Call(Message::SetAdditionalSelAlpha, static_cast<uintptr_t>(alpha));
2820 }
2821
AdditionalSelAlpha()2822 Alpha ScintillaCall::AdditionalSelAlpha() {
2823 return static_cast<API::Alpha>(Call(Message::GetAdditionalSelAlpha));
2824 }
2825
SetAdditionalCaretFore(Colour fore)2826 void ScintillaCall::SetAdditionalCaretFore(Colour fore) {
2827 Call(Message::SetAdditionalCaretFore, fore);
2828 }
2829
AdditionalCaretFore()2830 Colour ScintillaCall::AdditionalCaretFore() {
2831 return static_cast<Colour>(Call(Message::GetAdditionalCaretFore));
2832 }
2833
RotateSelection()2834 void ScintillaCall::RotateSelection() {
2835 Call(Message::RotateSelection);
2836 }
2837
SwapMainAnchorCaret()2838 void ScintillaCall::SwapMainAnchorCaret() {
2839 Call(Message::SwapMainAnchorCaret);
2840 }
2841
MultipleSelectAddNext()2842 void ScintillaCall::MultipleSelectAddNext() {
2843 Call(Message::MultipleSelectAddNext);
2844 }
2845
MultipleSelectAddEach()2846 void ScintillaCall::MultipleSelectAddEach() {
2847 Call(Message::MultipleSelectAddEach);
2848 }
2849
ChangeLexerState(Position start,Position end)2850 int ScintillaCall::ChangeLexerState(Position start, Position end) {
2851 return static_cast<int>(Call(Message::ChangeLexerState, start, end));
2852 }
2853
ContractedFoldNext(Line lineStart)2854 Line ScintillaCall::ContractedFoldNext(Line lineStart) {
2855 return Call(Message::ContractedFoldNext, lineStart);
2856 }
2857
VerticalCentreCaret()2858 void ScintillaCall::VerticalCentreCaret() {
2859 Call(Message::VerticalCentreCaret);
2860 }
2861
MoveSelectedLinesUp()2862 void ScintillaCall::MoveSelectedLinesUp() {
2863 Call(Message::MoveSelectedLinesUp);
2864 }
2865
MoveSelectedLinesDown()2866 void ScintillaCall::MoveSelectedLinesDown() {
2867 Call(Message::MoveSelectedLinesDown);
2868 }
2869
SetIdentifier(int identifier)2870 void ScintillaCall::SetIdentifier(int identifier) {
2871 Call(Message::SetIdentifier, identifier);
2872 }
2873
Identifier()2874 int ScintillaCall::Identifier() {
2875 return static_cast<int>(Call(Message::GetIdentifier));
2876 }
2877
RGBAImageSetWidth(int width)2878 void ScintillaCall::RGBAImageSetWidth(int width) {
2879 Call(Message::RGBAImageSetWidth, width);
2880 }
2881
RGBAImageSetHeight(int height)2882 void ScintillaCall::RGBAImageSetHeight(int height) {
2883 Call(Message::RGBAImageSetHeight, height);
2884 }
2885
RGBAImageSetScale(int scalePercent)2886 void ScintillaCall::RGBAImageSetScale(int scalePercent) {
2887 Call(Message::RGBAImageSetScale, scalePercent);
2888 }
2889
MarkerDefineRGBAImage(int markerNumber,const char * pixels)2890 void ScintillaCall::MarkerDefineRGBAImage(int markerNumber, const char *pixels) {
2891 CallString(Message::MarkerDefineRGBAImage, markerNumber, pixels);
2892 }
2893
RegisterRGBAImage(int type,const char * pixels)2894 void ScintillaCall::RegisterRGBAImage(int type, const char *pixels) {
2895 CallString(Message::RegisterRGBAImage, type, pixels);
2896 }
2897
ScrollToStart()2898 void ScintillaCall::ScrollToStart() {
2899 Call(Message::ScrollToStart);
2900 }
2901
ScrollToEnd()2902 void ScintillaCall::ScrollToEnd() {
2903 Call(Message::ScrollToEnd);
2904 }
2905
SetTechnology(API::Technology technology)2906 void ScintillaCall::SetTechnology(API::Technology technology) {
2907 Call(Message::SetTechnology, static_cast<uintptr_t>(technology));
2908 }
2909
Technology()2910 Technology ScintillaCall::Technology() {
2911 return static_cast<API::Technology>(Call(Message::GetTechnology));
2912 }
2913
CreateLoader(Position bytes,API::DocumentOption documentOptions)2914 void *ScintillaCall::CreateLoader(Position bytes, API::DocumentOption documentOptions) {
2915 return reinterpret_cast<void *>(Call(Message::CreateLoader, bytes, static_cast<intptr_t>(documentOptions)));
2916 }
2917
FindIndicatorShow(Position start,Position end)2918 void ScintillaCall::FindIndicatorShow(Position start, Position end) {
2919 Call(Message::FindIndicatorShow, start, end);
2920 }
2921
FindIndicatorFlash(Position start,Position end)2922 void ScintillaCall::FindIndicatorFlash(Position start, Position end) {
2923 Call(Message::FindIndicatorFlash, start, end);
2924 }
2925
FindIndicatorHide()2926 void ScintillaCall::FindIndicatorHide() {
2927 Call(Message::FindIndicatorHide);
2928 }
2929
VCHomeDisplay()2930 void ScintillaCall::VCHomeDisplay() {
2931 Call(Message::VCHomeDisplay);
2932 }
2933
VCHomeDisplayExtend()2934 void ScintillaCall::VCHomeDisplayExtend() {
2935 Call(Message::VCHomeDisplayExtend);
2936 }
2937
CaretLineVisibleAlways()2938 bool ScintillaCall::CaretLineVisibleAlways() {
2939 return Call(Message::GetCaretLineVisibleAlways);
2940 }
2941
SetCaretLineVisibleAlways(bool alwaysVisible)2942 void ScintillaCall::SetCaretLineVisibleAlways(bool alwaysVisible) {
2943 Call(Message::SetCaretLineVisibleAlways, alwaysVisible);
2944 }
2945
SetLineEndTypesAllowed(API::LineEndType lineEndBitSet)2946 void ScintillaCall::SetLineEndTypesAllowed(API::LineEndType lineEndBitSet) {
2947 Call(Message::SetLineEndTypesAllowed, static_cast<uintptr_t>(lineEndBitSet));
2948 }
2949
LineEndTypesAllowed()2950 LineEndType ScintillaCall::LineEndTypesAllowed() {
2951 return static_cast<API::LineEndType>(Call(Message::GetLineEndTypesAllowed));
2952 }
2953
LineEndTypesActive()2954 LineEndType ScintillaCall::LineEndTypesActive() {
2955 return static_cast<API::LineEndType>(Call(Message::GetLineEndTypesActive));
2956 }
2957
SetRepresentation(const char * encodedCharacter,const char * representation)2958 void ScintillaCall::SetRepresentation(const char *encodedCharacter, const char *representation) {
2959 CallString(Message::SetRepresentation, reinterpret_cast<uintptr_t>(encodedCharacter), representation);
2960 }
2961
Representation(const char * encodedCharacter,char * representation)2962 int ScintillaCall::Representation(const char *encodedCharacter, char *representation) {
2963 return static_cast<int>(CallPointer(Message::GetRepresentation, reinterpret_cast<uintptr_t>(encodedCharacter), representation));
2964 }
2965
Representation(const char * encodedCharacter)2966 std::string ScintillaCall::Representation(const char *encodedCharacter) {
2967 return CallReturnString(Message::GetRepresentation, reinterpret_cast<uintptr_t>(encodedCharacter));
2968 }
2969
ClearRepresentation(const char * encodedCharacter)2970 void ScintillaCall::ClearRepresentation(const char *encodedCharacter) {
2971 Call(Message::ClearRepresentation, reinterpret_cast<uintptr_t>(encodedCharacter));
2972 }
2973
EOLAnnotationSetText(Line line,const char * text)2974 void ScintillaCall::EOLAnnotationSetText(Line line, const char *text) {
2975 CallString(Message::EOLAnnotationSetText, line, text);
2976 }
2977
EOLAnnotationGetText(Line line,char * text)2978 int ScintillaCall::EOLAnnotationGetText(Line line, char *text) {
2979 return static_cast<int>(CallPointer(Message::EOLAnnotationGetText, line, text));
2980 }
2981
EOLAnnotationGetText(Line line)2982 std::string ScintillaCall::EOLAnnotationGetText(Line line) {
2983 return CallReturnString(Message::EOLAnnotationGetText, line);
2984 }
2985
EOLAnnotationSetStyle(Line line,int style)2986 void ScintillaCall::EOLAnnotationSetStyle(Line line, int style) {
2987 Call(Message::EOLAnnotationSetStyle, line, style);
2988 }
2989
EOLAnnotationGetStyle(Line line)2990 int ScintillaCall::EOLAnnotationGetStyle(Line line) {
2991 return static_cast<int>(Call(Message::EOLAnnotationGetStyle, line));
2992 }
2993
EOLAnnotationClearAll()2994 void ScintillaCall::EOLAnnotationClearAll() {
2995 Call(Message::EOLAnnotationClearAll);
2996 }
2997
EOLAnnotationSetVisible(API::EOLAnnotationVisible visible)2998 void ScintillaCall::EOLAnnotationSetVisible(API::EOLAnnotationVisible visible) {
2999 Call(Message::EOLAnnotationSetVisible, static_cast<uintptr_t>(visible));
3000 }
3001
EOLAnnotationGetVisible()3002 EOLAnnotationVisible ScintillaCall::EOLAnnotationGetVisible() {
3003 return static_cast<API::EOLAnnotationVisible>(Call(Message::EOLAnnotationGetVisible));
3004 }
3005
EOLAnnotationSetStyleOffset(int style)3006 void ScintillaCall::EOLAnnotationSetStyleOffset(int style) {
3007 Call(Message::EOLAnnotationSetStyleOffset, style);
3008 }
3009
EOLAnnotationGetStyleOffset()3010 int ScintillaCall::EOLAnnotationGetStyleOffset() {
3011 return static_cast<int>(Call(Message::EOLAnnotationGetStyleOffset));
3012 }
3013
StartRecord()3014 void ScintillaCall::StartRecord() {
3015 Call(Message::StartRecord);
3016 }
3017
StopRecord()3018 void ScintillaCall::StopRecord() {
3019 Call(Message::StopRecord);
3020 }
3021
SetLexer(int lexer)3022 void ScintillaCall::SetLexer(int lexer) {
3023 Call(Message::SetLexer, lexer);
3024 }
3025
Lexer()3026 int ScintillaCall::Lexer() {
3027 return static_cast<int>(Call(Message::GetLexer));
3028 }
3029
Colourise(Position start,Position end)3030 void ScintillaCall::Colourise(Position start, Position end) {
3031 Call(Message::Colourise, start, end);
3032 }
3033
SetProperty(const char * key,const char * value)3034 void ScintillaCall::SetProperty(const char *key, const char *value) {
3035 CallString(Message::SetProperty, reinterpret_cast<uintptr_t>(key), value);
3036 }
3037
SetKeyWords(int keyWordSet,const char * keyWords)3038 void ScintillaCall::SetKeyWords(int keyWordSet, const char *keyWords) {
3039 CallString(Message::SetKeyWords, keyWordSet, keyWords);
3040 }
3041
SetLexerLanguage(const char * language)3042 void ScintillaCall::SetLexerLanguage(const char *language) {
3043 CallString(Message::SetLexerLanguage, 0, language);
3044 }
3045
LoadLexerLibrary(const char * path)3046 void ScintillaCall::LoadLexerLibrary(const char *path) {
3047 CallString(Message::LoadLexerLibrary, 0, path);
3048 }
3049
Property(const char * key,char * value)3050 int ScintillaCall::Property(const char *key, char *value) {
3051 return static_cast<int>(CallPointer(Message::GetProperty, reinterpret_cast<uintptr_t>(key), value));
3052 }
3053
Property(const char * key)3054 std::string ScintillaCall::Property(const char *key) {
3055 return CallReturnString(Message::GetProperty, reinterpret_cast<uintptr_t>(key));
3056 }
3057
PropertyExpanded(const char * key,char * value)3058 int ScintillaCall::PropertyExpanded(const char *key, char *value) {
3059 return static_cast<int>(CallPointer(Message::GetPropertyExpanded, reinterpret_cast<uintptr_t>(key), value));
3060 }
3061
PropertyExpanded(const char * key)3062 std::string ScintillaCall::PropertyExpanded(const char *key) {
3063 return CallReturnString(Message::GetPropertyExpanded, reinterpret_cast<uintptr_t>(key));
3064 }
3065
PropertyInt(const char * key,int defaultValue)3066 int ScintillaCall::PropertyInt(const char *key, int defaultValue) {
3067 return static_cast<int>(Call(Message::GetPropertyInt, reinterpret_cast<uintptr_t>(key), defaultValue));
3068 }
3069
LexerLanguage(char * language)3070 int ScintillaCall::LexerLanguage(char *language) {
3071 return static_cast<int>(CallPointer(Message::GetLexerLanguage, 0, language));
3072 }
3073
LexerLanguage()3074 std::string ScintillaCall::LexerLanguage() {
3075 return CallReturnString(Message::GetLexerLanguage, 0);
3076 }
3077
PrivateLexerCall(int operation,void * pointer)3078 void *ScintillaCall::PrivateLexerCall(int operation, void *pointer) {
3079 return reinterpret_cast<void *>(CallPointer(Message::PrivateLexerCall, operation, pointer));
3080 }
3081
PropertyNames(char * names)3082 int ScintillaCall::PropertyNames(char *names) {
3083 return static_cast<int>(CallPointer(Message::PropertyNames, 0, names));
3084 }
3085
PropertyNames()3086 std::string ScintillaCall::PropertyNames() {
3087 return CallReturnString(Message::PropertyNames, 0);
3088 }
3089
PropertyType(const char * name)3090 TypeProperty ScintillaCall::PropertyType(const char *name) {
3091 return static_cast<API::TypeProperty>(Call(Message::PropertyType, reinterpret_cast<uintptr_t>(name)));
3092 }
3093
DescribeProperty(const char * name,char * description)3094 int ScintillaCall::DescribeProperty(const char *name, char *description) {
3095 return static_cast<int>(CallPointer(Message::DescribeProperty, reinterpret_cast<uintptr_t>(name), description));
3096 }
3097
DescribeProperty(const char * name)3098 std::string ScintillaCall::DescribeProperty(const char *name) {
3099 return CallReturnString(Message::DescribeProperty, reinterpret_cast<uintptr_t>(name));
3100 }
3101
DescribeKeyWordSets(char * descriptions)3102 int ScintillaCall::DescribeKeyWordSets(char *descriptions) {
3103 return static_cast<int>(CallPointer(Message::DescribeKeyWordSets, 0, descriptions));
3104 }
3105
DescribeKeyWordSets()3106 std::string ScintillaCall::DescribeKeyWordSets() {
3107 return CallReturnString(Message::DescribeKeyWordSets, 0);
3108 }
3109
LineEndTypesSupported()3110 int ScintillaCall::LineEndTypesSupported() {
3111 return static_cast<int>(Call(Message::GetLineEndTypesSupported));
3112 }
3113
AllocateSubStyles(int styleBase,int numberStyles)3114 int ScintillaCall::AllocateSubStyles(int styleBase, int numberStyles) {
3115 return static_cast<int>(Call(Message::AllocateSubStyles, styleBase, numberStyles));
3116 }
3117
SubStylesStart(int styleBase)3118 int ScintillaCall::SubStylesStart(int styleBase) {
3119 return static_cast<int>(Call(Message::GetSubStylesStart, styleBase));
3120 }
3121
SubStylesLength(int styleBase)3122 int ScintillaCall::SubStylesLength(int styleBase) {
3123 return static_cast<int>(Call(Message::GetSubStylesLength, styleBase));
3124 }
3125
StyleFromSubStyle(int subStyle)3126 int ScintillaCall::StyleFromSubStyle(int subStyle) {
3127 return static_cast<int>(Call(Message::GetStyleFromSubStyle, subStyle));
3128 }
3129
PrimaryStyleFromStyle(int style)3130 int ScintillaCall::PrimaryStyleFromStyle(int style) {
3131 return static_cast<int>(Call(Message::GetPrimaryStyleFromStyle, style));
3132 }
3133
FreeSubStyles()3134 void ScintillaCall::FreeSubStyles() {
3135 Call(Message::FreeSubStyles);
3136 }
3137
SetIdentifiers(int style,const char * identifiers)3138 void ScintillaCall::SetIdentifiers(int style, const char *identifiers) {
3139 CallString(Message::SetIdentifiers, style, identifiers);
3140 }
3141
DistanceToSecondaryStyles()3142 int ScintillaCall::DistanceToSecondaryStyles() {
3143 return static_cast<int>(Call(Message::DistanceToSecondaryStyles));
3144 }
3145
SubStyleBases(char * styles)3146 int ScintillaCall::SubStyleBases(char *styles) {
3147 return static_cast<int>(CallPointer(Message::GetSubStyleBases, 0, styles));
3148 }
3149
SubStyleBases()3150 std::string ScintillaCall::SubStyleBases() {
3151 return CallReturnString(Message::GetSubStyleBases, 0);
3152 }
3153
NamedStyles()3154 int ScintillaCall::NamedStyles() {
3155 return static_cast<int>(Call(Message::GetNamedStyles));
3156 }
3157
NameOfStyle(int style,char * name)3158 int ScintillaCall::NameOfStyle(int style, char *name) {
3159 return static_cast<int>(CallPointer(Message::NameOfStyle, style, name));
3160 }
3161
NameOfStyle(int style)3162 std::string ScintillaCall::NameOfStyle(int style) {
3163 return CallReturnString(Message::NameOfStyle, style);
3164 }
3165
TagsOfStyle(int style,char * tags)3166 int ScintillaCall::TagsOfStyle(int style, char *tags) {
3167 return static_cast<int>(CallPointer(Message::TagsOfStyle, style, tags));
3168 }
3169
TagsOfStyle(int style)3170 std::string ScintillaCall::TagsOfStyle(int style) {
3171 return CallReturnString(Message::TagsOfStyle, style);
3172 }
3173
DescriptionOfStyle(int style,char * description)3174 int ScintillaCall::DescriptionOfStyle(int style, char *description) {
3175 return static_cast<int>(CallPointer(Message::DescriptionOfStyle, style, description));
3176 }
3177
DescriptionOfStyle(int style)3178 std::string ScintillaCall::DescriptionOfStyle(int style) {
3179 return CallReturnString(Message::DescriptionOfStyle, style);
3180 }
3181
SetILexer(void * ilexer)3182 void ScintillaCall::SetILexer(void *ilexer) {
3183 CallPointer(Message::SetILexer, 0, ilexer);
3184 }
3185
Bidirectional()3186 Bidirectional ScintillaCall::Bidirectional() {
3187 return static_cast<API::Bidirectional>(Call(Message::GetBidirectional));
3188 }
3189
SetBidirectional(API::Bidirectional bidirectional)3190 void ScintillaCall::SetBidirectional(API::Bidirectional bidirectional) {
3191 Call(Message::SetBidirectional, static_cast<uintptr_t>(bidirectional));
3192 }
3193
LineCharacterIndex()3194 LineCharacterIndexType ScintillaCall::LineCharacterIndex() {
3195 return static_cast<API::LineCharacterIndexType>(Call(Message::GetLineCharacterIndex));
3196 }
3197
AllocateLineCharacterIndex(API::LineCharacterIndexType lineCharacterIndex)3198 void ScintillaCall::AllocateLineCharacterIndex(API::LineCharacterIndexType lineCharacterIndex) {
3199 Call(Message::AllocateLineCharacterIndex, static_cast<uintptr_t>(lineCharacterIndex));
3200 }
3201
ReleaseLineCharacterIndex(API::LineCharacterIndexType lineCharacterIndex)3202 void ScintillaCall::ReleaseLineCharacterIndex(API::LineCharacterIndexType lineCharacterIndex) {
3203 Call(Message::ReleaseLineCharacterIndex, static_cast<uintptr_t>(lineCharacterIndex));
3204 }
3205
LineFromIndexPosition(Position pos,API::LineCharacterIndexType lineCharacterIndex)3206 Line ScintillaCall::LineFromIndexPosition(Position pos, API::LineCharacterIndexType lineCharacterIndex) {
3207 return Call(Message::LineFromIndexPosition, pos, static_cast<intptr_t>(lineCharacterIndex));
3208 }
3209
IndexPositionFromLine(Line line,API::LineCharacterIndexType lineCharacterIndex)3210 Position ScintillaCall::IndexPositionFromLine(Line line, API::LineCharacterIndexType lineCharacterIndex) {
3211 return Call(Message::IndexPositionFromLine, line, static_cast<intptr_t>(lineCharacterIndex));
3212 }
3213
3214 //--Autogenerated -- end of section automatically generated from Scintilla.iface */
3215
3216 }
3217