From 11297b8ecd15ce92b727377255cca058d66d59a1 Mon Sep 17 00:00:00 2001 From: mappu Date: Sun, 20 Oct 2024 18:02:15 +1300 Subject: [PATCH] scintillaedit: build --- qt-extras/scintillaedit/gen_ScintillaEdit.cpp | 5598 ++++++++++ qt-extras/scintillaedit/gen_ScintillaEdit.go | 9336 +++++++++++++++++ qt-extras/scintillaedit/gen_ScintillaEdit.h | 1492 +++ 3 files changed, 16426 insertions(+) create mode 100644 qt-extras/scintillaedit/gen_ScintillaEdit.cpp create mode 100644 qt-extras/scintillaedit/gen_ScintillaEdit.go create mode 100644 qt-extras/scintillaedit/gen_ScintillaEdit.h diff --git a/qt-extras/scintillaedit/gen_ScintillaEdit.cpp b/qt-extras/scintillaedit/gen_ScintillaEdit.cpp new file mode 100644 index 00000000..53152e3d --- /dev/null +++ b/qt-extras/scintillaedit/gen_ScintillaEdit.cpp @@ -0,0 +1,5598 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__CharacterRange +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__CharacterRangeFull +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ColourRGBA +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ColourStop +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Fill +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__FillStroke +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Font +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__FontParameters +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__IListBoxDelegate +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__IScreenLine +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__IScreenLineLayout +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Interval +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ListBox +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ListBoxEvent +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ListOptions +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Menu +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__PRectangle +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Point +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Stroke +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Surface +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__SurfaceMode +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Window +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__NotificationData +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__NotifyHeader +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__RangeToFormat +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__RangeToFormatFull +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Rectangle +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__TextRange +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__TextRangeFull +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__TextToFind +#define WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__TextToFindFull +#include +#include "gen_ScintillaEdit.h" +#include "_cgo_export.h" + +Scintilla__Internal__Point* Scintilla__Internal__Point_new() { + return new Scintilla::Internal::Point(); +} + +Scintilla__Internal__Point* Scintilla__Internal__Point_new2(Scintilla__Internal__Point* param1) { + return new Scintilla::Internal::Point(*param1); +} + +Scintilla__Internal__Point* Scintilla__Internal__Point_new3(double x_) { + return new Scintilla::Internal::Point(static_cast(x_)); +} + +Scintilla__Internal__Point* Scintilla__Internal__Point_new4(double x_, double y_) { + return new Scintilla::Internal::Point(static_cast(x_), static_cast(y_)); +} + +Scintilla__Internal__Point* Scintilla__Internal__Point_FromInts(int x_, int y_) { + return new Scintilla::Internal::Point(Scintilla::Internal::Point::FromInts(static_cast(x_), static_cast(y_))); +} + +bool Scintilla__Internal__Point_OperatorEqual(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other) { + return self->operator==(*other); +} + +bool Scintilla__Internal__Point_OperatorNotEqual(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other) { + return self->operator!=(*other); +} + +Scintilla__Internal__Point* Scintilla__Internal__Point_OperatorPlus(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other) { + return new Scintilla::Internal::Point(self->operator+(*other)); +} + +Scintilla__Internal__Point* Scintilla__Internal__Point_OperatorMinus(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other) { + return new Scintilla::Internal::Point(self->operator-(*other)); +} + +void Scintilla__Internal__Point_Delete(Scintilla__Internal__Point* self) { + delete self; +} + +bool Scintilla__Internal__Interval_OperatorEqual(const Scintilla__Internal__Interval* self, Scintilla__Internal__Interval* other) { + return self->operator==(*other); +} + +double Scintilla__Internal__Interval_Width(const Scintilla__Internal__Interval* self) { + Scintilla::Internal::XYPOSITION _ret = self->Width(); + return static_cast(_ret); +} + +bool Scintilla__Internal__Interval_Empty(const Scintilla__Internal__Interval* self) { + return self->Empty(); +} + +bool Scintilla__Internal__Interval_Intersects(const Scintilla__Internal__Interval* self, Scintilla__Internal__Interval* other) { + return self->Intersects(*other); +} + +Scintilla__Internal__Interval* Scintilla__Internal__Interval_Offset(const Scintilla__Internal__Interval* self, double offset) { + return new Scintilla::Internal::Interval(self->Offset(static_cast(offset))); +} + +void Scintilla__Internal__Interval_Delete(Scintilla__Internal__Interval* self) { + delete self; +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new() { + return new Scintilla::Internal::PRectangle(); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new2(Scintilla__Internal__PRectangle* param1) { + return new Scintilla::Internal::PRectangle(*param1); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new3(double left_) { + return new Scintilla::Internal::PRectangle(static_cast(left_)); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new4(double left_, double top_) { + return new Scintilla::Internal::PRectangle(static_cast(left_), static_cast(top_)); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new5(double left_, double top_, double right_) { + return new Scintilla::Internal::PRectangle(static_cast(left_), static_cast(top_), static_cast(right_)); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new6(double left_, double top_, double right_, double bottom_) { + return new Scintilla::Internal::PRectangle(static_cast(left_), static_cast(top_), static_cast(right_), static_cast(bottom_)); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_FromInts(int left_, int top_, int right_, int bottom_) { + return new Scintilla::Internal::PRectangle(Scintilla::Internal::PRectangle::FromInts(static_cast(left_), static_cast(top_), static_cast(right_), static_cast(bottom_))); +} + +bool Scintilla__Internal__PRectangle_OperatorEqual(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__PRectangle* rc) { + return self->operator==(*rc); +} + +bool Scintilla__Internal__PRectangle_Contains(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Point* pt) { + return self->Contains(*pt); +} + +bool Scintilla__Internal__PRectangle_ContainsWholePixel(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Point* pt) { + return self->ContainsWholePixel(*pt); +} + +bool Scintilla__Internal__PRectangle_ContainsWithRc(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__PRectangle* rc) { + return self->Contains(*rc); +} + +bool Scintilla__Internal__PRectangle_Intersects(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__PRectangle* other) { + return self->Intersects(*other); +} + +bool Scintilla__Internal__PRectangle_IntersectsWithHorizontalBounds(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Interval* horizontalBounds) { + return self->Intersects(*horizontalBounds); +} + +void Scintilla__Internal__PRectangle_Move(Scintilla__Internal__PRectangle* self, double xDelta, double yDelta) { + self->Move(static_cast(xDelta), static_cast(yDelta)); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_WithHorizontalBounds(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Interval* horizontal) { + return new Scintilla::Internal::PRectangle(self->WithHorizontalBounds(*horizontal)); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_Inset(const Scintilla__Internal__PRectangle* self, double delta) { + return new Scintilla::Internal::PRectangle(self->Inset(static_cast(delta))); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_InsetWithDelta(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Point* delta) { + return new Scintilla::Internal::PRectangle(self->Inset(*delta)); +} + +Scintilla__Internal__Point* Scintilla__Internal__PRectangle_Centre(const Scintilla__Internal__PRectangle* self) { + return new Scintilla::Internal::Point(self->Centre()); +} + +double Scintilla__Internal__PRectangle_Width(const Scintilla__Internal__PRectangle* self) { + Scintilla::Internal::XYPOSITION _ret = self->Width(); + return static_cast(_ret); +} + +double Scintilla__Internal__PRectangle_Height(const Scintilla__Internal__PRectangle* self) { + Scintilla::Internal::XYPOSITION _ret = self->Height(); + return static_cast(_ret); +} + +bool Scintilla__Internal__PRectangle_Empty(const Scintilla__Internal__PRectangle* self) { + return self->Empty(); +} + +void Scintilla__Internal__PRectangle_Delete(Scintilla__Internal__PRectangle* self) { + delete self; +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new() { + return new Scintilla::Internal::ColourRGBA(); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new2(unsigned int red, unsigned int green, unsigned int blue) { + return new Scintilla::Internal::ColourRGBA(static_cast(red), static_cast(green), static_cast(blue)); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new3(Scintilla__Internal__ColourRGBA* cd, unsigned int alpha) { + return new Scintilla::Internal::ColourRGBA(*cd, static_cast(alpha)); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new4(Scintilla__Internal__ColourRGBA* param1) { + return new Scintilla::Internal::ColourRGBA(*param1); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new5(int co_) { + return new Scintilla::Internal::ColourRGBA(static_cast(co_)); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new6(unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha) { + return new Scintilla::Internal::ColourRGBA(static_cast(red), static_cast(green), static_cast(blue), static_cast(alpha)); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_FromRGB(int co_) { + return new Scintilla::Internal::ColourRGBA(Scintilla::Internal::ColourRGBA::FromRGB(static_cast(co_))); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_Grey(unsigned int grey) { + return new Scintilla::Internal::ColourRGBA(Scintilla::Internal::ColourRGBA::Grey(static_cast(grey))); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_FromIpRGB(intptr_t co_) { + return new Scintilla::Internal::ColourRGBA(Scintilla::Internal::ColourRGBA::FromIpRGB(static_cast(co_))); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_WithoutAlpha(const Scintilla__Internal__ColourRGBA* self) { + return new Scintilla::Internal::ColourRGBA(self->WithoutAlpha()); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_Opaque(const Scintilla__Internal__ColourRGBA* self) { + return new Scintilla::Internal::ColourRGBA(self->Opaque()); +} + +int Scintilla__Internal__ColourRGBA_AsInteger(const Scintilla__Internal__ColourRGBA* self) { + return self->AsInteger(); +} + +int Scintilla__Internal__ColourRGBA_OpaqueRGB(const Scintilla__Internal__ColourRGBA* self) { + return self->OpaqueRGB(); +} + +unsigned char Scintilla__Internal__ColourRGBA_GetRed(const Scintilla__Internal__ColourRGBA* self) { + return self->GetRed(); +} + +unsigned char Scintilla__Internal__ColourRGBA_GetGreen(const Scintilla__Internal__ColourRGBA* self) { + return self->GetGreen(); +} + +unsigned char Scintilla__Internal__ColourRGBA_GetBlue(const Scintilla__Internal__ColourRGBA* self) { + return self->GetBlue(); +} + +unsigned char Scintilla__Internal__ColourRGBA_GetAlpha(const Scintilla__Internal__ColourRGBA* self) { + return self->GetAlpha(); +} + +float Scintilla__Internal__ColourRGBA_GetRedComponent(const Scintilla__Internal__ColourRGBA* self) { + return self->GetRedComponent(); +} + +float Scintilla__Internal__ColourRGBA_GetGreenComponent(const Scintilla__Internal__ColourRGBA* self) { + return self->GetGreenComponent(); +} + +float Scintilla__Internal__ColourRGBA_GetBlueComponent(const Scintilla__Internal__ColourRGBA* self) { + return self->GetBlueComponent(); +} + +float Scintilla__Internal__ColourRGBA_GetAlphaComponent(const Scintilla__Internal__ColourRGBA* self) { + return self->GetAlphaComponent(); +} + +bool Scintilla__Internal__ColourRGBA_OperatorEqual(const Scintilla__Internal__ColourRGBA* self, Scintilla__Internal__ColourRGBA* other) { + return self->operator==(*other); +} + +bool Scintilla__Internal__ColourRGBA_IsOpaque(const Scintilla__Internal__ColourRGBA* self) { + return self->IsOpaque(); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_MixedWith(const Scintilla__Internal__ColourRGBA* self, Scintilla__Internal__ColourRGBA* other) { + return new Scintilla::Internal::ColourRGBA(self->MixedWith(*other)); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_MixedWith2(const Scintilla__Internal__ColourRGBA* self, Scintilla__Internal__ColourRGBA* other, double proportion) { + return new Scintilla::Internal::ColourRGBA(self->MixedWith(*other, static_cast(proportion))); +} + +void Scintilla__Internal__ColourRGBA_OperatorAssign(Scintilla__Internal__ColourRGBA* self, Scintilla__Internal__ColourRGBA* param1) { + self->operator=(*param1); +} + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_Grey2(unsigned int grey, unsigned int alpha) { + return new Scintilla::Internal::ColourRGBA(Scintilla::Internal::ColourRGBA::Grey(static_cast(grey), static_cast(alpha))); +} + +void Scintilla__Internal__ColourRGBA_Delete(Scintilla__Internal__ColourRGBA* self) { + delete self; +} + +Scintilla__Internal__Stroke* Scintilla__Internal__Stroke_new(Scintilla__Internal__ColourRGBA* colour_) { + return new Scintilla::Internal::Stroke(*colour_); +} + +Scintilla__Internal__Stroke* Scintilla__Internal__Stroke_new2(Scintilla__Internal__Stroke* param1) { + return new Scintilla::Internal::Stroke(*param1); +} + +Scintilla__Internal__Stroke* Scintilla__Internal__Stroke_new3(Scintilla__Internal__ColourRGBA* colour_, double width_) { + return new Scintilla::Internal::Stroke(*colour_, static_cast(width_)); +} + +float Scintilla__Internal__Stroke_WidthF(const Scintilla__Internal__Stroke* self) { + return self->WidthF(); +} + +void Scintilla__Internal__Stroke_Delete(Scintilla__Internal__Stroke* self) { + delete self; +} + +Scintilla__Internal__Fill* Scintilla__Internal__Fill_new(Scintilla__Internal__ColourRGBA* colour_) { + return new Scintilla::Internal::Fill(*colour_); +} + +Scintilla__Internal__Fill* Scintilla__Internal__Fill_new2(Scintilla__Internal__Fill* param1) { + return new Scintilla::Internal::Fill(*param1); +} + +void Scintilla__Internal__Fill_Delete(Scintilla__Internal__Fill* self) { + delete self; +} + +Scintilla__Internal__FillStroke* Scintilla__Internal__FillStroke_new(Scintilla__Internal__ColourRGBA* colourFill_, Scintilla__Internal__ColourRGBA* colourStroke_) { + return new Scintilla::Internal::FillStroke(*colourFill_, *colourStroke_); +} + +Scintilla__Internal__FillStroke* Scintilla__Internal__FillStroke_new2(Scintilla__Internal__ColourRGBA* colourBoth) { + return new Scintilla::Internal::FillStroke(*colourBoth); +} + +Scintilla__Internal__FillStroke* Scintilla__Internal__FillStroke_new3(Scintilla__Internal__ColourRGBA* colourFill_, Scintilla__Internal__ColourRGBA* colourStroke_, double widthStroke_) { + return new Scintilla::Internal::FillStroke(*colourFill_, *colourStroke_, static_cast(widthStroke_)); +} + +Scintilla__Internal__FillStroke* Scintilla__Internal__FillStroke_new4(Scintilla__Internal__ColourRGBA* colourBoth, double widthStroke_) { + return new Scintilla::Internal::FillStroke(*colourBoth, static_cast(widthStroke_)); +} + +void Scintilla__Internal__FillStroke_Delete(Scintilla__Internal__FillStroke* self) { + delete self; +} + +Scintilla__Internal__ColourStop* Scintilla__Internal__ColourStop_new(double position_, Scintilla__Internal__ColourRGBA* colour_) { + return new Scintilla::Internal::ColourStop(static_cast(position_), *colour_); +} + +void Scintilla__Internal__ColourStop_Delete(Scintilla__Internal__ColourStop* self) { + delete self; +} + +void Scintilla__CharacterRange_Delete(Scintilla__CharacterRange* self) { + delete self; +} + +void Scintilla__CharacterRangeFull_Delete(Scintilla__CharacterRangeFull* self) { + delete self; +} + +void Scintilla__TextRange_Delete(Scintilla__TextRange* self) { + delete self; +} + +void Scintilla__TextRangeFull_Delete(Scintilla__TextRangeFull* self) { + delete self; +} + +void Scintilla__TextToFind_Delete(Scintilla__TextToFind* self) { + delete self; +} + +void Scintilla__TextToFindFull_Delete(Scintilla__TextToFindFull* self) { + delete self; +} + +void Scintilla__Rectangle_Delete(Scintilla__Rectangle* self) { + delete self; +} + +void Scintilla__RangeToFormat_Delete(Scintilla__RangeToFormat* self) { + delete self; +} + +void Scintilla__RangeToFormatFull_Delete(Scintilla__RangeToFormatFull* self) { + delete self; +} + +void Scintilla__NotifyHeader_Delete(Scintilla__NotifyHeader* self) { + delete self; +} + +void Scintilla__NotificationData_Delete(Scintilla__NotificationData* self) { + delete self; +} + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new(const char* faceName_) { + return new Scintilla::Internal::FontParameters(faceName_); +} + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new2(const char* faceName_, double size_) { + return new Scintilla::Internal::FontParameters(faceName_, static_cast(size_)); +} + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new3(const char* faceName_, double size_, int weight_) { + return new Scintilla::Internal::FontParameters(faceName_, static_cast(size_), static_cast(weight_)); +} + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new4(const char* faceName_, double size_, int weight_, bool italic_) { + return new Scintilla::Internal::FontParameters(faceName_, static_cast(size_), static_cast(weight_), italic_); +} + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new5(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_) { + return new Scintilla::Internal::FontParameters(faceName_, static_cast(size_), static_cast(weight_), italic_, static_cast(extraFontFlag_)); +} + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new6(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_, int technology_) { + return new Scintilla::Internal::FontParameters(faceName_, static_cast(size_), static_cast(weight_), italic_, static_cast(extraFontFlag_), static_cast(technology_)); +} + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new7(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_, int technology_, int characterSet_) { + return new Scintilla::Internal::FontParameters(faceName_, static_cast(size_), static_cast(weight_), italic_, static_cast(extraFontFlag_), static_cast(technology_), static_cast(characterSet_)); +} + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new8(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_, int technology_, int characterSet_, const char* localeName_) { + return new Scintilla::Internal::FontParameters(faceName_, static_cast(size_), static_cast(weight_), italic_, static_cast(extraFontFlag_), static_cast(technology_), static_cast(characterSet_), localeName_); +} + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new9(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_, int technology_, int characterSet_, const char* localeName_, int stretch_) { + return new Scintilla::Internal::FontParameters(faceName_, static_cast(size_), static_cast(weight_), italic_, static_cast(extraFontFlag_), static_cast(technology_), static_cast(characterSet_), localeName_, static_cast(stretch_)); +} + +void Scintilla__Internal__FontParameters_Delete(Scintilla__Internal__FontParameters* self) { + delete self; +} + +Scintilla__Internal__Font* Scintilla__Internal__Font_new() { + return new Scintilla::Internal::Font(); +} + +void Scintilla__Internal__Font_Delete(Scintilla__Internal__Font* self) { + delete self; +} + +size_t Scintilla__Internal__IScreenLine_Length(const Scintilla__Internal__IScreenLine* self) { + return self->Length(); +} + +size_t Scintilla__Internal__IScreenLine_RepresentationCount(const Scintilla__Internal__IScreenLine* self) { + return self->RepresentationCount(); +} + +double Scintilla__Internal__IScreenLine_Width(const Scintilla__Internal__IScreenLine* self) { + Scintilla::Internal::XYPOSITION _ret = self->Width(); + return static_cast(_ret); +} + +double Scintilla__Internal__IScreenLine_Height(const Scintilla__Internal__IScreenLine* self) { + Scintilla::Internal::XYPOSITION _ret = self->Height(); + return static_cast(_ret); +} + +double Scintilla__Internal__IScreenLine_TabWidth(const Scintilla__Internal__IScreenLine* self) { + Scintilla::Internal::XYPOSITION _ret = self->TabWidth(); + return static_cast(_ret); +} + +double Scintilla__Internal__IScreenLine_TabWidthMinimumPixels(const Scintilla__Internal__IScreenLine* self) { + Scintilla::Internal::XYPOSITION _ret = self->TabWidthMinimumPixels(); + return static_cast(_ret); +} + +Scintilla__Internal__Font* Scintilla__Internal__IScreenLine_FontOfPosition(const Scintilla__Internal__IScreenLine* self, size_t position) { + return (Scintilla__Internal__Font*) self->FontOfPosition(static_cast(position)); +} + +double Scintilla__Internal__IScreenLine_RepresentationWidth(const Scintilla__Internal__IScreenLine* self, size_t position) { + Scintilla::Internal::XYPOSITION _ret = self->RepresentationWidth(static_cast(position)); + return static_cast(_ret); +} + +double Scintilla__Internal__IScreenLine_TabPositionAfter(const Scintilla__Internal__IScreenLine* self, double xPosition) { + Scintilla::Internal::XYPOSITION _ret = self->TabPositionAfter(static_cast(xPosition)); + return static_cast(_ret); +} + +void Scintilla__Internal__IScreenLine_OperatorAssign(Scintilla__Internal__IScreenLine* self, Scintilla__Internal__IScreenLine* param1) { + self->operator=(*param1); +} + +void Scintilla__Internal__IScreenLine_Delete(Scintilla__Internal__IScreenLine* self) { + delete self; +} + +size_t Scintilla__Internal__IScreenLineLayout_PositionFromX(Scintilla__Internal__IScreenLineLayout* self, double xDistance, bool charPosition) { + return self->PositionFromX(static_cast(xDistance), charPosition); +} + +double Scintilla__Internal__IScreenLineLayout_XFromPosition(Scintilla__Internal__IScreenLineLayout* self, size_t caretPosition) { + Scintilla::Internal::XYPOSITION _ret = self->XFromPosition(static_cast(caretPosition)); + return static_cast(_ret); +} + +void Scintilla__Internal__IScreenLineLayout_OperatorAssign(Scintilla__Internal__IScreenLineLayout* self, Scintilla__Internal__IScreenLineLayout* param1) { + self->operator=(*param1); +} + +void Scintilla__Internal__IScreenLineLayout_Delete(Scintilla__Internal__IScreenLineLayout* self) { + delete self; +} + +Scintilla__Internal__SurfaceMode* Scintilla__Internal__SurfaceMode_new() { + return new Scintilla::Internal::SurfaceMode(); +} + +Scintilla__Internal__SurfaceMode* Scintilla__Internal__SurfaceMode_new2(int codePage_, bool bidiR2L_) { + return new Scintilla::Internal::SurfaceMode(static_cast(codePage_), bidiR2L_); +} + +void Scintilla__Internal__SurfaceMode_Delete(Scintilla__Internal__SurfaceMode* self) { + delete self; +} + +void Scintilla__Internal__Surface_Init(Scintilla__Internal__Surface* self, void* wid) { + self->Init(wid); +} + +void Scintilla__Internal__Surface_Init2(Scintilla__Internal__Surface* self, void* sid, void* wid) { + self->Init(sid, wid); +} + +void Scintilla__Internal__Surface_SetMode(Scintilla__Internal__Surface* self, Scintilla__Internal__SurfaceMode* mode) { + self->SetMode(*mode); +} + +void Scintilla__Internal__Surface_Release(Scintilla__Internal__Surface* self) { + self->Release(); +} + +int Scintilla__Internal__Surface_SupportsFeature(Scintilla__Internal__Surface* self, int feature) { + return self->SupportsFeature(static_cast(feature)); +} + +bool Scintilla__Internal__Surface_Initialised(Scintilla__Internal__Surface* self) { + return self->Initialised(); +} + +int Scintilla__Internal__Surface_LogPixelsY(Scintilla__Internal__Surface* self) { + return self->LogPixelsY(); +} + +int Scintilla__Internal__Surface_PixelDivisions(Scintilla__Internal__Surface* self) { + return self->PixelDivisions(); +} + +int Scintilla__Internal__Surface_DeviceHeightFont(Scintilla__Internal__Surface* self, int points) { + return self->DeviceHeightFont(static_cast(points)); +} + +void Scintilla__Internal__Surface_LineDraw(Scintilla__Internal__Surface* self, Scintilla__Internal__Point* start, Scintilla__Internal__Point* end, Scintilla__Internal__Stroke* stroke) { + self->LineDraw(*start, *end, *stroke); +} + +void Scintilla__Internal__Surface_PolyLine(Scintilla__Internal__Surface* self, Scintilla__Internal__Point* pts, size_t npts, Scintilla__Internal__Stroke* stroke) { + self->PolyLine(pts, static_cast(npts), *stroke); +} + +void Scintilla__Internal__Surface_Polygon(Scintilla__Internal__Surface* self, Scintilla__Internal__Point* pts, size_t npts, Scintilla__Internal__FillStroke* fillStroke) { + self->Polygon(pts, static_cast(npts), *fillStroke); +} + +void Scintilla__Internal__Surface_RectangleDraw(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke) { + self->RectangleDraw(*rc, *fillStroke); +} + +void Scintilla__Internal__Surface_RectangleFrame(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Stroke* stroke) { + self->RectangleFrame(*rc, *stroke); +} + +void Scintilla__Internal__Surface_FillRectangle(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Fill* fill) { + self->FillRectangle(*rc, *fill); +} + +void Scintilla__Internal__Surface_FillRectangleAligned(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Fill* fill) { + self->FillRectangleAligned(*rc, *fill); +} + +void Scintilla__Internal__Surface_FillRectangle2(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Surface* surfacePattern) { + self->FillRectangle(*rc, *surfacePattern); +} + +void Scintilla__Internal__Surface_RoundedRectangle(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke) { + self->RoundedRectangle(*rc, *fillStroke); +} + +void Scintilla__Internal__Surface_AlphaRectangle(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, double cornerSize, Scintilla__Internal__FillStroke* fillStroke) { + self->AlphaRectangle(*rc, static_cast(cornerSize), *fillStroke); +} + +void Scintilla__Internal__Surface_DrawRGBAImage(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, int width, int height, const unsigned char* pixelsImage) { + self->DrawRGBAImage(*rc, static_cast(width), static_cast(height), static_cast(pixelsImage)); +} + +void Scintilla__Internal__Surface_Ellipse(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke) { + self->Ellipse(*rc, *fillStroke); +} + +void Scintilla__Internal__Surface_Stadium(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke, int ends) { + self->Stadium(*rc, *fillStroke, static_cast(ends)); +} + +void Scintilla__Internal__Surface_Copy(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Point* from, Scintilla__Internal__Surface* surfaceSource) { + self->Copy(*rc, *from, *surfaceSource); +} + +double Scintilla__Internal__Surface_Ascent(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_) { + Scintilla::Internal::XYPOSITION _ret = self->Ascent(font_); + return static_cast(_ret); +} + +double Scintilla__Internal__Surface_Descent(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_) { + Scintilla::Internal::XYPOSITION _ret = self->Descent(font_); + return static_cast(_ret); +} + +double Scintilla__Internal__Surface_InternalLeading(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_) { + Scintilla::Internal::XYPOSITION _ret = self->InternalLeading(font_); + return static_cast(_ret); +} + +double Scintilla__Internal__Surface_Height(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_) { + Scintilla::Internal::XYPOSITION _ret = self->Height(font_); + return static_cast(_ret); +} + +double Scintilla__Internal__Surface_AverageCharWidth(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_) { + Scintilla::Internal::XYPOSITION _ret = self->AverageCharWidth(font_); + return static_cast(_ret); +} + +void Scintilla__Internal__Surface_SetClip(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc) { + self->SetClip(*rc); +} + +void Scintilla__Internal__Surface_PopClip(Scintilla__Internal__Surface* self) { + self->PopClip(); +} + +void Scintilla__Internal__Surface_FlushCachedState(Scintilla__Internal__Surface* self) { + self->FlushCachedState(); +} + +void Scintilla__Internal__Surface_FlushDrawing(Scintilla__Internal__Surface* self) { + self->FlushDrawing(); +} + +void Scintilla__Internal__Surface_Delete(Scintilla__Internal__Surface* self) { + delete self; +} + +Scintilla__Internal__Window* Scintilla__Internal__Window_new() { + return new Scintilla::Internal::Window(); +} + +void Scintilla__Internal__Window_OperatorAssign(Scintilla__Internal__Window* self, void* wid_) { + self->operator=(wid_); +} + +void* Scintilla__Internal__Window_GetID(const Scintilla__Internal__Window* self) { + Scintilla::Internal::WindowID _ret = self->GetID(); + return static_cast(_ret); +} + +bool Scintilla__Internal__Window_Created(const Scintilla__Internal__Window* self) { + return self->Created(); +} + +void Scintilla__Internal__Window_Destroy(Scintilla__Internal__Window* self) { + self->Destroy(); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__Window_GetPosition(const Scintilla__Internal__Window* self) { + return new Scintilla::Internal::PRectangle(self->GetPosition()); +} + +void Scintilla__Internal__Window_SetPosition(Scintilla__Internal__Window* self, Scintilla__Internal__PRectangle* rc) { + self->SetPosition(*rc); +} + +void Scintilla__Internal__Window_SetPositionRelative(Scintilla__Internal__Window* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Window* relativeTo) { + self->SetPositionRelative(*rc, relativeTo); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__Window_GetClientPosition(const Scintilla__Internal__Window* self) { + return new Scintilla::Internal::PRectangle(self->GetClientPosition()); +} + +void Scintilla__Internal__Window_Show(Scintilla__Internal__Window* self) { + self->Show(); +} + +void Scintilla__Internal__Window_InvalidateAll(Scintilla__Internal__Window* self) { + self->InvalidateAll(); +} + +void Scintilla__Internal__Window_InvalidateRectangle(Scintilla__Internal__Window* self, Scintilla__Internal__PRectangle* rc) { + self->InvalidateRectangle(*rc); +} + +void Scintilla__Internal__Window_SetCursor(Scintilla__Internal__Window* self, int curs) { + self->SetCursor(static_cast(curs)); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__Window_GetMonitorRect(Scintilla__Internal__Window* self, Scintilla__Internal__Point* pt) { + return new Scintilla::Internal::PRectangle(self->GetMonitorRect(*pt)); +} + +void Scintilla__Internal__Window_Show1(Scintilla__Internal__Window* self, bool show) { + self->Show(show); +} + +void Scintilla__Internal__Window_Delete(Scintilla__Internal__Window* self) { + delete self; +} + +Scintilla__Internal__ListBoxEvent* Scintilla__Internal__ListBoxEvent_new(int event_) { + return new Scintilla::Internal::ListBoxEvent(static_cast(event_)); +} + +void Scintilla__Internal__ListBoxEvent_Delete(Scintilla__Internal__ListBoxEvent* self) { + delete self; +} + +void Scintilla__Internal__IListBoxDelegate_ListNotify(Scintilla__Internal__IListBoxDelegate* self, Scintilla__Internal__ListBoxEvent* plbe) { + self->ListNotify(plbe); +} + +void Scintilla__Internal__IListBoxDelegate_OperatorAssign(Scintilla__Internal__IListBoxDelegate* self, Scintilla__Internal__IListBoxDelegate* param1) { + self->operator=(*param1); +} + +void Scintilla__Internal__IListBoxDelegate_Delete(Scintilla__Internal__IListBoxDelegate* self) { + delete self; +} + +void Scintilla__Internal__ListOptions_Delete(Scintilla__Internal__ListOptions* self) { + delete self; +} + +void Scintilla__Internal__ListBox_SetFont(Scintilla__Internal__ListBox* self, Scintilla__Internal__Font* font) { + self->SetFont(font); +} + +void Scintilla__Internal__ListBox_Create(Scintilla__Internal__ListBox* self, Scintilla__Internal__Window* parent, int ctrlID, Scintilla__Internal__Point* location, int lineHeight_, bool unicodeMode_, int technology_) { + self->Create(*parent, static_cast(ctrlID), *location, static_cast(lineHeight_), unicodeMode_, static_cast(technology_)); +} + +void Scintilla__Internal__ListBox_SetAverageCharWidth(Scintilla__Internal__ListBox* self, int width) { + self->SetAverageCharWidth(static_cast(width)); +} + +void Scintilla__Internal__ListBox_SetVisibleRows(Scintilla__Internal__ListBox* self, int rows) { + self->SetVisibleRows(static_cast(rows)); +} + +int Scintilla__Internal__ListBox_GetVisibleRows(const Scintilla__Internal__ListBox* self) { + return self->GetVisibleRows(); +} + +Scintilla__Internal__PRectangle* Scintilla__Internal__ListBox_GetDesiredRect(Scintilla__Internal__ListBox* self) { + return new Scintilla::Internal::PRectangle(self->GetDesiredRect()); +} + +int Scintilla__Internal__ListBox_CaretFromEdge(Scintilla__Internal__ListBox* self) { + return self->CaretFromEdge(); +} + +void Scintilla__Internal__ListBox_Clear(Scintilla__Internal__ListBox* self) { + self->Clear(); +} + +void Scintilla__Internal__ListBox_Append(Scintilla__Internal__ListBox* self, char* s) { + self->Append(s); +} + +int Scintilla__Internal__ListBox_Length(Scintilla__Internal__ListBox* self) { + return self->Length(); +} + +void Scintilla__Internal__ListBox_Select(Scintilla__Internal__ListBox* self, int n) { + self->Select(static_cast(n)); +} + +int Scintilla__Internal__ListBox_GetSelection(Scintilla__Internal__ListBox* self) { + return self->GetSelection(); +} + +int Scintilla__Internal__ListBox_Find(Scintilla__Internal__ListBox* self, const char* prefix) { + return self->Find(prefix); +} + +void Scintilla__Internal__ListBox_RegisterImage(Scintilla__Internal__ListBox* self, int typeVal, const char* xpm_data) { + self->RegisterImage(static_cast(typeVal), xpm_data); +} + +void Scintilla__Internal__ListBox_RegisterRGBAImage(Scintilla__Internal__ListBox* self, int typeVal, int width, int height, const unsigned char* pixelsImage) { + self->RegisterRGBAImage(static_cast(typeVal), static_cast(width), static_cast(height), static_cast(pixelsImage)); +} + +void Scintilla__Internal__ListBox_ClearRegisteredImages(Scintilla__Internal__ListBox* self) { + self->ClearRegisteredImages(); +} + +void Scintilla__Internal__ListBox_SetDelegate(Scintilla__Internal__ListBox* self, Scintilla__Internal__IListBoxDelegate* lbDelegate) { + self->SetDelegate(lbDelegate); +} + +void Scintilla__Internal__ListBox_SetList(Scintilla__Internal__ListBox* self, const char* list, char separator, char typesep) { + self->SetList(list, static_cast(separator), static_cast(typesep)); +} + +void Scintilla__Internal__ListBox_SetOptions(Scintilla__Internal__ListBox* self, Scintilla__Internal__ListOptions* options_) { + self->SetOptions(*options_); +} + +void Scintilla__Internal__ListBox_Append2(Scintilla__Internal__ListBox* self, char* s, int typeVal) { + self->Append(s, static_cast(typeVal)); +} + +void Scintilla__Internal__ListBox_Delete(Scintilla__Internal__ListBox* self) { + delete self; +} + +Scintilla__Internal__Menu* Scintilla__Internal__Menu_new() { + return new Scintilla::Internal::Menu(); +} + +void* Scintilla__Internal__Menu_GetID(const Scintilla__Internal__Menu* self) { + Scintilla::Internal::MenuID _ret = self->GetID(); + return static_cast(_ret); +} + +void Scintilla__Internal__Menu_CreatePopUp(Scintilla__Internal__Menu* self) { + self->CreatePopUp(); +} + +void Scintilla__Internal__Menu_Destroy(Scintilla__Internal__Menu* self) { + self->Destroy(); +} + +void Scintilla__Internal__Menu_Show(Scintilla__Internal__Menu* self, Scintilla__Internal__Point* pt, Scintilla__Internal__Window* w) { + self->Show(*pt, *w); +} + +void Scintilla__Internal__Menu_Delete(Scintilla__Internal__Menu* self) { + delete self; +} + +void Sci_CharacterRange_Delete(Sci_CharacterRange* self) { + delete self; +} + +void Sci_CharacterRangeFull_Delete(Sci_CharacterRangeFull* self) { + delete self; +} + +void Sci_TextRange_Delete(Sci_TextRange* self) { + delete self; +} + +void Sci_TextRangeFull_Delete(Sci_TextRangeFull* self) { + delete self; +} + +void Sci_TextToFind_Delete(Sci_TextToFind* self) { + delete self; +} + +void Sci_TextToFindFull_Delete(Sci_TextToFindFull* self) { + delete self; +} + +void Sci_Rectangle_Delete(Sci_Rectangle* self) { + delete self; +} + +void Sci_RangeToFormat_Delete(Sci_RangeToFormat* self) { + delete self; +} + +void Sci_RangeToFormatFull_Delete(Sci_RangeToFormatFull* self) { + delete self; +} + +void Sci_NotifyHeader_Delete(Sci_NotifyHeader* self) { + delete self; +} + +void SCNotification_Delete(SCNotification* self) { + delete self; +} + +ScintillaEditBase* ScintillaEditBase_new() { + return new ScintillaEditBase(); +} + +ScintillaEditBase* ScintillaEditBase_new2(QWidget* parent) { + return new ScintillaEditBase(parent); +} + +QMetaObject* ScintillaEditBase_MetaObject(const ScintillaEditBase* self) { + return (QMetaObject*) self->metaObject(); +} + +void* ScintillaEditBase_Metacast(ScintillaEditBase* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string ScintillaEditBase_Tr(const char* s) { + QString _ret = ScintillaEditBase::tr(s); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEditBase_TrUtf8(const char* s) { + QString _ret = ScintillaEditBase::trUtf8(s); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEditBase_Send(const ScintillaEditBase* self, unsigned int iMessage) { + sptr_t _ret = self->send(static_cast(iMessage)); + return static_cast(_ret); +} + +intptr_t ScintillaEditBase_Sends(const ScintillaEditBase* self, unsigned int iMessage) { + sptr_t _ret = self->sends(static_cast(iMessage)); + return static_cast(_ret); +} + +void ScintillaEditBase_ScrollHorizontal(ScintillaEditBase* self, int value) { + self->scrollHorizontal(static_cast(value)); +} + +void ScintillaEditBase_ScrollVertical(ScintillaEditBase* self, int value) { + self->scrollVertical(static_cast(value)); +} + +void ScintillaEditBase_NotifyParent(ScintillaEditBase* self, Scintilla__NotificationData* scn) { + self->notifyParent(*scn); +} + +void ScintillaEditBase_EventCommand(ScintillaEditBase* self, uintptr_t wParam, intptr_t lParam) { + self->event_command(static_cast(wParam), static_cast(lParam)); +} + +void ScintillaEditBase_HorizontalScrolled(ScintillaEditBase* self, int value) { + self->horizontalScrolled(static_cast(value)); +} + +void ScintillaEditBase_connect_HorizontalScrolled(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::horizontalScrolled), self, [=](int value) { + int sigval1 = value; + miqt_exec_callback_ScintillaEditBase_HorizontalScrolled(slot, sigval1); + }); +} + +void ScintillaEditBase_VerticalScrolled(ScintillaEditBase* self, int value) { + self->verticalScrolled(static_cast(value)); +} + +void ScintillaEditBase_connect_VerticalScrolled(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::verticalScrolled), self, [=](int value) { + int sigval1 = value; + miqt_exec_callback_ScintillaEditBase_VerticalScrolled(slot, sigval1); + }); +} + +void ScintillaEditBase_HorizontalRangeChanged(ScintillaEditBase* self, int max, int page) { + self->horizontalRangeChanged(static_cast(max), static_cast(page)); +} + +void ScintillaEditBase_connect_HorizontalRangeChanged(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::horizontalRangeChanged), self, [=](int max, int page) { + int sigval1 = max; + int sigval2 = page; + miqt_exec_callback_ScintillaEditBase_HorizontalRangeChanged(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_VerticalRangeChanged(ScintillaEditBase* self, int max, int page) { + self->verticalRangeChanged(static_cast(max), static_cast(page)); +} + +void ScintillaEditBase_connect_VerticalRangeChanged(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::verticalRangeChanged), self, [=](int max, int page) { + int sigval1 = max; + int sigval2 = page; + miqt_exec_callback_ScintillaEditBase_VerticalRangeChanged(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_NotifyChange(ScintillaEditBase* self) { + self->notifyChange(); +} + +void ScintillaEditBase_connect_NotifyChange(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::notifyChange), self, [=]() { + miqt_exec_callback_ScintillaEditBase_NotifyChange(slot); + }); +} + +void ScintillaEditBase_LinesAdded(ScintillaEditBase* self, intptr_t linesAdded) { + self->linesAdded(static_cast(linesAdded)); +} + +void ScintillaEditBase_connect_LinesAdded(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::linesAdded), self, [=](Scintilla::Position linesAdded) { + Scintilla::Position linesAdded_ret = linesAdded; + intptr_t sigval1 = static_cast(linesAdded_ret); + miqt_exec_callback_ScintillaEditBase_LinesAdded(slot, sigval1); + }); +} + +void ScintillaEditBase_AboutToCopy(ScintillaEditBase* self, QMimeData* data) { + self->aboutToCopy(data); +} + +void ScintillaEditBase_connect_AboutToCopy(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::aboutToCopy), self, [=](QMimeData* data) { + QMimeData* sigval1 = data; + miqt_exec_callback_ScintillaEditBase_AboutToCopy(slot, sigval1); + }); +} + +void ScintillaEditBase_StyleNeeded(ScintillaEditBase* self, intptr_t position) { + self->styleNeeded(static_cast(position)); +} + +void ScintillaEditBase_connect_StyleNeeded(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::styleNeeded), self, [=](Scintilla::Position position) { + Scintilla::Position position_ret = position; + intptr_t sigval1 = static_cast(position_ret); + miqt_exec_callback_ScintillaEditBase_StyleNeeded(slot, sigval1); + }); +} + +void ScintillaEditBase_CharAdded(ScintillaEditBase* self, int ch) { + self->charAdded(static_cast(ch)); +} + +void ScintillaEditBase_connect_CharAdded(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::charAdded), self, [=](int ch) { + int sigval1 = ch; + miqt_exec_callback_ScintillaEditBase_CharAdded(slot, sigval1); + }); +} + +void ScintillaEditBase_SavePointChanged(ScintillaEditBase* self, bool dirty) { + self->savePointChanged(dirty); +} + +void ScintillaEditBase_connect_SavePointChanged(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::savePointChanged), self, [=](bool dirty) { + bool sigval1 = dirty; + miqt_exec_callback_ScintillaEditBase_SavePointChanged(slot, sigval1); + }); +} + +void ScintillaEditBase_ModifyAttemptReadOnly(ScintillaEditBase* self) { + self->modifyAttemptReadOnly(); +} + +void ScintillaEditBase_connect_ModifyAttemptReadOnly(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::modifyAttemptReadOnly), self, [=]() { + miqt_exec_callback_ScintillaEditBase_ModifyAttemptReadOnly(slot); + }); +} + +void ScintillaEditBase_Key(ScintillaEditBase* self, int key) { + self->key(static_cast(key)); +} + +void ScintillaEditBase_connect_Key(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::key), self, [=](int key) { + int sigval1 = key; + miqt_exec_callback_ScintillaEditBase_Key(slot, sigval1); + }); +} + +void ScintillaEditBase_DoubleClick(ScintillaEditBase* self, intptr_t position, intptr_t line) { + self->doubleClick(static_cast(position), static_cast(line)); +} + +void ScintillaEditBase_connect_DoubleClick(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::doubleClick), self, [=](Scintilla::Position position, Scintilla::Position line) { + Scintilla::Position position_ret = position; + intptr_t sigval1 = static_cast(position_ret); + Scintilla::Position line_ret = line; + intptr_t sigval2 = static_cast(line_ret); + miqt_exec_callback_ScintillaEditBase_DoubleClick(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_UpdateUi(ScintillaEditBase* self, int updated) { + self->updateUi(static_cast(updated)); +} + +void ScintillaEditBase_connect_UpdateUi(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::updateUi), self, [=](Scintilla::Update updated) { + Scintilla::Update updated_ret = updated; + int sigval1 = static_cast(updated_ret); + miqt_exec_callback_ScintillaEditBase_UpdateUi(slot, sigval1); + }); +} + +void ScintillaEditBase_Modified(ScintillaEditBase* self, int typeVal, intptr_t position, intptr_t length, intptr_t linesAdded, struct miqt_string text, intptr_t line, int foldNow, int foldPrev) { + QByteArray text_QByteArray(text.data, text.len); + self->modified(static_cast(typeVal), static_cast(position), static_cast(length), static_cast(linesAdded), text_QByteArray, static_cast(line), static_cast(foldNow), static_cast(foldPrev)); +} + +void ScintillaEditBase_connect_Modified(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::modified), self, [=](Scintilla::ModificationFlags typeVal, Scintilla::Position position, Scintilla::Position length, Scintilla::Position linesAdded, const QByteArray& text, Scintilla::Position line, Scintilla::FoldLevel foldNow, Scintilla::FoldLevel foldPrev) { + Scintilla::ModificationFlags typeVal_ret = typeVal; + int sigval1 = static_cast(typeVal_ret); + Scintilla::Position position_ret = position; + intptr_t sigval2 = static_cast(position_ret); + Scintilla::Position length_ret = length; + intptr_t sigval3 = static_cast(length_ret); + Scintilla::Position linesAdded_ret = linesAdded; + intptr_t sigval4 = static_cast(linesAdded_ret); + const QByteArray text_qb = text; + struct miqt_string text_ms; + text_ms.len = text_qb.length(); + text_ms.data = static_cast(malloc(text_ms.len)); + memcpy(text_ms.data, text_qb.data(), text_ms.len); + struct miqt_string sigval5 = text_ms; + Scintilla::Position line_ret = line; + intptr_t sigval6 = static_cast(line_ret); + Scintilla::FoldLevel foldNow_ret = foldNow; + int sigval7 = static_cast(foldNow_ret); + Scintilla::FoldLevel foldPrev_ret = foldPrev; + int sigval8 = static_cast(foldPrev_ret); + miqt_exec_callback_ScintillaEditBase_Modified(slot, sigval1, sigval2, sigval3, sigval4, sigval5, sigval6, sigval7, sigval8); + }); +} + +void ScintillaEditBase_MacroRecord(ScintillaEditBase* self, int message, uintptr_t wParam, intptr_t lParam) { + self->macroRecord(static_cast(message), static_cast(wParam), static_cast(lParam)); +} + +void ScintillaEditBase_connect_MacroRecord(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::macroRecord), self, [=](Scintilla::Message message, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) { + Scintilla::Message message_ret = message; + int sigval1 = static_cast(message_ret); + Scintilla::uptr_t wParam_ret = wParam; + uintptr_t sigval2 = static_cast(wParam_ret); + Scintilla::sptr_t lParam_ret = lParam; + intptr_t sigval3 = static_cast(lParam_ret); + miqt_exec_callback_ScintillaEditBase_MacroRecord(slot, sigval1, sigval2, sigval3); + }); +} + +void ScintillaEditBase_MarginClicked(ScintillaEditBase* self, intptr_t position, int modifiers, int margin) { + self->marginClicked(static_cast(position), static_cast(modifiers), static_cast(margin)); +} + +void ScintillaEditBase_connect_MarginClicked(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::marginClicked), self, [=](Scintilla::Position position, Scintilla::KeyMod modifiers, int margin) { + Scintilla::Position position_ret = position; + intptr_t sigval1 = static_cast(position_ret); + Scintilla::KeyMod modifiers_ret = modifiers; + int sigval2 = static_cast(modifiers_ret); + int sigval3 = margin; + miqt_exec_callback_ScintillaEditBase_MarginClicked(slot, sigval1, sigval2, sigval3); + }); +} + +void ScintillaEditBase_TextAreaClicked(ScintillaEditBase* self, intptr_t line, int modifiers) { + self->textAreaClicked(static_cast(line), static_cast(modifiers)); +} + +void ScintillaEditBase_connect_TextAreaClicked(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::textAreaClicked), self, [=](Scintilla::Position line, int modifiers) { + Scintilla::Position line_ret = line; + intptr_t sigval1 = static_cast(line_ret); + int sigval2 = modifiers; + miqt_exec_callback_ScintillaEditBase_TextAreaClicked(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_NeedShown(ScintillaEditBase* self, intptr_t position, intptr_t length) { + self->needShown(static_cast(position), static_cast(length)); +} + +void ScintillaEditBase_connect_NeedShown(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::needShown), self, [=](Scintilla::Position position, Scintilla::Position length) { + Scintilla::Position position_ret = position; + intptr_t sigval1 = static_cast(position_ret); + Scintilla::Position length_ret = length; + intptr_t sigval2 = static_cast(length_ret); + miqt_exec_callback_ScintillaEditBase_NeedShown(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_Painted(ScintillaEditBase* self) { + self->painted(); +} + +void ScintillaEditBase_connect_Painted(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::painted), self, [=]() { + miqt_exec_callback_ScintillaEditBase_Painted(slot); + }); +} + +void ScintillaEditBase_UserListSelection(ScintillaEditBase* self) { + self->userListSelection(); +} + +void ScintillaEditBase_connect_UserListSelection(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::userListSelection), self, [=]() { + miqt_exec_callback_ScintillaEditBase_UserListSelection(slot); + }); +} + +void ScintillaEditBase_UriDropped(ScintillaEditBase* self, struct miqt_string uri) { + QString uri_QString = QString::fromUtf8(uri.data, uri.len); + self->uriDropped(uri_QString); +} + +void ScintillaEditBase_connect_UriDropped(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::uriDropped), self, [=](const QString& uri) { + const QString uri_ret = uri; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray uri_b = uri_ret.toUtf8(); + struct miqt_string uri_ms; + uri_ms.len = uri_b.length(); + uri_ms.data = static_cast(malloc(uri_ms.len)); + memcpy(uri_ms.data, uri_b.data(), uri_ms.len); + struct miqt_string sigval1 = uri_ms; + miqt_exec_callback_ScintillaEditBase_UriDropped(slot, sigval1); + }); +} + +void ScintillaEditBase_DwellStart(ScintillaEditBase* self, int x, int y) { + self->dwellStart(static_cast(x), static_cast(y)); +} + +void ScintillaEditBase_connect_DwellStart(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::dwellStart), self, [=](int x, int y) { + int sigval1 = x; + int sigval2 = y; + miqt_exec_callback_ScintillaEditBase_DwellStart(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_DwellEnd(ScintillaEditBase* self, int x, int y) { + self->dwellEnd(static_cast(x), static_cast(y)); +} + +void ScintillaEditBase_connect_DwellEnd(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::dwellEnd), self, [=](int x, int y) { + int sigval1 = x; + int sigval2 = y; + miqt_exec_callback_ScintillaEditBase_DwellEnd(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_Zoom(ScintillaEditBase* self, int zoom) { + self->zoom(static_cast(zoom)); +} + +void ScintillaEditBase_connect_Zoom(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::zoom), self, [=](int zoom) { + int sigval1 = zoom; + miqt_exec_callback_ScintillaEditBase_Zoom(slot, sigval1); + }); +} + +void ScintillaEditBase_HotSpotClick(ScintillaEditBase* self, intptr_t position, int modifiers) { + self->hotSpotClick(static_cast(position), static_cast(modifiers)); +} + +void ScintillaEditBase_connect_HotSpotClick(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::hotSpotClick), self, [=](Scintilla::Position position, Scintilla::KeyMod modifiers) { + Scintilla::Position position_ret = position; + intptr_t sigval1 = static_cast(position_ret); + Scintilla::KeyMod modifiers_ret = modifiers; + int sigval2 = static_cast(modifiers_ret); + miqt_exec_callback_ScintillaEditBase_HotSpotClick(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_HotSpotDoubleClick(ScintillaEditBase* self, intptr_t position, int modifiers) { + self->hotSpotDoubleClick(static_cast(position), static_cast(modifiers)); +} + +void ScintillaEditBase_connect_HotSpotDoubleClick(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::hotSpotDoubleClick), self, [=](Scintilla::Position position, Scintilla::KeyMod modifiers) { + Scintilla::Position position_ret = position; + intptr_t sigval1 = static_cast(position_ret); + Scintilla::KeyMod modifiers_ret = modifiers; + int sigval2 = static_cast(modifiers_ret); + miqt_exec_callback_ScintillaEditBase_HotSpotDoubleClick(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_CallTipClick(ScintillaEditBase* self) { + self->callTipClick(); +} + +void ScintillaEditBase_connect_CallTipClick(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::callTipClick), self, [=]() { + miqt_exec_callback_ScintillaEditBase_CallTipClick(slot); + }); +} + +void ScintillaEditBase_AutoCompleteSelection(ScintillaEditBase* self, intptr_t position, struct miqt_string text) { + QString text_QString = QString::fromUtf8(text.data, text.len); + self->autoCompleteSelection(static_cast(position), text_QString); +} + +void ScintillaEditBase_connect_AutoCompleteSelection(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::autoCompleteSelection), self, [=](Scintilla::Position position, const QString& text) { + Scintilla::Position position_ret = position; + intptr_t sigval1 = static_cast(position_ret); + const QString text_ret = text; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray text_b = text_ret.toUtf8(); + struct miqt_string text_ms; + text_ms.len = text_b.length(); + text_ms.data = static_cast(malloc(text_ms.len)); + memcpy(text_ms.data, text_b.data(), text_ms.len); + struct miqt_string sigval2 = text_ms; + miqt_exec_callback_ScintillaEditBase_AutoCompleteSelection(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_AutoCompleteCancelled(ScintillaEditBase* self) { + self->autoCompleteCancelled(); +} + +void ScintillaEditBase_connect_AutoCompleteCancelled(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::autoCompleteCancelled), self, [=]() { + miqt_exec_callback_ScintillaEditBase_AutoCompleteCancelled(slot); + }); +} + +void ScintillaEditBase_FocusChanged(ScintillaEditBase* self, bool focused) { + self->focusChanged(focused); +} + +void ScintillaEditBase_connect_FocusChanged(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::focusChanged), self, [=](bool focused) { + bool sigval1 = focused; + miqt_exec_callback_ScintillaEditBase_FocusChanged(slot, sigval1); + }); +} + +void ScintillaEditBase_Notify(ScintillaEditBase* self, Scintilla__NotificationData* pscn) { + self->notify(pscn); +} + +void ScintillaEditBase_connect_Notify(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::notify), self, [=](Scintilla::NotificationData* pscn) { + Scintilla__NotificationData* sigval1 = pscn; + miqt_exec_callback_ScintillaEditBase_Notify(slot, sigval1); + }); +} + +void ScintillaEditBase_Command(ScintillaEditBase* self, uintptr_t wParam, intptr_t lParam) { + self->command(static_cast(wParam), static_cast(lParam)); +} + +void ScintillaEditBase_connect_Command(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::command), self, [=](Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) { + Scintilla::uptr_t wParam_ret = wParam; + uintptr_t sigval1 = static_cast(wParam_ret); + Scintilla::sptr_t lParam_ret = lParam; + intptr_t sigval2 = static_cast(lParam_ret); + miqt_exec_callback_ScintillaEditBase_Command(slot, sigval1, sigval2); + }); +} + +void ScintillaEditBase_ButtonPressed(ScintillaEditBase* self, QMouseEvent* event) { + self->buttonPressed(event); +} + +void ScintillaEditBase_connect_ButtonPressed(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::buttonPressed), self, [=](QMouseEvent* event) { + QMouseEvent* sigval1 = event; + miqt_exec_callback_ScintillaEditBase_ButtonPressed(slot, sigval1); + }); +} + +void ScintillaEditBase_ButtonReleased(ScintillaEditBase* self, QMouseEvent* event) { + self->buttonReleased(event); +} + +void ScintillaEditBase_connect_ButtonReleased(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::buttonReleased), self, [=](QMouseEvent* event) { + QMouseEvent* sigval1 = event; + miqt_exec_callback_ScintillaEditBase_ButtonReleased(slot, sigval1); + }); +} + +void ScintillaEditBase_KeyPressed(ScintillaEditBase* self, QKeyEvent* event) { + self->keyPressed(event); +} + +void ScintillaEditBase_connect_KeyPressed(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::keyPressed), self, [=](QKeyEvent* event) { + QKeyEvent* sigval1 = event; + miqt_exec_callback_ScintillaEditBase_KeyPressed(slot, sigval1); + }); +} + +void ScintillaEditBase_Resized(ScintillaEditBase* self) { + self->resized(); +} + +void ScintillaEditBase_connect_Resized(ScintillaEditBase* self, intptr_t slot) { + ScintillaEditBase::connect(self, static_cast(&ScintillaEditBase::resized), self, [=]() { + miqt_exec_callback_ScintillaEditBase_Resized(slot); + }); +} + +struct miqt_string ScintillaEditBase_Tr2(const char* s, const char* c) { + QString _ret = ScintillaEditBase::tr(s, c); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEditBase_Tr3(const char* s, const char* c, int n) { + QString _ret = ScintillaEditBase::tr(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEditBase_TrUtf82(const char* s, const char* c) { + QString _ret = ScintillaEditBase::trUtf8(s, c); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEditBase_TrUtf83(const char* s, const char* c, int n) { + QString _ret = ScintillaEditBase::trUtf8(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEditBase_Send2(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam) { + sptr_t _ret = self->send(static_cast(iMessage), static_cast(wParam)); + return static_cast(_ret); +} + +intptr_t ScintillaEditBase_Send3(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam, intptr_t lParam) { + sptr_t _ret = self->send(static_cast(iMessage), static_cast(wParam), static_cast(lParam)); + return static_cast(_ret); +} + +intptr_t ScintillaEditBase_Sends2(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam) { + sptr_t _ret = self->sends(static_cast(iMessage), static_cast(wParam)); + return static_cast(_ret); +} + +intptr_t ScintillaEditBase_Sends3(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam, const char* s) { + sptr_t _ret = self->sends(static_cast(iMessage), static_cast(wParam), s); + return static_cast(_ret); +} + +void ScintillaEditBase_Delete(ScintillaEditBase* self) { + delete self; +} + +ScintillaDocument* ScintillaDocument_new() { + return new ScintillaDocument(); +} + +ScintillaDocument* ScintillaDocument_new2(QObject* parent) { + return new ScintillaDocument(parent); +} + +ScintillaDocument* ScintillaDocument_new3(QObject* parent, void* pdoc_) { + return new ScintillaDocument(parent, pdoc_); +} + +QMetaObject* ScintillaDocument_MetaObject(const ScintillaDocument* self) { + return (QMetaObject*) self->metaObject(); +} + +void* ScintillaDocument_Metacast(ScintillaDocument* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string ScintillaDocument_Tr(const char* s) { + QString _ret = ScintillaDocument::tr(s); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaDocument_TrUtf8(const char* s) { + QString _ret = ScintillaDocument::trUtf8(s); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +void* ScintillaDocument_Pointer(ScintillaDocument* self) { + return self->pointer(); +} + +int ScintillaDocument_LineFromPosition(ScintillaDocument* self, int pos) { + return self->line_from_position(static_cast(pos)); +} + +bool ScintillaDocument_IsCrLf(ScintillaDocument* self, int pos) { + return self->is_cr_lf(static_cast(pos)); +} + +bool ScintillaDocument_DeleteChars(ScintillaDocument* self, int pos, int lenVal) { + return self->delete_chars(static_cast(pos), static_cast(lenVal)); +} + +int ScintillaDocument_Undo(ScintillaDocument* self) { + return self->undo(); +} + +int ScintillaDocument_Redo(ScintillaDocument* self) { + return self->redo(); +} + +bool ScintillaDocument_CanUndo(ScintillaDocument* self) { + return self->can_undo(); +} + +bool ScintillaDocument_CanRedo(ScintillaDocument* self) { + return self->can_redo(); +} + +void ScintillaDocument_DeleteUndoHistory(ScintillaDocument* self) { + self->delete_undo_history(); +} + +bool ScintillaDocument_SetUndoCollection(ScintillaDocument* self, bool collect_undo) { + return self->set_undo_collection(collect_undo); +} + +bool ScintillaDocument_IsCollectingUndo(ScintillaDocument* self) { + return self->is_collecting_undo(); +} + +void ScintillaDocument_BeginUndoAction(ScintillaDocument* self) { + self->begin_undo_action(); +} + +void ScintillaDocument_EndUndoAction(ScintillaDocument* self) { + self->end_undo_action(); +} + +void ScintillaDocument_SetSavePoint(ScintillaDocument* self) { + self->set_save_point(); +} + +bool ScintillaDocument_IsSavePoint(ScintillaDocument* self) { + return self->is_save_point(); +} + +void ScintillaDocument_SetReadOnly(ScintillaDocument* self, bool read_only) { + self->set_read_only(read_only); +} + +bool ScintillaDocument_IsReadOnly(ScintillaDocument* self) { + return self->is_read_only(); +} + +void ScintillaDocument_InsertString(ScintillaDocument* self, int position, struct miqt_string str) { + QByteArray str_QByteArray(str.data, str.len); + self->insert_string(static_cast(position), str_QByteArray); +} + +struct miqt_string ScintillaDocument_GetCharRange(ScintillaDocument* self, int position, int length) { + QByteArray _qb = self->get_char_range(static_cast(position), static_cast(length)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +char ScintillaDocument_StyleAt(ScintillaDocument* self, int position) { + return self->style_at(static_cast(position)); +} + +int ScintillaDocument_LineStart(ScintillaDocument* self, int lineno) { + return self->line_start(static_cast(lineno)); +} + +int ScintillaDocument_LineEnd(ScintillaDocument* self, int lineno) { + return self->line_end(static_cast(lineno)); +} + +int ScintillaDocument_LineEndPosition(ScintillaDocument* self, int pos) { + return self->line_end_position(static_cast(pos)); +} + +int ScintillaDocument_Length(ScintillaDocument* self) { + return self->length(); +} + +int ScintillaDocument_LinesTotal(ScintillaDocument* self) { + return self->lines_total(); +} + +void ScintillaDocument_StartStyling(ScintillaDocument* self, int position) { + self->start_styling(static_cast(position)); +} + +bool ScintillaDocument_SetStyleFor(ScintillaDocument* self, int length, char style) { + return self->set_style_for(static_cast(length), static_cast(style)); +} + +int ScintillaDocument_GetEndStyled(ScintillaDocument* self) { + return self->get_end_styled(); +} + +void ScintillaDocument_EnsureStyledTo(ScintillaDocument* self, int position) { + self->ensure_styled_to(static_cast(position)); +} + +void ScintillaDocument_SetCurrentIndicator(ScintillaDocument* self, int indic) { + self->set_current_indicator(static_cast(indic)); +} + +void ScintillaDocument_DecorationFillRange(ScintillaDocument* self, int position, int value, int fillLength) { + self->decoration_fill_range(static_cast(position), static_cast(value), static_cast(fillLength)); +} + +int ScintillaDocument_DecorationsValueAt(ScintillaDocument* self, int indic, int position) { + return self->decorations_value_at(static_cast(indic), static_cast(position)); +} + +int ScintillaDocument_DecorationsStart(ScintillaDocument* self, int indic, int position) { + return self->decorations_start(static_cast(indic), static_cast(position)); +} + +int ScintillaDocument_DecorationsEnd(ScintillaDocument* self, int indic, int position) { + return self->decorations_end(static_cast(indic), static_cast(position)); +} + +int ScintillaDocument_GetCodePage(ScintillaDocument* self) { + return self->get_code_page(); +} + +void ScintillaDocument_SetCodePage(ScintillaDocument* self, int code_page) { + self->set_code_page(static_cast(code_page)); +} + +int ScintillaDocument_GetEolMode(ScintillaDocument* self) { + return self->get_eol_mode(); +} + +void ScintillaDocument_SetEolMode(ScintillaDocument* self, int eol_mode) { + self->set_eol_mode(static_cast(eol_mode)); +} + +int ScintillaDocument_MovePositionOutsideChar(ScintillaDocument* self, int pos, int move_dir, bool check_line_end) { + return self->move_position_outside_char(static_cast(pos), static_cast(move_dir), check_line_end); +} + +int ScintillaDocument_GetCharacter(ScintillaDocument* self, int pos) { + return self->get_character(static_cast(pos)); +} + +void ScintillaDocument_ModifyAttempt(ScintillaDocument* self) { + self->modify_attempt(); +} + +void ScintillaDocument_connect_ModifyAttempt(ScintillaDocument* self, intptr_t slot) { + ScintillaDocument::connect(self, static_cast(&ScintillaDocument::modify_attempt), self, [=]() { + miqt_exec_callback_ScintillaDocument_ModifyAttempt(slot); + }); +} + +void ScintillaDocument_SavePoint(ScintillaDocument* self, bool atSavePoint) { + self->save_point(atSavePoint); +} + +void ScintillaDocument_connect_SavePoint(ScintillaDocument* self, intptr_t slot) { + ScintillaDocument::connect(self, static_cast(&ScintillaDocument::save_point), self, [=](bool atSavePoint) { + bool sigval1 = atSavePoint; + miqt_exec_callback_ScintillaDocument_SavePoint(slot, sigval1); + }); +} + +void ScintillaDocument_Modified(ScintillaDocument* self, int position, int modification_type, struct miqt_string text, int length, int linesAdded, int line, int foldLevelNow, int foldLevelPrev) { + QByteArray text_QByteArray(text.data, text.len); + self->modified(static_cast(position), static_cast(modification_type), text_QByteArray, static_cast(length), static_cast(linesAdded), static_cast(line), static_cast(foldLevelNow), static_cast(foldLevelPrev)); +} + +void ScintillaDocument_connect_Modified(ScintillaDocument* self, intptr_t slot) { + ScintillaDocument::connect(self, static_cast(&ScintillaDocument::modified), self, [=](int position, int modification_type, const QByteArray& text, int length, int linesAdded, int line, int foldLevelNow, int foldLevelPrev) { + int sigval1 = position; + int sigval2 = modification_type; + const QByteArray text_qb = text; + struct miqt_string text_ms; + text_ms.len = text_qb.length(); + text_ms.data = static_cast(malloc(text_ms.len)); + memcpy(text_ms.data, text_qb.data(), text_ms.len); + struct miqt_string sigval3 = text_ms; + int sigval4 = length; + int sigval5 = linesAdded; + int sigval6 = line; + int sigval7 = foldLevelNow; + int sigval8 = foldLevelPrev; + miqt_exec_callback_ScintillaDocument_Modified(slot, sigval1, sigval2, sigval3, sigval4, sigval5, sigval6, sigval7, sigval8); + }); +} + +void ScintillaDocument_StyleNeeded(ScintillaDocument* self, int pos) { + self->style_needed(static_cast(pos)); +} + +void ScintillaDocument_connect_StyleNeeded(ScintillaDocument* self, intptr_t slot) { + ScintillaDocument::connect(self, static_cast(&ScintillaDocument::style_needed), self, [=](int pos) { + int sigval1 = pos; + miqt_exec_callback_ScintillaDocument_StyleNeeded(slot, sigval1); + }); +} + +void ScintillaDocument_ErrorOccurred(ScintillaDocument* self, int status) { + self->error_occurred(static_cast(status)); +} + +void ScintillaDocument_connect_ErrorOccurred(ScintillaDocument* self, intptr_t slot) { + ScintillaDocument::connect(self, static_cast(&ScintillaDocument::error_occurred), self, [=](int status) { + int sigval1 = status; + miqt_exec_callback_ScintillaDocument_ErrorOccurred(slot, sigval1); + }); +} + +struct miqt_string ScintillaDocument_Tr2(const char* s, const char* c) { + QString _ret = ScintillaDocument::tr(s, c); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaDocument_Tr3(const char* s, const char* c, int n) { + QString _ret = ScintillaDocument::tr(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaDocument_TrUtf82(const char* s, const char* c) { + QString _ret = ScintillaDocument::trUtf8(s, c); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaDocument_TrUtf83(const char* s, const char* c, int n) { + QString _ret = ScintillaDocument::trUtf8(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +void ScintillaDocument_BeginUndoAction1(ScintillaDocument* self, bool coalesceWithPrior) { + self->begin_undo_action(coalesceWithPrior); +} + +void ScintillaDocument_Delete(ScintillaDocument* self) { + delete self; +} + +ScintillaEdit* ScintillaEdit_new() { + return new ScintillaEdit(); +} + +ScintillaEdit* ScintillaEdit_new2(QWidget* parent) { + return new ScintillaEdit(parent); +} + +QMetaObject* ScintillaEdit_MetaObject(const ScintillaEdit* self) { + return (QMetaObject*) self->metaObject(); +} + +void* ScintillaEdit_Metacast(ScintillaEdit* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string ScintillaEdit_Tr(const char* s) { + QString _ret = ScintillaEdit::tr(s); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_TrUtf8(const char* s) { + QString _ret = ScintillaEdit::trUtf8(s); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_TextReturner(const ScintillaEdit* self, int message, uintptr_t wParam) { + QByteArray _qb = self->TextReturner(static_cast(message), static_cast(wParam)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_GetTextRange(ScintillaEdit* self, int start, int end) { + QByteArray _qb = self->get_text_range(static_cast(start), static_cast(end)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +ScintillaDocument* ScintillaEdit_GetDoc(ScintillaEdit* self) { + return self->get_doc(); +} + +void ScintillaEdit_SetDoc(ScintillaEdit* self, ScintillaDocument* pdoc_) { + self->set_doc(pdoc_); +} + +struct miqt_string ScintillaEdit_TextRange(ScintillaEdit* self, int start, int end) { + QByteArray _qb = self->textRange(static_cast(start), static_cast(end)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +long ScintillaEdit_FormatRange(ScintillaEdit* self, bool draw, QPaintDevice* target, QPaintDevice* measure, QRect* print_rect, QRect* page_rect, long range_start, long range_end) { + return self->format_range(draw, target, measure, *print_rect, *page_rect, static_cast(range_start), static_cast(range_end)); +} + +long ScintillaEdit_FormatRange2(ScintillaEdit* self, bool draw, QPaintDevice* target, QPaintDevice* measure, QRect* print_rect, QRect* page_rect, long range_start, long range_end) { + return self->formatRange(draw, target, measure, *print_rect, *page_rect, static_cast(range_start), static_cast(range_end)); +} + +void ScintillaEdit_AddText(ScintillaEdit* self, intptr_t length, const char* text) { + self->addText(static_cast(length), text); +} + +void ScintillaEdit_AddStyledText(ScintillaEdit* self, intptr_t length, const char* c) { + self->addStyledText(static_cast(length), c); +} + +void ScintillaEdit_InsertText(ScintillaEdit* self, intptr_t pos, const char* text) { + self->insertText(static_cast(pos), text); +} + +void ScintillaEdit_ChangeInsertion(ScintillaEdit* self, intptr_t length, const char* text) { + self->changeInsertion(static_cast(length), text); +} + +void ScintillaEdit_ClearAll(ScintillaEdit* self) { + self->clearAll(); +} + +void ScintillaEdit_DeleteRange(ScintillaEdit* self, intptr_t start, intptr_t lengthDelete) { + self->deleteRange(static_cast(start), static_cast(lengthDelete)); +} + +void ScintillaEdit_ClearDocumentStyle(ScintillaEdit* self) { + self->clearDocumentStyle(); +} + +intptr_t ScintillaEdit_Length(const ScintillaEdit* self) { + sptr_t _ret = self->length(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CharAt(const ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->charAt(static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CurrentPos(const ScintillaEdit* self) { + sptr_t _ret = self->currentPos(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_Anchor(const ScintillaEdit* self) { + sptr_t _ret = self->anchor(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_StyleAt(const ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->styleAt(static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_StyleIndexAt(const ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->styleIndexAt(static_cast(pos)); + return static_cast(_ret); +} + +void ScintillaEdit_Redo(ScintillaEdit* self) { + self->redo(); +} + +void ScintillaEdit_SetUndoCollection(ScintillaEdit* self, bool collectUndo) { + self->setUndoCollection(collectUndo); +} + +void ScintillaEdit_SelectAll(ScintillaEdit* self) { + self->selectAll(); +} + +void ScintillaEdit_SetSavePoint(ScintillaEdit* self) { + self->setSavePoint(); +} + +bool ScintillaEdit_CanRedo(ScintillaEdit* self) { + return self->canRedo(); +} + +intptr_t ScintillaEdit_MarkerLineFromHandle(ScintillaEdit* self, intptr_t markerHandle) { + sptr_t _ret = self->markerLineFromHandle(static_cast(markerHandle)); + return static_cast(_ret); +} + +void ScintillaEdit_MarkerDeleteHandle(ScintillaEdit* self, intptr_t markerHandle) { + self->markerDeleteHandle(static_cast(markerHandle)); +} + +intptr_t ScintillaEdit_MarkerHandleFromLine(ScintillaEdit* self, intptr_t line, intptr_t which) { + sptr_t _ret = self->markerHandleFromLine(static_cast(line), static_cast(which)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_MarkerNumberFromLine(ScintillaEdit* self, intptr_t line, intptr_t which) { + sptr_t _ret = self->markerNumberFromLine(static_cast(line), static_cast(which)); + return static_cast(_ret); +} + +bool ScintillaEdit_UndoCollection(const ScintillaEdit* self) { + return self->undoCollection(); +} + +intptr_t ScintillaEdit_ViewWS(const ScintillaEdit* self) { + sptr_t _ret = self->viewWS(); + return static_cast(_ret); +} + +void ScintillaEdit_SetViewWS(ScintillaEdit* self, intptr_t viewWS) { + self->setViewWS(static_cast(viewWS)); +} + +intptr_t ScintillaEdit_TabDrawMode(const ScintillaEdit* self) { + sptr_t _ret = self->tabDrawMode(); + return static_cast(_ret); +} + +void ScintillaEdit_SetTabDrawMode(ScintillaEdit* self, intptr_t tabDrawMode) { + self->setTabDrawMode(static_cast(tabDrawMode)); +} + +intptr_t ScintillaEdit_PositionFromPoint(ScintillaEdit* self, intptr_t x, intptr_t y) { + sptr_t _ret = self->positionFromPoint(static_cast(x), static_cast(y)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_PositionFromPointClose(ScintillaEdit* self, intptr_t x, intptr_t y) { + sptr_t _ret = self->positionFromPointClose(static_cast(x), static_cast(y)); + return static_cast(_ret); +} + +void ScintillaEdit_GotoLine(ScintillaEdit* self, intptr_t line) { + self->gotoLine(static_cast(line)); +} + +void ScintillaEdit_GotoPos(ScintillaEdit* self, intptr_t caret) { + self->gotoPos(static_cast(caret)); +} + +void ScintillaEdit_SetAnchor(ScintillaEdit* self, intptr_t anchor) { + self->setAnchor(static_cast(anchor)); +} + +struct miqt_string ScintillaEdit_GetCurLine(ScintillaEdit* self, intptr_t length) { + QByteArray _qb = self->getCurLine(static_cast(length)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_EndStyled(const ScintillaEdit* self) { + sptr_t _ret = self->endStyled(); + return static_cast(_ret); +} + +void ScintillaEdit_ConvertEOLs(ScintillaEdit* self, intptr_t eolMode) { + self->convertEOLs(static_cast(eolMode)); +} + +intptr_t ScintillaEdit_EOLMode(const ScintillaEdit* self) { + sptr_t _ret = self->eOLMode(); + return static_cast(_ret); +} + +void ScintillaEdit_SetEOLMode(ScintillaEdit* self, intptr_t eolMode) { + self->setEOLMode(static_cast(eolMode)); +} + +void ScintillaEdit_StartStyling(ScintillaEdit* self, intptr_t start, intptr_t unused) { + self->startStyling(static_cast(start), static_cast(unused)); +} + +void ScintillaEdit_SetStyling(ScintillaEdit* self, intptr_t length, intptr_t style) { + self->setStyling(static_cast(length), static_cast(style)); +} + +bool ScintillaEdit_BufferedDraw(const ScintillaEdit* self) { + return self->bufferedDraw(); +} + +void ScintillaEdit_SetBufferedDraw(ScintillaEdit* self, bool buffered) { + self->setBufferedDraw(buffered); +} + +void ScintillaEdit_SetTabWidth(ScintillaEdit* self, intptr_t tabWidth) { + self->setTabWidth(static_cast(tabWidth)); +} + +intptr_t ScintillaEdit_TabWidth(const ScintillaEdit* self) { + sptr_t _ret = self->tabWidth(); + return static_cast(_ret); +} + +void ScintillaEdit_SetTabMinimumWidth(ScintillaEdit* self, intptr_t pixels) { + self->setTabMinimumWidth(static_cast(pixels)); +} + +intptr_t ScintillaEdit_TabMinimumWidth(const ScintillaEdit* self) { + sptr_t _ret = self->tabMinimumWidth(); + return static_cast(_ret); +} + +void ScintillaEdit_ClearTabStops(ScintillaEdit* self, intptr_t line) { + self->clearTabStops(static_cast(line)); +} + +void ScintillaEdit_AddTabStop(ScintillaEdit* self, intptr_t line, intptr_t x) { + self->addTabStop(static_cast(line), static_cast(x)); +} + +intptr_t ScintillaEdit_GetNextTabStop(ScintillaEdit* self, intptr_t line, intptr_t x) { + sptr_t _ret = self->getNextTabStop(static_cast(line), static_cast(x)); + return static_cast(_ret); +} + +void ScintillaEdit_SetCodePage(ScintillaEdit* self, intptr_t codePage) { + self->setCodePage(static_cast(codePage)); +} + +void ScintillaEdit_SetFontLocale(ScintillaEdit* self, const char* localeName) { + self->setFontLocale(localeName); +} + +struct miqt_string ScintillaEdit_FontLocale(const ScintillaEdit* self) { + QByteArray _qb = self->fontLocale(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_IMEInteraction(const ScintillaEdit* self) { + sptr_t _ret = self->iMEInteraction(); + return static_cast(_ret); +} + +void ScintillaEdit_SetIMEInteraction(ScintillaEdit* self, intptr_t imeInteraction) { + self->setIMEInteraction(static_cast(imeInteraction)); +} + +void ScintillaEdit_MarkerDefine(ScintillaEdit* self, intptr_t markerNumber, intptr_t markerSymbol) { + self->markerDefine(static_cast(markerNumber), static_cast(markerSymbol)); +} + +void ScintillaEdit_MarkerSetFore(ScintillaEdit* self, intptr_t markerNumber, intptr_t fore) { + self->markerSetFore(static_cast(markerNumber), static_cast(fore)); +} + +void ScintillaEdit_MarkerSetBack(ScintillaEdit* self, intptr_t markerNumber, intptr_t back) { + self->markerSetBack(static_cast(markerNumber), static_cast(back)); +} + +void ScintillaEdit_MarkerSetBackSelected(ScintillaEdit* self, intptr_t markerNumber, intptr_t back) { + self->markerSetBackSelected(static_cast(markerNumber), static_cast(back)); +} + +void ScintillaEdit_MarkerSetForeTranslucent(ScintillaEdit* self, intptr_t markerNumber, intptr_t fore) { + self->markerSetForeTranslucent(static_cast(markerNumber), static_cast(fore)); +} + +void ScintillaEdit_MarkerSetBackTranslucent(ScintillaEdit* self, intptr_t markerNumber, intptr_t back) { + self->markerSetBackTranslucent(static_cast(markerNumber), static_cast(back)); +} + +void ScintillaEdit_MarkerSetBackSelectedTranslucent(ScintillaEdit* self, intptr_t markerNumber, intptr_t back) { + self->markerSetBackSelectedTranslucent(static_cast(markerNumber), static_cast(back)); +} + +void ScintillaEdit_MarkerSetStrokeWidth(ScintillaEdit* self, intptr_t markerNumber, intptr_t hundredths) { + self->markerSetStrokeWidth(static_cast(markerNumber), static_cast(hundredths)); +} + +void ScintillaEdit_MarkerEnableHighlight(ScintillaEdit* self, bool enabled) { + self->markerEnableHighlight(enabled); +} + +intptr_t ScintillaEdit_MarkerAdd(ScintillaEdit* self, intptr_t line, intptr_t markerNumber) { + sptr_t _ret = self->markerAdd(static_cast(line), static_cast(markerNumber)); + return static_cast(_ret); +} + +void ScintillaEdit_MarkerDelete(ScintillaEdit* self, intptr_t line, intptr_t markerNumber) { + self->markerDelete(static_cast(line), static_cast(markerNumber)); +} + +void ScintillaEdit_MarkerDeleteAll(ScintillaEdit* self, intptr_t markerNumber) { + self->markerDeleteAll(static_cast(markerNumber)); +} + +intptr_t ScintillaEdit_MarkerGet(ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->markerGet(static_cast(line)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_MarkerNext(ScintillaEdit* self, intptr_t lineStart, intptr_t markerMask) { + sptr_t _ret = self->markerNext(static_cast(lineStart), static_cast(markerMask)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_MarkerPrevious(ScintillaEdit* self, intptr_t lineStart, intptr_t markerMask) { + sptr_t _ret = self->markerPrevious(static_cast(lineStart), static_cast(markerMask)); + return static_cast(_ret); +} + +void ScintillaEdit_MarkerDefinePixmap(ScintillaEdit* self, intptr_t markerNumber, const char* pixmap) { + self->markerDefinePixmap(static_cast(markerNumber), pixmap); +} + +void ScintillaEdit_MarkerAddSet(ScintillaEdit* self, intptr_t line, intptr_t markerSet) { + self->markerAddSet(static_cast(line), static_cast(markerSet)); +} + +void ScintillaEdit_MarkerSetAlpha(ScintillaEdit* self, intptr_t markerNumber, intptr_t alpha) { + self->markerSetAlpha(static_cast(markerNumber), static_cast(alpha)); +} + +intptr_t ScintillaEdit_MarkerLayer(const ScintillaEdit* self, intptr_t markerNumber) { + sptr_t _ret = self->markerLayer(static_cast(markerNumber)); + return static_cast(_ret); +} + +void ScintillaEdit_MarkerSetLayer(ScintillaEdit* self, intptr_t markerNumber, intptr_t layer) { + self->markerSetLayer(static_cast(markerNumber), static_cast(layer)); +} + +void ScintillaEdit_SetMarginTypeN(ScintillaEdit* self, intptr_t margin, intptr_t marginType) { + self->setMarginTypeN(static_cast(margin), static_cast(marginType)); +} + +intptr_t ScintillaEdit_MarginTypeN(const ScintillaEdit* self, intptr_t margin) { + sptr_t _ret = self->marginTypeN(static_cast(margin)); + return static_cast(_ret); +} + +void ScintillaEdit_SetMarginWidthN(ScintillaEdit* self, intptr_t margin, intptr_t pixelWidth) { + self->setMarginWidthN(static_cast(margin), static_cast(pixelWidth)); +} + +intptr_t ScintillaEdit_MarginWidthN(const ScintillaEdit* self, intptr_t margin) { + sptr_t _ret = self->marginWidthN(static_cast(margin)); + return static_cast(_ret); +} + +void ScintillaEdit_SetMarginMaskN(ScintillaEdit* self, intptr_t margin, intptr_t mask) { + self->setMarginMaskN(static_cast(margin), static_cast(mask)); +} + +intptr_t ScintillaEdit_MarginMaskN(const ScintillaEdit* self, intptr_t margin) { + sptr_t _ret = self->marginMaskN(static_cast(margin)); + return static_cast(_ret); +} + +void ScintillaEdit_SetMarginSensitiveN(ScintillaEdit* self, intptr_t margin, bool sensitive) { + self->setMarginSensitiveN(static_cast(margin), sensitive); +} + +bool ScintillaEdit_MarginSensitiveN(const ScintillaEdit* self, intptr_t margin) { + return self->marginSensitiveN(static_cast(margin)); +} + +void ScintillaEdit_SetMarginCursorN(ScintillaEdit* self, intptr_t margin, intptr_t cursor) { + self->setMarginCursorN(static_cast(margin), static_cast(cursor)); +} + +intptr_t ScintillaEdit_MarginCursorN(const ScintillaEdit* self, intptr_t margin) { + sptr_t _ret = self->marginCursorN(static_cast(margin)); + return static_cast(_ret); +} + +void ScintillaEdit_SetMarginBackN(ScintillaEdit* self, intptr_t margin, intptr_t back) { + self->setMarginBackN(static_cast(margin), static_cast(back)); +} + +intptr_t ScintillaEdit_MarginBackN(const ScintillaEdit* self, intptr_t margin) { + sptr_t _ret = self->marginBackN(static_cast(margin)); + return static_cast(_ret); +} + +void ScintillaEdit_SetMargins(ScintillaEdit* self, intptr_t margins) { + self->setMargins(static_cast(margins)); +} + +intptr_t ScintillaEdit_Margins(const ScintillaEdit* self) { + sptr_t _ret = self->margins(); + return static_cast(_ret); +} + +void ScintillaEdit_StyleClearAll(ScintillaEdit* self) { + self->styleClearAll(); +} + +void ScintillaEdit_StyleSetFore(ScintillaEdit* self, intptr_t style, intptr_t fore) { + self->styleSetFore(static_cast(style), static_cast(fore)); +} + +void ScintillaEdit_StyleSetBack(ScintillaEdit* self, intptr_t style, intptr_t back) { + self->styleSetBack(static_cast(style), static_cast(back)); +} + +void ScintillaEdit_StyleSetBold(ScintillaEdit* self, intptr_t style, bool bold) { + self->styleSetBold(static_cast(style), bold); +} + +void ScintillaEdit_StyleSetItalic(ScintillaEdit* self, intptr_t style, bool italic) { + self->styleSetItalic(static_cast(style), italic); +} + +void ScintillaEdit_StyleSetSize(ScintillaEdit* self, intptr_t style, intptr_t sizePoints) { + self->styleSetSize(static_cast(style), static_cast(sizePoints)); +} + +void ScintillaEdit_StyleSetFont(ScintillaEdit* self, intptr_t style, const char* fontName) { + self->styleSetFont(static_cast(style), fontName); +} + +void ScintillaEdit_StyleSetEOLFilled(ScintillaEdit* self, intptr_t style, bool eolFilled) { + self->styleSetEOLFilled(static_cast(style), eolFilled); +} + +void ScintillaEdit_StyleResetDefault(ScintillaEdit* self) { + self->styleResetDefault(); +} + +void ScintillaEdit_StyleSetUnderline(ScintillaEdit* self, intptr_t style, bool underline) { + self->styleSetUnderline(static_cast(style), underline); +} + +intptr_t ScintillaEdit_StyleFore(const ScintillaEdit* self, intptr_t style) { + sptr_t _ret = self->styleFore(static_cast(style)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_StyleBack(const ScintillaEdit* self, intptr_t style) { + sptr_t _ret = self->styleBack(static_cast(style)); + return static_cast(_ret); +} + +bool ScintillaEdit_StyleBold(const ScintillaEdit* self, intptr_t style) { + return self->styleBold(static_cast(style)); +} + +bool ScintillaEdit_StyleItalic(const ScintillaEdit* self, intptr_t style) { + return self->styleItalic(static_cast(style)); +} + +intptr_t ScintillaEdit_StyleSize(const ScintillaEdit* self, intptr_t style) { + sptr_t _ret = self->styleSize(static_cast(style)); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_StyleFont(const ScintillaEdit* self, intptr_t style) { + QByteArray _qb = self->styleFont(static_cast(style)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +bool ScintillaEdit_StyleEOLFilled(const ScintillaEdit* self, intptr_t style) { + return self->styleEOLFilled(static_cast(style)); +} + +bool ScintillaEdit_StyleUnderline(const ScintillaEdit* self, intptr_t style) { + return self->styleUnderline(static_cast(style)); +} + +intptr_t ScintillaEdit_StyleCase(const ScintillaEdit* self, intptr_t style) { + sptr_t _ret = self->styleCase(static_cast(style)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_StyleCharacterSet(const ScintillaEdit* self, intptr_t style) { + sptr_t _ret = self->styleCharacterSet(static_cast(style)); + return static_cast(_ret); +} + +bool ScintillaEdit_StyleVisible(const ScintillaEdit* self, intptr_t style) { + return self->styleVisible(static_cast(style)); +} + +bool ScintillaEdit_StyleChangeable(const ScintillaEdit* self, intptr_t style) { + return self->styleChangeable(static_cast(style)); +} + +bool ScintillaEdit_StyleHotSpot(const ScintillaEdit* self, intptr_t style) { + return self->styleHotSpot(static_cast(style)); +} + +void ScintillaEdit_StyleSetCase(ScintillaEdit* self, intptr_t style, intptr_t caseVisible) { + self->styleSetCase(static_cast(style), static_cast(caseVisible)); +} + +void ScintillaEdit_StyleSetSizeFractional(ScintillaEdit* self, intptr_t style, intptr_t sizeHundredthPoints) { + self->styleSetSizeFractional(static_cast(style), static_cast(sizeHundredthPoints)); +} + +intptr_t ScintillaEdit_StyleSizeFractional(const ScintillaEdit* self, intptr_t style) { + sptr_t _ret = self->styleSizeFractional(static_cast(style)); + return static_cast(_ret); +} + +void ScintillaEdit_StyleSetWeight(ScintillaEdit* self, intptr_t style, intptr_t weight) { + self->styleSetWeight(static_cast(style), static_cast(weight)); +} + +intptr_t ScintillaEdit_StyleWeight(const ScintillaEdit* self, intptr_t style) { + sptr_t _ret = self->styleWeight(static_cast(style)); + return static_cast(_ret); +} + +void ScintillaEdit_StyleSetCharacterSet(ScintillaEdit* self, intptr_t style, intptr_t characterSet) { + self->styleSetCharacterSet(static_cast(style), static_cast(characterSet)); +} + +void ScintillaEdit_StyleSetHotSpot(ScintillaEdit* self, intptr_t style, bool hotspot) { + self->styleSetHotSpot(static_cast(style), hotspot); +} + +void ScintillaEdit_StyleSetCheckMonospaced(ScintillaEdit* self, intptr_t style, bool checkMonospaced) { + self->styleSetCheckMonospaced(static_cast(style), checkMonospaced); +} + +bool ScintillaEdit_StyleCheckMonospaced(const ScintillaEdit* self, intptr_t style) { + return self->styleCheckMonospaced(static_cast(style)); +} + +void ScintillaEdit_StyleSetStretch(ScintillaEdit* self, intptr_t style, intptr_t stretch) { + self->styleSetStretch(static_cast(style), static_cast(stretch)); +} + +intptr_t ScintillaEdit_StyleStretch(const ScintillaEdit* self, intptr_t style) { + sptr_t _ret = self->styleStretch(static_cast(style)); + return static_cast(_ret); +} + +void ScintillaEdit_StyleSetInvisibleRepresentation(ScintillaEdit* self, intptr_t style, const char* representation) { + self->styleSetInvisibleRepresentation(static_cast(style), representation); +} + +struct miqt_string ScintillaEdit_StyleInvisibleRepresentation(const ScintillaEdit* self, intptr_t style) { + QByteArray _qb = self->styleInvisibleRepresentation(static_cast(style)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_SetElementColour(ScintillaEdit* self, intptr_t element, intptr_t colourElement) { + self->setElementColour(static_cast(element), static_cast(colourElement)); +} + +intptr_t ScintillaEdit_ElementColour(const ScintillaEdit* self, intptr_t element) { + sptr_t _ret = self->elementColour(static_cast(element)); + return static_cast(_ret); +} + +void ScintillaEdit_ResetElementColour(ScintillaEdit* self, intptr_t element) { + self->resetElementColour(static_cast(element)); +} + +bool ScintillaEdit_ElementIsSet(const ScintillaEdit* self, intptr_t element) { + return self->elementIsSet(static_cast(element)); +} + +bool ScintillaEdit_ElementAllowsTranslucent(const ScintillaEdit* self, intptr_t element) { + return self->elementAllowsTranslucent(static_cast(element)); +} + +intptr_t ScintillaEdit_ElementBaseColour(const ScintillaEdit* self, intptr_t element) { + sptr_t _ret = self->elementBaseColour(static_cast(element)); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelFore(ScintillaEdit* self, bool useSetting, intptr_t fore) { + self->setSelFore(useSetting, static_cast(fore)); +} + +void ScintillaEdit_SetSelBack(ScintillaEdit* self, bool useSetting, intptr_t back) { + self->setSelBack(useSetting, static_cast(back)); +} + +intptr_t ScintillaEdit_SelAlpha(const ScintillaEdit* self) { + sptr_t _ret = self->selAlpha(); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelAlpha(ScintillaEdit* self, intptr_t alpha) { + self->setSelAlpha(static_cast(alpha)); +} + +bool ScintillaEdit_SelEOLFilled(const ScintillaEdit* self) { + return self->selEOLFilled(); +} + +void ScintillaEdit_SetSelEOLFilled(ScintillaEdit* self, bool filled) { + self->setSelEOLFilled(filled); +} + +intptr_t ScintillaEdit_SelectionLayer(const ScintillaEdit* self) { + sptr_t _ret = self->selectionLayer(); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelectionLayer(ScintillaEdit* self, intptr_t layer) { + self->setSelectionLayer(static_cast(layer)); +} + +intptr_t ScintillaEdit_CaretLineLayer(const ScintillaEdit* self) { + sptr_t _ret = self->caretLineLayer(); + return static_cast(_ret); +} + +void ScintillaEdit_SetCaretLineLayer(ScintillaEdit* self, intptr_t layer) { + self->setCaretLineLayer(static_cast(layer)); +} + +bool ScintillaEdit_CaretLineHighlightSubLine(const ScintillaEdit* self) { + return self->caretLineHighlightSubLine(); +} + +void ScintillaEdit_SetCaretLineHighlightSubLine(ScintillaEdit* self, bool subLine) { + self->setCaretLineHighlightSubLine(subLine); +} + +void ScintillaEdit_SetCaretFore(ScintillaEdit* self, intptr_t fore) { + self->setCaretFore(static_cast(fore)); +} + +void ScintillaEdit_AssignCmdKey(ScintillaEdit* self, intptr_t keyDefinition, intptr_t sciCommand) { + self->assignCmdKey(static_cast(keyDefinition), static_cast(sciCommand)); +} + +void ScintillaEdit_ClearCmdKey(ScintillaEdit* self, intptr_t keyDefinition) { + self->clearCmdKey(static_cast(keyDefinition)); +} + +void ScintillaEdit_ClearAllCmdKeys(ScintillaEdit* self) { + self->clearAllCmdKeys(); +} + +void ScintillaEdit_SetStylingEx(ScintillaEdit* self, intptr_t length, const char* styles) { + self->setStylingEx(static_cast(length), styles); +} + +void ScintillaEdit_StyleSetVisible(ScintillaEdit* self, intptr_t style, bool visible) { + self->styleSetVisible(static_cast(style), visible); +} + +intptr_t ScintillaEdit_CaretPeriod(const ScintillaEdit* self) { + sptr_t _ret = self->caretPeriod(); + return static_cast(_ret); +} + +void ScintillaEdit_SetCaretPeriod(ScintillaEdit* self, intptr_t periodMilliseconds) { + self->setCaretPeriod(static_cast(periodMilliseconds)); +} + +void ScintillaEdit_SetWordChars(ScintillaEdit* self, const char* characters) { + self->setWordChars(characters); +} + +struct miqt_string ScintillaEdit_WordChars(const ScintillaEdit* self) { + QByteArray _qb = self->wordChars(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_SetCharacterCategoryOptimization(ScintillaEdit* self, intptr_t countCharacters) { + self->setCharacterCategoryOptimization(static_cast(countCharacters)); +} + +intptr_t ScintillaEdit_CharacterCategoryOptimization(const ScintillaEdit* self) { + sptr_t _ret = self->characterCategoryOptimization(); + return static_cast(_ret); +} + +void ScintillaEdit_BeginUndoAction(ScintillaEdit* self) { + self->beginUndoAction(); +} + +void ScintillaEdit_EndUndoAction(ScintillaEdit* self) { + self->endUndoAction(); +} + +intptr_t ScintillaEdit_UndoSequence(const ScintillaEdit* self) { + sptr_t _ret = self->undoSequence(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_UndoActions(const ScintillaEdit* self) { + sptr_t _ret = self->undoActions(); + return static_cast(_ret); +} + +void ScintillaEdit_SetUndoSavePoint(ScintillaEdit* self, intptr_t action) { + self->setUndoSavePoint(static_cast(action)); +} + +intptr_t ScintillaEdit_UndoSavePoint(const ScintillaEdit* self) { + sptr_t _ret = self->undoSavePoint(); + return static_cast(_ret); +} + +void ScintillaEdit_SetUndoDetach(ScintillaEdit* self, intptr_t action) { + self->setUndoDetach(static_cast(action)); +} + +intptr_t ScintillaEdit_UndoDetach(const ScintillaEdit* self) { + sptr_t _ret = self->undoDetach(); + return static_cast(_ret); +} + +void ScintillaEdit_SetUndoTentative(ScintillaEdit* self, intptr_t action) { + self->setUndoTentative(static_cast(action)); +} + +intptr_t ScintillaEdit_UndoTentative(const ScintillaEdit* self) { + sptr_t _ret = self->undoTentative(); + return static_cast(_ret); +} + +void ScintillaEdit_SetUndoCurrent(ScintillaEdit* self, intptr_t action) { + self->setUndoCurrent(static_cast(action)); +} + +intptr_t ScintillaEdit_UndoCurrent(const ScintillaEdit* self) { + sptr_t _ret = self->undoCurrent(); + return static_cast(_ret); +} + +void ScintillaEdit_PushUndoActionType(ScintillaEdit* self, intptr_t typeVal, intptr_t pos) { + self->pushUndoActionType(static_cast(typeVal), static_cast(pos)); +} + +void ScintillaEdit_ChangeLastUndoActionText(ScintillaEdit* self, intptr_t length, const char* text) { + self->changeLastUndoActionText(static_cast(length), text); +} + +intptr_t ScintillaEdit_UndoActionType(const ScintillaEdit* self, intptr_t action) { + sptr_t _ret = self->undoActionType(static_cast(action)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_UndoActionPosition(const ScintillaEdit* self, intptr_t action) { + sptr_t _ret = self->undoActionPosition(static_cast(action)); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_UndoActionText(const ScintillaEdit* self, intptr_t action) { + QByteArray _qb = self->undoActionText(static_cast(action)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_IndicSetStyle(ScintillaEdit* self, intptr_t indicator, intptr_t indicatorStyle) { + self->indicSetStyle(static_cast(indicator), static_cast(indicatorStyle)); +} + +intptr_t ScintillaEdit_IndicStyle(const ScintillaEdit* self, intptr_t indicator) { + sptr_t _ret = self->indicStyle(static_cast(indicator)); + return static_cast(_ret); +} + +void ScintillaEdit_IndicSetFore(ScintillaEdit* self, intptr_t indicator, intptr_t fore) { + self->indicSetFore(static_cast(indicator), static_cast(fore)); +} + +intptr_t ScintillaEdit_IndicFore(const ScintillaEdit* self, intptr_t indicator) { + sptr_t _ret = self->indicFore(static_cast(indicator)); + return static_cast(_ret); +} + +void ScintillaEdit_IndicSetUnder(ScintillaEdit* self, intptr_t indicator, bool under) { + self->indicSetUnder(static_cast(indicator), under); +} + +bool ScintillaEdit_IndicUnder(const ScintillaEdit* self, intptr_t indicator) { + return self->indicUnder(static_cast(indicator)); +} + +void ScintillaEdit_IndicSetHoverStyle(ScintillaEdit* self, intptr_t indicator, intptr_t indicatorStyle) { + self->indicSetHoverStyle(static_cast(indicator), static_cast(indicatorStyle)); +} + +intptr_t ScintillaEdit_IndicHoverStyle(const ScintillaEdit* self, intptr_t indicator) { + sptr_t _ret = self->indicHoverStyle(static_cast(indicator)); + return static_cast(_ret); +} + +void ScintillaEdit_IndicSetHoverFore(ScintillaEdit* self, intptr_t indicator, intptr_t fore) { + self->indicSetHoverFore(static_cast(indicator), static_cast(fore)); +} + +intptr_t ScintillaEdit_IndicHoverFore(const ScintillaEdit* self, intptr_t indicator) { + sptr_t _ret = self->indicHoverFore(static_cast(indicator)); + return static_cast(_ret); +} + +void ScintillaEdit_IndicSetFlags(ScintillaEdit* self, intptr_t indicator, intptr_t flags) { + self->indicSetFlags(static_cast(indicator), static_cast(flags)); +} + +intptr_t ScintillaEdit_IndicFlags(const ScintillaEdit* self, intptr_t indicator) { + sptr_t _ret = self->indicFlags(static_cast(indicator)); + return static_cast(_ret); +} + +void ScintillaEdit_IndicSetStrokeWidth(ScintillaEdit* self, intptr_t indicator, intptr_t hundredths) { + self->indicSetStrokeWidth(static_cast(indicator), static_cast(hundredths)); +} + +intptr_t ScintillaEdit_IndicStrokeWidth(const ScintillaEdit* self, intptr_t indicator) { + sptr_t _ret = self->indicStrokeWidth(static_cast(indicator)); + return static_cast(_ret); +} + +void ScintillaEdit_SetWhitespaceFore(ScintillaEdit* self, bool useSetting, intptr_t fore) { + self->setWhitespaceFore(useSetting, static_cast(fore)); +} + +void ScintillaEdit_SetWhitespaceBack(ScintillaEdit* self, bool useSetting, intptr_t back) { + self->setWhitespaceBack(useSetting, static_cast(back)); +} + +void ScintillaEdit_SetWhitespaceSize(ScintillaEdit* self, intptr_t size) { + self->setWhitespaceSize(static_cast(size)); +} + +intptr_t ScintillaEdit_WhitespaceSize(const ScintillaEdit* self) { + sptr_t _ret = self->whitespaceSize(); + return static_cast(_ret); +} + +void ScintillaEdit_SetLineState(ScintillaEdit* self, intptr_t line, intptr_t state) { + self->setLineState(static_cast(line), static_cast(state)); +} + +intptr_t ScintillaEdit_LineState(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->lineState(static_cast(line)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_MaxLineState(const ScintillaEdit* self) { + sptr_t _ret = self->maxLineState(); + return static_cast(_ret); +} + +bool ScintillaEdit_CaretLineVisible(const ScintillaEdit* self) { + return self->caretLineVisible(); +} + +void ScintillaEdit_SetCaretLineVisible(ScintillaEdit* self, bool show) { + self->setCaretLineVisible(show); +} + +intptr_t ScintillaEdit_CaretLineBack(const ScintillaEdit* self) { + sptr_t _ret = self->caretLineBack(); + return static_cast(_ret); +} + +void ScintillaEdit_SetCaretLineBack(ScintillaEdit* self, intptr_t back) { + self->setCaretLineBack(static_cast(back)); +} + +intptr_t ScintillaEdit_CaretLineFrame(const ScintillaEdit* self) { + sptr_t _ret = self->caretLineFrame(); + return static_cast(_ret); +} + +void ScintillaEdit_SetCaretLineFrame(ScintillaEdit* self, intptr_t width) { + self->setCaretLineFrame(static_cast(width)); +} + +void ScintillaEdit_StyleSetChangeable(ScintillaEdit* self, intptr_t style, bool changeable) { + self->styleSetChangeable(static_cast(style), changeable); +} + +void ScintillaEdit_AutoCShow(ScintillaEdit* self, intptr_t lengthEntered, const char* itemList) { + self->autoCShow(static_cast(lengthEntered), itemList); +} + +void ScintillaEdit_AutoCCancel(ScintillaEdit* self) { + self->autoCCancel(); +} + +bool ScintillaEdit_AutoCActive(ScintillaEdit* self) { + return self->autoCActive(); +} + +intptr_t ScintillaEdit_AutoCPosStart(ScintillaEdit* self) { + sptr_t _ret = self->autoCPosStart(); + return static_cast(_ret); +} + +void ScintillaEdit_AutoCComplete(ScintillaEdit* self) { + self->autoCComplete(); +} + +void ScintillaEdit_AutoCStops(ScintillaEdit* self, const char* characterSet) { + self->autoCStops(characterSet); +} + +void ScintillaEdit_AutoCSetSeparator(ScintillaEdit* self, intptr_t separatorCharacter) { + self->autoCSetSeparator(static_cast(separatorCharacter)); +} + +intptr_t ScintillaEdit_AutoCSeparator(const ScintillaEdit* self) { + sptr_t _ret = self->autoCSeparator(); + return static_cast(_ret); +} + +void ScintillaEdit_AutoCSelect(ScintillaEdit* self, const char* selectVal) { + self->autoCSelect(selectVal); +} + +void ScintillaEdit_AutoCSetCancelAtStart(ScintillaEdit* self, bool cancel) { + self->autoCSetCancelAtStart(cancel); +} + +bool ScintillaEdit_AutoCCancelAtStart(const ScintillaEdit* self) { + return self->autoCCancelAtStart(); +} + +void ScintillaEdit_AutoCSetFillUps(ScintillaEdit* self, const char* characterSet) { + self->autoCSetFillUps(characterSet); +} + +void ScintillaEdit_AutoCSetChooseSingle(ScintillaEdit* self, bool chooseSingle) { + self->autoCSetChooseSingle(chooseSingle); +} + +bool ScintillaEdit_AutoCChooseSingle(const ScintillaEdit* self) { + return self->autoCChooseSingle(); +} + +void ScintillaEdit_AutoCSetIgnoreCase(ScintillaEdit* self, bool ignoreCase) { + self->autoCSetIgnoreCase(ignoreCase); +} + +bool ScintillaEdit_AutoCIgnoreCase(const ScintillaEdit* self) { + return self->autoCIgnoreCase(); +} + +void ScintillaEdit_UserListShow(ScintillaEdit* self, intptr_t listType, const char* itemList) { + self->userListShow(static_cast(listType), itemList); +} + +void ScintillaEdit_AutoCSetAutoHide(ScintillaEdit* self, bool autoHide) { + self->autoCSetAutoHide(autoHide); +} + +bool ScintillaEdit_AutoCAutoHide(const ScintillaEdit* self) { + return self->autoCAutoHide(); +} + +void ScintillaEdit_AutoCSetOptions(ScintillaEdit* self, intptr_t options) { + self->autoCSetOptions(static_cast(options)); +} + +intptr_t ScintillaEdit_AutoCOptions(const ScintillaEdit* self) { + sptr_t _ret = self->autoCOptions(); + return static_cast(_ret); +} + +void ScintillaEdit_AutoCSetDropRestOfWord(ScintillaEdit* self, bool dropRestOfWord) { + self->autoCSetDropRestOfWord(dropRestOfWord); +} + +bool ScintillaEdit_AutoCDropRestOfWord(const ScintillaEdit* self) { + return self->autoCDropRestOfWord(); +} + +void ScintillaEdit_RegisterImage(ScintillaEdit* self, intptr_t typeVal, const char* xpmData) { + self->registerImage(static_cast(typeVal), xpmData); +} + +void ScintillaEdit_ClearRegisteredImages(ScintillaEdit* self) { + self->clearRegisteredImages(); +} + +intptr_t ScintillaEdit_AutoCTypeSeparator(const ScintillaEdit* self) { + sptr_t _ret = self->autoCTypeSeparator(); + return static_cast(_ret); +} + +void ScintillaEdit_AutoCSetTypeSeparator(ScintillaEdit* self, intptr_t separatorCharacter) { + self->autoCSetTypeSeparator(static_cast(separatorCharacter)); +} + +void ScintillaEdit_AutoCSetMaxWidth(ScintillaEdit* self, intptr_t characterCount) { + self->autoCSetMaxWidth(static_cast(characterCount)); +} + +intptr_t ScintillaEdit_AutoCMaxWidth(const ScintillaEdit* self) { + sptr_t _ret = self->autoCMaxWidth(); + return static_cast(_ret); +} + +void ScintillaEdit_AutoCSetMaxHeight(ScintillaEdit* self, intptr_t rowCount) { + self->autoCSetMaxHeight(static_cast(rowCount)); +} + +intptr_t ScintillaEdit_AutoCMaxHeight(const ScintillaEdit* self) { + sptr_t _ret = self->autoCMaxHeight(); + return static_cast(_ret); +} + +void ScintillaEdit_AutoCSetStyle(ScintillaEdit* self, intptr_t style) { + self->autoCSetStyle(static_cast(style)); +} + +intptr_t ScintillaEdit_AutoCStyle(const ScintillaEdit* self) { + sptr_t _ret = self->autoCStyle(); + return static_cast(_ret); +} + +void ScintillaEdit_SetIndent(ScintillaEdit* self, intptr_t indentSize) { + self->setIndent(static_cast(indentSize)); +} + +intptr_t ScintillaEdit_Indent(const ScintillaEdit* self) { + sptr_t _ret = self->indent(); + return static_cast(_ret); +} + +void ScintillaEdit_SetUseTabs(ScintillaEdit* self, bool useTabs) { + self->setUseTabs(useTabs); +} + +bool ScintillaEdit_UseTabs(const ScintillaEdit* self) { + return self->useTabs(); +} + +void ScintillaEdit_SetLineIndentation(ScintillaEdit* self, intptr_t line, intptr_t indentation) { + self->setLineIndentation(static_cast(line), static_cast(indentation)); +} + +intptr_t ScintillaEdit_LineIndentation(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->lineIndentation(static_cast(line)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_LineIndentPosition(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->lineIndentPosition(static_cast(line)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_Column(const ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->column(static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CountCharacters(ScintillaEdit* self, intptr_t start, intptr_t end) { + sptr_t _ret = self->countCharacters(static_cast(start), static_cast(end)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CountCodeUnits(ScintillaEdit* self, intptr_t start, intptr_t end) { + sptr_t _ret = self->countCodeUnits(static_cast(start), static_cast(end)); + return static_cast(_ret); +} + +void ScintillaEdit_SetHScrollBar(ScintillaEdit* self, bool visible) { + self->setHScrollBar(visible); +} + +bool ScintillaEdit_HScrollBar(const ScintillaEdit* self) { + return self->hScrollBar(); +} + +void ScintillaEdit_SetIndentationGuides(ScintillaEdit* self, intptr_t indentView) { + self->setIndentationGuides(static_cast(indentView)); +} + +intptr_t ScintillaEdit_IndentationGuides(const ScintillaEdit* self) { + sptr_t _ret = self->indentationGuides(); + return static_cast(_ret); +} + +void ScintillaEdit_SetHighlightGuide(ScintillaEdit* self, intptr_t column) { + self->setHighlightGuide(static_cast(column)); +} + +intptr_t ScintillaEdit_HighlightGuide(const ScintillaEdit* self) { + sptr_t _ret = self->highlightGuide(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_LineEndPosition(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->lineEndPosition(static_cast(line)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CodePage(const ScintillaEdit* self) { + sptr_t _ret = self->codePage(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CaretFore(const ScintillaEdit* self) { + sptr_t _ret = self->caretFore(); + return static_cast(_ret); +} + +bool ScintillaEdit_ReadOnly(const ScintillaEdit* self) { + return self->readOnly(); +} + +void ScintillaEdit_SetCurrentPos(ScintillaEdit* self, intptr_t caret) { + self->setCurrentPos(static_cast(caret)); +} + +void ScintillaEdit_SetSelectionStart(ScintillaEdit* self, intptr_t anchor) { + self->setSelectionStart(static_cast(anchor)); +} + +intptr_t ScintillaEdit_SelectionStart(const ScintillaEdit* self) { + sptr_t _ret = self->selectionStart(); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelectionEnd(ScintillaEdit* self, intptr_t caret) { + self->setSelectionEnd(static_cast(caret)); +} + +intptr_t ScintillaEdit_SelectionEnd(const ScintillaEdit* self) { + sptr_t _ret = self->selectionEnd(); + return static_cast(_ret); +} + +void ScintillaEdit_SetEmptySelection(ScintillaEdit* self, intptr_t caret) { + self->setEmptySelection(static_cast(caret)); +} + +void ScintillaEdit_SetPrintMagnification(ScintillaEdit* self, intptr_t magnification) { + self->setPrintMagnification(static_cast(magnification)); +} + +intptr_t ScintillaEdit_PrintMagnification(const ScintillaEdit* self) { + sptr_t _ret = self->printMagnification(); + return static_cast(_ret); +} + +void ScintillaEdit_SetPrintColourMode(ScintillaEdit* self, intptr_t mode) { + self->setPrintColourMode(static_cast(mode)); +} + +intptr_t ScintillaEdit_PrintColourMode(const ScintillaEdit* self) { + sptr_t _ret = self->printColourMode(); + return static_cast(_ret); +} + +void ScintillaEdit_SetChangeHistory(ScintillaEdit* self, intptr_t changeHistory) { + self->setChangeHistory(static_cast(changeHistory)); +} + +intptr_t ScintillaEdit_ChangeHistory(const ScintillaEdit* self) { + sptr_t _ret = self->changeHistory(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_FirstVisibleLine(const ScintillaEdit* self) { + sptr_t _ret = self->firstVisibleLine(); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_GetLine(ScintillaEdit* self, intptr_t line) { + QByteArray _qb = self->getLine(static_cast(line)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_LineCount(const ScintillaEdit* self) { + sptr_t _ret = self->lineCount(); + return static_cast(_ret); +} + +void ScintillaEdit_AllocateLines(ScintillaEdit* self, intptr_t lines) { + self->allocateLines(static_cast(lines)); +} + +void ScintillaEdit_SetMarginLeft(ScintillaEdit* self, intptr_t pixelWidth) { + self->setMarginLeft(static_cast(pixelWidth)); +} + +intptr_t ScintillaEdit_MarginLeft(const ScintillaEdit* self) { + sptr_t _ret = self->marginLeft(); + return static_cast(_ret); +} + +void ScintillaEdit_SetMarginRight(ScintillaEdit* self, intptr_t pixelWidth) { + self->setMarginRight(static_cast(pixelWidth)); +} + +intptr_t ScintillaEdit_MarginRight(const ScintillaEdit* self) { + sptr_t _ret = self->marginRight(); + return static_cast(_ret); +} + +bool ScintillaEdit_Modify(const ScintillaEdit* self) { + return self->modify(); +} + +void ScintillaEdit_SetSel(ScintillaEdit* self, intptr_t anchor, intptr_t caret) { + self->setSel(static_cast(anchor), static_cast(caret)); +} + +struct miqt_string ScintillaEdit_GetSelText(ScintillaEdit* self) { + QByteArray _qb = self->getSelText(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_HideSelection(ScintillaEdit* self, bool hide) { + self->hideSelection(hide); +} + +bool ScintillaEdit_SelectionHidden(const ScintillaEdit* self) { + return self->selectionHidden(); +} + +intptr_t ScintillaEdit_PointXFromPosition(ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->pointXFromPosition(static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_PointYFromPosition(ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->pointYFromPosition(static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_LineFromPosition(ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->lineFromPosition(static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_PositionFromLine(ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->positionFromLine(static_cast(line)); + return static_cast(_ret); +} + +void ScintillaEdit_LineScroll(ScintillaEdit* self, intptr_t columns, intptr_t lines) { + self->lineScroll(static_cast(columns), static_cast(lines)); +} + +void ScintillaEdit_ScrollCaret(ScintillaEdit* self) { + self->scrollCaret(); +} + +void ScintillaEdit_ScrollRange(ScintillaEdit* self, intptr_t secondary, intptr_t primary) { + self->scrollRange(static_cast(secondary), static_cast(primary)); +} + +void ScintillaEdit_ReplaceSel(ScintillaEdit* self, const char* text) { + self->replaceSel(text); +} + +void ScintillaEdit_SetReadOnly(ScintillaEdit* self, bool readOnly) { + self->setReadOnly(readOnly); +} + +void ScintillaEdit_Null(ScintillaEdit* self) { + self->null(); +} + +bool ScintillaEdit_CanPaste(ScintillaEdit* self) { + return self->canPaste(); +} + +bool ScintillaEdit_CanUndo(ScintillaEdit* self) { + return self->canUndo(); +} + +void ScintillaEdit_EmptyUndoBuffer(ScintillaEdit* self) { + self->emptyUndoBuffer(); +} + +void ScintillaEdit_Undo(ScintillaEdit* self) { + self->undo(); +} + +void ScintillaEdit_Cut(ScintillaEdit* self) { + self->cut(); +} + +void ScintillaEdit_Copy(ScintillaEdit* self) { + self->copy(); +} + +void ScintillaEdit_Paste(ScintillaEdit* self) { + self->paste(); +} + +void ScintillaEdit_Clear(ScintillaEdit* self) { + self->clear(); +} + +void ScintillaEdit_SetText(ScintillaEdit* self, const char* text) { + self->setText(text); +} + +struct miqt_string ScintillaEdit_GetText(ScintillaEdit* self, intptr_t length) { + QByteArray _qb = self->getText(static_cast(length)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_TextLength(const ScintillaEdit* self) { + sptr_t _ret = self->textLength(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_DirectFunction(const ScintillaEdit* self) { + sptr_t _ret = self->directFunction(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_DirectStatusFunction(const ScintillaEdit* self) { + sptr_t _ret = self->directStatusFunction(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_DirectPointer(const ScintillaEdit* self) { + sptr_t _ret = self->directPointer(); + return static_cast(_ret); +} + +void ScintillaEdit_SetOvertype(ScintillaEdit* self, bool overType) { + self->setOvertype(overType); +} + +bool ScintillaEdit_Overtype(const ScintillaEdit* self) { + return self->overtype(); +} + +void ScintillaEdit_SetCaretWidth(ScintillaEdit* self, intptr_t pixelWidth) { + self->setCaretWidth(static_cast(pixelWidth)); +} + +intptr_t ScintillaEdit_CaretWidth(const ScintillaEdit* self) { + sptr_t _ret = self->caretWidth(); + return static_cast(_ret); +} + +void ScintillaEdit_SetTargetStart(ScintillaEdit* self, intptr_t start) { + self->setTargetStart(static_cast(start)); +} + +intptr_t ScintillaEdit_TargetStart(const ScintillaEdit* self) { + sptr_t _ret = self->targetStart(); + return static_cast(_ret); +} + +void ScintillaEdit_SetTargetStartVirtualSpace(ScintillaEdit* self, intptr_t space) { + self->setTargetStartVirtualSpace(static_cast(space)); +} + +intptr_t ScintillaEdit_TargetStartVirtualSpace(const ScintillaEdit* self) { + sptr_t _ret = self->targetStartVirtualSpace(); + return static_cast(_ret); +} + +void ScintillaEdit_SetTargetEnd(ScintillaEdit* self, intptr_t end) { + self->setTargetEnd(static_cast(end)); +} + +intptr_t ScintillaEdit_TargetEnd(const ScintillaEdit* self) { + sptr_t _ret = self->targetEnd(); + return static_cast(_ret); +} + +void ScintillaEdit_SetTargetEndVirtualSpace(ScintillaEdit* self, intptr_t space) { + self->setTargetEndVirtualSpace(static_cast(space)); +} + +intptr_t ScintillaEdit_TargetEndVirtualSpace(const ScintillaEdit* self) { + sptr_t _ret = self->targetEndVirtualSpace(); + return static_cast(_ret); +} + +void ScintillaEdit_SetTargetRange(ScintillaEdit* self, intptr_t start, intptr_t end) { + self->setTargetRange(static_cast(start), static_cast(end)); +} + +struct miqt_string ScintillaEdit_TargetText(const ScintillaEdit* self) { + QByteArray _qb = self->targetText(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_TargetFromSelection(ScintillaEdit* self) { + self->targetFromSelection(); +} + +void ScintillaEdit_TargetWholeDocument(ScintillaEdit* self) { + self->targetWholeDocument(); +} + +intptr_t ScintillaEdit_ReplaceTarget(ScintillaEdit* self, intptr_t length, const char* text) { + sptr_t _ret = self->replaceTarget(static_cast(length), text); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_ReplaceTargetRE(ScintillaEdit* self, intptr_t length, const char* text) { + sptr_t _ret = self->replaceTargetRE(static_cast(length), text); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_ReplaceTargetMinimal(ScintillaEdit* self, intptr_t length, const char* text) { + sptr_t _ret = self->replaceTargetMinimal(static_cast(length), text); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_SearchInTarget(ScintillaEdit* self, intptr_t length, const char* text) { + sptr_t _ret = self->searchInTarget(static_cast(length), text); + return static_cast(_ret); +} + +void ScintillaEdit_SetSearchFlags(ScintillaEdit* self, intptr_t searchFlags) { + self->setSearchFlags(static_cast(searchFlags)); +} + +intptr_t ScintillaEdit_SearchFlags(const ScintillaEdit* self) { + sptr_t _ret = self->searchFlags(); + return static_cast(_ret); +} + +void ScintillaEdit_CallTipShow(ScintillaEdit* self, intptr_t pos, const char* definition) { + self->callTipShow(static_cast(pos), definition); +} + +void ScintillaEdit_CallTipCancel(ScintillaEdit* self) { + self->callTipCancel(); +} + +bool ScintillaEdit_CallTipActive(ScintillaEdit* self) { + return self->callTipActive(); +} + +intptr_t ScintillaEdit_CallTipPosStart(ScintillaEdit* self) { + sptr_t _ret = self->callTipPosStart(); + return static_cast(_ret); +} + +void ScintillaEdit_CallTipSetPosStart(ScintillaEdit* self, intptr_t posStart) { + self->callTipSetPosStart(static_cast(posStart)); +} + +void ScintillaEdit_CallTipSetHlt(ScintillaEdit* self, intptr_t highlightStart, intptr_t highlightEnd) { + self->callTipSetHlt(static_cast(highlightStart), static_cast(highlightEnd)); +} + +void ScintillaEdit_CallTipSetBack(ScintillaEdit* self, intptr_t back) { + self->callTipSetBack(static_cast(back)); +} + +void ScintillaEdit_CallTipSetFore(ScintillaEdit* self, intptr_t fore) { + self->callTipSetFore(static_cast(fore)); +} + +void ScintillaEdit_CallTipSetForeHlt(ScintillaEdit* self, intptr_t fore) { + self->callTipSetForeHlt(static_cast(fore)); +} + +void ScintillaEdit_CallTipUseStyle(ScintillaEdit* self, intptr_t tabSize) { + self->callTipUseStyle(static_cast(tabSize)); +} + +void ScintillaEdit_CallTipSetPosition(ScintillaEdit* self, bool above) { + self->callTipSetPosition(above); +} + +intptr_t ScintillaEdit_VisibleFromDocLine(ScintillaEdit* self, intptr_t docLine) { + sptr_t _ret = self->visibleFromDocLine(static_cast(docLine)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_DocLineFromVisible(ScintillaEdit* self, intptr_t displayLine) { + sptr_t _ret = self->docLineFromVisible(static_cast(displayLine)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_WrapCount(ScintillaEdit* self, intptr_t docLine) { + sptr_t _ret = self->wrapCount(static_cast(docLine)); + return static_cast(_ret); +} + +void ScintillaEdit_SetFoldLevel(ScintillaEdit* self, intptr_t line, intptr_t level) { + self->setFoldLevel(static_cast(line), static_cast(level)); +} + +intptr_t ScintillaEdit_FoldLevel(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->foldLevel(static_cast(line)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_LastChild(const ScintillaEdit* self, intptr_t line, intptr_t level) { + sptr_t _ret = self->lastChild(static_cast(line), static_cast(level)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_FoldParent(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->foldParent(static_cast(line)); + return static_cast(_ret); +} + +void ScintillaEdit_ShowLines(ScintillaEdit* self, intptr_t lineStart, intptr_t lineEnd) { + self->showLines(static_cast(lineStart), static_cast(lineEnd)); +} + +void ScintillaEdit_HideLines(ScintillaEdit* self, intptr_t lineStart, intptr_t lineEnd) { + self->hideLines(static_cast(lineStart), static_cast(lineEnd)); +} + +bool ScintillaEdit_LineVisible(const ScintillaEdit* self, intptr_t line) { + return self->lineVisible(static_cast(line)); +} + +bool ScintillaEdit_AllLinesVisible(const ScintillaEdit* self) { + return self->allLinesVisible(); +} + +void ScintillaEdit_SetFoldExpanded(ScintillaEdit* self, intptr_t line, bool expanded) { + self->setFoldExpanded(static_cast(line), expanded); +} + +bool ScintillaEdit_FoldExpanded(const ScintillaEdit* self, intptr_t line) { + return self->foldExpanded(static_cast(line)); +} + +void ScintillaEdit_ToggleFold(ScintillaEdit* self, intptr_t line) { + self->toggleFold(static_cast(line)); +} + +void ScintillaEdit_ToggleFoldShowText(ScintillaEdit* self, intptr_t line, const char* text) { + self->toggleFoldShowText(static_cast(line), text); +} + +void ScintillaEdit_FoldDisplayTextSetStyle(ScintillaEdit* self, intptr_t style) { + self->foldDisplayTextSetStyle(static_cast(style)); +} + +intptr_t ScintillaEdit_FoldDisplayTextStyle(const ScintillaEdit* self) { + sptr_t _ret = self->foldDisplayTextStyle(); + return static_cast(_ret); +} + +void ScintillaEdit_SetDefaultFoldDisplayText(ScintillaEdit* self, const char* text) { + self->setDefaultFoldDisplayText(text); +} + +struct miqt_string ScintillaEdit_GetDefaultFoldDisplayText(ScintillaEdit* self) { + QByteArray _qb = self->getDefaultFoldDisplayText(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_FoldLine(ScintillaEdit* self, intptr_t line, intptr_t action) { + self->foldLine(static_cast(line), static_cast(action)); +} + +void ScintillaEdit_FoldChildren(ScintillaEdit* self, intptr_t line, intptr_t action) { + self->foldChildren(static_cast(line), static_cast(action)); +} + +void ScintillaEdit_ExpandChildren(ScintillaEdit* self, intptr_t line, intptr_t level) { + self->expandChildren(static_cast(line), static_cast(level)); +} + +void ScintillaEdit_FoldAll(ScintillaEdit* self, intptr_t action) { + self->foldAll(static_cast(action)); +} + +void ScintillaEdit_EnsureVisible(ScintillaEdit* self, intptr_t line) { + self->ensureVisible(static_cast(line)); +} + +void ScintillaEdit_SetAutomaticFold(ScintillaEdit* self, intptr_t automaticFold) { + self->setAutomaticFold(static_cast(automaticFold)); +} + +intptr_t ScintillaEdit_AutomaticFold(const ScintillaEdit* self) { + sptr_t _ret = self->automaticFold(); + return static_cast(_ret); +} + +void ScintillaEdit_SetFoldFlags(ScintillaEdit* self, intptr_t flags) { + self->setFoldFlags(static_cast(flags)); +} + +void ScintillaEdit_EnsureVisibleEnforcePolicy(ScintillaEdit* self, intptr_t line) { + self->ensureVisibleEnforcePolicy(static_cast(line)); +} + +void ScintillaEdit_SetTabIndents(ScintillaEdit* self, bool tabIndents) { + self->setTabIndents(tabIndents); +} + +bool ScintillaEdit_TabIndents(const ScintillaEdit* self) { + return self->tabIndents(); +} + +void ScintillaEdit_SetBackSpaceUnIndents(ScintillaEdit* self, bool bsUnIndents) { + self->setBackSpaceUnIndents(bsUnIndents); +} + +bool ScintillaEdit_BackSpaceUnIndents(const ScintillaEdit* self) { + return self->backSpaceUnIndents(); +} + +void ScintillaEdit_SetMouseDwellTime(ScintillaEdit* self, intptr_t periodMilliseconds) { + self->setMouseDwellTime(static_cast(periodMilliseconds)); +} + +intptr_t ScintillaEdit_MouseDwellTime(const ScintillaEdit* self) { + sptr_t _ret = self->mouseDwellTime(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_WordStartPosition(ScintillaEdit* self, intptr_t pos, bool onlyWordCharacters) { + sptr_t _ret = self->wordStartPosition(static_cast(pos), onlyWordCharacters); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_WordEndPosition(ScintillaEdit* self, intptr_t pos, bool onlyWordCharacters) { + sptr_t _ret = self->wordEndPosition(static_cast(pos), onlyWordCharacters); + return static_cast(_ret); +} + +bool ScintillaEdit_IsRangeWord(ScintillaEdit* self, intptr_t start, intptr_t end) { + return self->isRangeWord(static_cast(start), static_cast(end)); +} + +void ScintillaEdit_SetIdleStyling(ScintillaEdit* self, intptr_t idleStyling) { + self->setIdleStyling(static_cast(idleStyling)); +} + +intptr_t ScintillaEdit_IdleStyling(const ScintillaEdit* self) { + sptr_t _ret = self->idleStyling(); + return static_cast(_ret); +} + +void ScintillaEdit_SetWrapMode(ScintillaEdit* self, intptr_t wrapMode) { + self->setWrapMode(static_cast(wrapMode)); +} + +intptr_t ScintillaEdit_WrapMode(const ScintillaEdit* self) { + sptr_t _ret = self->wrapMode(); + return static_cast(_ret); +} + +void ScintillaEdit_SetWrapVisualFlags(ScintillaEdit* self, intptr_t wrapVisualFlags) { + self->setWrapVisualFlags(static_cast(wrapVisualFlags)); +} + +intptr_t ScintillaEdit_WrapVisualFlags(const ScintillaEdit* self) { + sptr_t _ret = self->wrapVisualFlags(); + return static_cast(_ret); +} + +void ScintillaEdit_SetWrapVisualFlagsLocation(ScintillaEdit* self, intptr_t wrapVisualFlagsLocation) { + self->setWrapVisualFlagsLocation(static_cast(wrapVisualFlagsLocation)); +} + +intptr_t ScintillaEdit_WrapVisualFlagsLocation(const ScintillaEdit* self) { + sptr_t _ret = self->wrapVisualFlagsLocation(); + return static_cast(_ret); +} + +void ScintillaEdit_SetWrapStartIndent(ScintillaEdit* self, intptr_t indent) { + self->setWrapStartIndent(static_cast(indent)); +} + +intptr_t ScintillaEdit_WrapStartIndent(const ScintillaEdit* self) { + sptr_t _ret = self->wrapStartIndent(); + return static_cast(_ret); +} + +void ScintillaEdit_SetWrapIndentMode(ScintillaEdit* self, intptr_t wrapIndentMode) { + self->setWrapIndentMode(static_cast(wrapIndentMode)); +} + +intptr_t ScintillaEdit_WrapIndentMode(const ScintillaEdit* self) { + sptr_t _ret = self->wrapIndentMode(); + return static_cast(_ret); +} + +void ScintillaEdit_SetLayoutCache(ScintillaEdit* self, intptr_t cacheMode) { + self->setLayoutCache(static_cast(cacheMode)); +} + +intptr_t ScintillaEdit_LayoutCache(const ScintillaEdit* self) { + sptr_t _ret = self->layoutCache(); + return static_cast(_ret); +} + +void ScintillaEdit_SetScrollWidth(ScintillaEdit* self, intptr_t pixelWidth) { + self->setScrollWidth(static_cast(pixelWidth)); +} + +intptr_t ScintillaEdit_ScrollWidth(const ScintillaEdit* self) { + sptr_t _ret = self->scrollWidth(); + return static_cast(_ret); +} + +void ScintillaEdit_SetScrollWidthTracking(ScintillaEdit* self, bool tracking) { + self->setScrollWidthTracking(tracking); +} + +bool ScintillaEdit_ScrollWidthTracking(const ScintillaEdit* self) { + return self->scrollWidthTracking(); +} + +intptr_t ScintillaEdit_TextWidth(ScintillaEdit* self, intptr_t style, const char* text) { + sptr_t _ret = self->textWidth(static_cast(style), text); + return static_cast(_ret); +} + +void ScintillaEdit_SetEndAtLastLine(ScintillaEdit* self, bool endAtLastLine) { + self->setEndAtLastLine(endAtLastLine); +} + +bool ScintillaEdit_EndAtLastLine(const ScintillaEdit* self) { + return self->endAtLastLine(); +} + +intptr_t ScintillaEdit_TextHeight(ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->textHeight(static_cast(line)); + return static_cast(_ret); +} + +void ScintillaEdit_SetVScrollBar(ScintillaEdit* self, bool visible) { + self->setVScrollBar(visible); +} + +bool ScintillaEdit_VScrollBar(const ScintillaEdit* self) { + return self->vScrollBar(); +} + +void ScintillaEdit_AppendText(ScintillaEdit* self, intptr_t length, const char* text) { + self->appendText(static_cast(length), text); +} + +intptr_t ScintillaEdit_PhasesDraw(const ScintillaEdit* self) { + sptr_t _ret = self->phasesDraw(); + return static_cast(_ret); +} + +void ScintillaEdit_SetPhasesDraw(ScintillaEdit* self, intptr_t phases) { + self->setPhasesDraw(static_cast(phases)); +} + +void ScintillaEdit_SetFontQuality(ScintillaEdit* self, intptr_t fontQuality) { + self->setFontQuality(static_cast(fontQuality)); +} + +intptr_t ScintillaEdit_FontQuality(const ScintillaEdit* self) { + sptr_t _ret = self->fontQuality(); + return static_cast(_ret); +} + +void ScintillaEdit_SetFirstVisibleLine(ScintillaEdit* self, intptr_t displayLine) { + self->setFirstVisibleLine(static_cast(displayLine)); +} + +void ScintillaEdit_SetMultiPaste(ScintillaEdit* self, intptr_t multiPaste) { + self->setMultiPaste(static_cast(multiPaste)); +} + +intptr_t ScintillaEdit_MultiPaste(const ScintillaEdit* self) { + sptr_t _ret = self->multiPaste(); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_Tag(const ScintillaEdit* self, intptr_t tagNumber) { + QByteArray _qb = self->tag(static_cast(tagNumber)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_LinesJoin(ScintillaEdit* self) { + self->linesJoin(); +} + +void ScintillaEdit_LinesSplit(ScintillaEdit* self, intptr_t pixelWidth) { + self->linesSplit(static_cast(pixelWidth)); +} + +void ScintillaEdit_SetFoldMarginColour(ScintillaEdit* self, bool useSetting, intptr_t back) { + self->setFoldMarginColour(useSetting, static_cast(back)); +} + +void ScintillaEdit_SetFoldMarginHiColour(ScintillaEdit* self, bool useSetting, intptr_t fore) { + self->setFoldMarginHiColour(useSetting, static_cast(fore)); +} + +void ScintillaEdit_SetAccessibility(ScintillaEdit* self, intptr_t accessibility) { + self->setAccessibility(static_cast(accessibility)); +} + +intptr_t ScintillaEdit_Accessibility(const ScintillaEdit* self) { + sptr_t _ret = self->accessibility(); + return static_cast(_ret); +} + +void ScintillaEdit_LineDown(ScintillaEdit* self) { + self->lineDown(); +} + +void ScintillaEdit_LineDownExtend(ScintillaEdit* self) { + self->lineDownExtend(); +} + +void ScintillaEdit_LineUp(ScintillaEdit* self) { + self->lineUp(); +} + +void ScintillaEdit_LineUpExtend(ScintillaEdit* self) { + self->lineUpExtend(); +} + +void ScintillaEdit_CharLeft(ScintillaEdit* self) { + self->charLeft(); +} + +void ScintillaEdit_CharLeftExtend(ScintillaEdit* self) { + self->charLeftExtend(); +} + +void ScintillaEdit_CharRight(ScintillaEdit* self) { + self->charRight(); +} + +void ScintillaEdit_CharRightExtend(ScintillaEdit* self) { + self->charRightExtend(); +} + +void ScintillaEdit_WordLeft(ScintillaEdit* self) { + self->wordLeft(); +} + +void ScintillaEdit_WordLeftExtend(ScintillaEdit* self) { + self->wordLeftExtend(); +} + +void ScintillaEdit_WordRight(ScintillaEdit* self) { + self->wordRight(); +} + +void ScintillaEdit_WordRightExtend(ScintillaEdit* self) { + self->wordRightExtend(); +} + +void ScintillaEdit_Home(ScintillaEdit* self) { + self->home(); +} + +void ScintillaEdit_HomeExtend(ScintillaEdit* self) { + self->homeExtend(); +} + +void ScintillaEdit_LineEnd(ScintillaEdit* self) { + self->lineEnd(); +} + +void ScintillaEdit_LineEndExtend(ScintillaEdit* self) { + self->lineEndExtend(); +} + +void ScintillaEdit_DocumentStart(ScintillaEdit* self) { + self->documentStart(); +} + +void ScintillaEdit_DocumentStartExtend(ScintillaEdit* self) { + self->documentStartExtend(); +} + +void ScintillaEdit_DocumentEnd(ScintillaEdit* self) { + self->documentEnd(); +} + +void ScintillaEdit_DocumentEndExtend(ScintillaEdit* self) { + self->documentEndExtend(); +} + +void ScintillaEdit_PageUp(ScintillaEdit* self) { + self->pageUp(); +} + +void ScintillaEdit_PageUpExtend(ScintillaEdit* self) { + self->pageUpExtend(); +} + +void ScintillaEdit_PageDown(ScintillaEdit* self) { + self->pageDown(); +} + +void ScintillaEdit_PageDownExtend(ScintillaEdit* self) { + self->pageDownExtend(); +} + +void ScintillaEdit_EditToggleOvertype(ScintillaEdit* self) { + self->editToggleOvertype(); +} + +void ScintillaEdit_Cancel(ScintillaEdit* self) { + self->cancel(); +} + +void ScintillaEdit_DeleteBack(ScintillaEdit* self) { + self->deleteBack(); +} + +void ScintillaEdit_Tab(ScintillaEdit* self) { + self->tab(); +} + +void ScintillaEdit_LineIndent(ScintillaEdit* self) { + self->lineIndent(); +} + +void ScintillaEdit_BackTab(ScintillaEdit* self) { + self->backTab(); +} + +void ScintillaEdit_LineDedent(ScintillaEdit* self) { + self->lineDedent(); +} + +void ScintillaEdit_NewLine(ScintillaEdit* self) { + self->newLine(); +} + +void ScintillaEdit_FormFeed(ScintillaEdit* self) { + self->formFeed(); +} + +void ScintillaEdit_VCHome(ScintillaEdit* self) { + self->vCHome(); +} + +void ScintillaEdit_VCHomeExtend(ScintillaEdit* self) { + self->vCHomeExtend(); +} + +void ScintillaEdit_ZoomIn(ScintillaEdit* self) { + self->zoomIn(); +} + +void ScintillaEdit_ZoomOut(ScintillaEdit* self) { + self->zoomOut(); +} + +void ScintillaEdit_DelWordLeft(ScintillaEdit* self) { + self->delWordLeft(); +} + +void ScintillaEdit_DelWordRight(ScintillaEdit* self) { + self->delWordRight(); +} + +void ScintillaEdit_DelWordRightEnd(ScintillaEdit* self) { + self->delWordRightEnd(); +} + +void ScintillaEdit_LineCut(ScintillaEdit* self) { + self->lineCut(); +} + +void ScintillaEdit_LineDelete(ScintillaEdit* self) { + self->lineDelete(); +} + +void ScintillaEdit_LineTranspose(ScintillaEdit* self) { + self->lineTranspose(); +} + +void ScintillaEdit_LineReverse(ScintillaEdit* self) { + self->lineReverse(); +} + +void ScintillaEdit_LineDuplicate(ScintillaEdit* self) { + self->lineDuplicate(); +} + +void ScintillaEdit_LowerCase(ScintillaEdit* self) { + self->lowerCase(); +} + +void ScintillaEdit_UpperCase(ScintillaEdit* self) { + self->upperCase(); +} + +void ScintillaEdit_LineScrollDown(ScintillaEdit* self) { + self->lineScrollDown(); +} + +void ScintillaEdit_LineScrollUp(ScintillaEdit* self) { + self->lineScrollUp(); +} + +void ScintillaEdit_DeleteBackNotLine(ScintillaEdit* self) { + self->deleteBackNotLine(); +} + +void ScintillaEdit_HomeDisplay(ScintillaEdit* self) { + self->homeDisplay(); +} + +void ScintillaEdit_HomeDisplayExtend(ScintillaEdit* self) { + self->homeDisplayExtend(); +} + +void ScintillaEdit_LineEndDisplay(ScintillaEdit* self) { + self->lineEndDisplay(); +} + +void ScintillaEdit_LineEndDisplayExtend(ScintillaEdit* self) { + self->lineEndDisplayExtend(); +} + +void ScintillaEdit_HomeWrap(ScintillaEdit* self) { + self->homeWrap(); +} + +void ScintillaEdit_HomeWrapExtend(ScintillaEdit* self) { + self->homeWrapExtend(); +} + +void ScintillaEdit_LineEndWrap(ScintillaEdit* self) { + self->lineEndWrap(); +} + +void ScintillaEdit_LineEndWrapExtend(ScintillaEdit* self) { + self->lineEndWrapExtend(); +} + +void ScintillaEdit_VCHomeWrap(ScintillaEdit* self) { + self->vCHomeWrap(); +} + +void ScintillaEdit_VCHomeWrapExtend(ScintillaEdit* self) { + self->vCHomeWrapExtend(); +} + +void ScintillaEdit_LineCopy(ScintillaEdit* self) { + self->lineCopy(); +} + +void ScintillaEdit_MoveCaretInsideView(ScintillaEdit* self) { + self->moveCaretInsideView(); +} + +intptr_t ScintillaEdit_LineLength(ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->lineLength(static_cast(line)); + return static_cast(_ret); +} + +void ScintillaEdit_BraceHighlight(ScintillaEdit* self, intptr_t posA, intptr_t posB) { + self->braceHighlight(static_cast(posA), static_cast(posB)); +} + +void ScintillaEdit_BraceHighlightIndicator(ScintillaEdit* self, bool useSetting, intptr_t indicator) { + self->braceHighlightIndicator(useSetting, static_cast(indicator)); +} + +void ScintillaEdit_BraceBadLight(ScintillaEdit* self, intptr_t pos) { + self->braceBadLight(static_cast(pos)); +} + +void ScintillaEdit_BraceBadLightIndicator(ScintillaEdit* self, bool useSetting, intptr_t indicator) { + self->braceBadLightIndicator(useSetting, static_cast(indicator)); +} + +intptr_t ScintillaEdit_BraceMatch(ScintillaEdit* self, intptr_t pos, intptr_t maxReStyle) { + sptr_t _ret = self->braceMatch(static_cast(pos), static_cast(maxReStyle)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_BraceMatchNext(ScintillaEdit* self, intptr_t pos, intptr_t startPos) { + sptr_t _ret = self->braceMatchNext(static_cast(pos), static_cast(startPos)); + return static_cast(_ret); +} + +bool ScintillaEdit_ViewEOL(const ScintillaEdit* self) { + return self->viewEOL(); +} + +void ScintillaEdit_SetViewEOL(ScintillaEdit* self, bool visible) { + self->setViewEOL(visible); +} + +intptr_t ScintillaEdit_DocPointer(const ScintillaEdit* self) { + sptr_t _ret = self->docPointer(); + return static_cast(_ret); +} + +void ScintillaEdit_SetDocPointer(ScintillaEdit* self, intptr_t doc) { + self->setDocPointer(static_cast(doc)); +} + +void ScintillaEdit_SetModEventMask(ScintillaEdit* self, intptr_t eventMask) { + self->setModEventMask(static_cast(eventMask)); +} + +intptr_t ScintillaEdit_EdgeColumn(const ScintillaEdit* self) { + sptr_t _ret = self->edgeColumn(); + return static_cast(_ret); +} + +void ScintillaEdit_SetEdgeColumn(ScintillaEdit* self, intptr_t column) { + self->setEdgeColumn(static_cast(column)); +} + +intptr_t ScintillaEdit_EdgeMode(const ScintillaEdit* self) { + sptr_t _ret = self->edgeMode(); + return static_cast(_ret); +} + +void ScintillaEdit_SetEdgeMode(ScintillaEdit* self, intptr_t edgeMode) { + self->setEdgeMode(static_cast(edgeMode)); +} + +intptr_t ScintillaEdit_EdgeColour(const ScintillaEdit* self) { + sptr_t _ret = self->edgeColour(); + return static_cast(_ret); +} + +void ScintillaEdit_SetEdgeColour(ScintillaEdit* self, intptr_t edgeColour) { + self->setEdgeColour(static_cast(edgeColour)); +} + +void ScintillaEdit_MultiEdgeAddLine(ScintillaEdit* self, intptr_t column, intptr_t edgeColour) { + self->multiEdgeAddLine(static_cast(column), static_cast(edgeColour)); +} + +void ScintillaEdit_MultiEdgeClearAll(ScintillaEdit* self) { + self->multiEdgeClearAll(); +} + +intptr_t ScintillaEdit_MultiEdgeColumn(const ScintillaEdit* self, intptr_t which) { + sptr_t _ret = self->multiEdgeColumn(static_cast(which)); + return static_cast(_ret); +} + +void ScintillaEdit_SearchAnchor(ScintillaEdit* self) { + self->searchAnchor(); +} + +intptr_t ScintillaEdit_SearchNext(ScintillaEdit* self, intptr_t searchFlags, const char* text) { + sptr_t _ret = self->searchNext(static_cast(searchFlags), text); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_SearchPrev(ScintillaEdit* self, intptr_t searchFlags, const char* text) { + sptr_t _ret = self->searchPrev(static_cast(searchFlags), text); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_LinesOnScreen(const ScintillaEdit* self) { + sptr_t _ret = self->linesOnScreen(); + return static_cast(_ret); +} + +void ScintillaEdit_UsePopUp(ScintillaEdit* self, intptr_t popUpMode) { + self->usePopUp(static_cast(popUpMode)); +} + +bool ScintillaEdit_SelectionIsRectangle(const ScintillaEdit* self) { + return self->selectionIsRectangle(); +} + +void ScintillaEdit_SetZoom(ScintillaEdit* self, intptr_t zoomInPoints) { + self->setZoom(static_cast(zoomInPoints)); +} + +intptr_t ScintillaEdit_Zoom(const ScintillaEdit* self) { + sptr_t _ret = self->zoom(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CreateDocument(ScintillaEdit* self, intptr_t bytes, intptr_t documentOptions) { + sptr_t _ret = self->createDocument(static_cast(bytes), static_cast(documentOptions)); + return static_cast(_ret); +} + +void ScintillaEdit_AddRefDocument(ScintillaEdit* self, intptr_t doc) { + self->addRefDocument(static_cast(doc)); +} + +void ScintillaEdit_ReleaseDocument(ScintillaEdit* self, intptr_t doc) { + self->releaseDocument(static_cast(doc)); +} + +intptr_t ScintillaEdit_DocumentOptions(const ScintillaEdit* self) { + sptr_t _ret = self->documentOptions(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_ModEventMask(const ScintillaEdit* self) { + sptr_t _ret = self->modEventMask(); + return static_cast(_ret); +} + +void ScintillaEdit_SetCommandEvents(ScintillaEdit* self, bool commandEvents) { + self->setCommandEvents(commandEvents); +} + +bool ScintillaEdit_CommandEvents(const ScintillaEdit* self) { + return self->commandEvents(); +} + +void ScintillaEdit_SetFocus(ScintillaEdit* self, bool focus) { + self->setFocus(focus); +} + +bool ScintillaEdit_Focus(const ScintillaEdit* self) { + return self->focus(); +} + +void ScintillaEdit_SetStatus(ScintillaEdit* self, intptr_t status) { + self->setStatus(static_cast(status)); +} + +intptr_t ScintillaEdit_Status(const ScintillaEdit* self) { + sptr_t _ret = self->status(); + return static_cast(_ret); +} + +void ScintillaEdit_SetMouseDownCaptures(ScintillaEdit* self, bool captures) { + self->setMouseDownCaptures(captures); +} + +bool ScintillaEdit_MouseDownCaptures(const ScintillaEdit* self) { + return self->mouseDownCaptures(); +} + +void ScintillaEdit_SetMouseWheelCaptures(ScintillaEdit* self, bool captures) { + self->setMouseWheelCaptures(captures); +} + +bool ScintillaEdit_MouseWheelCaptures(const ScintillaEdit* self) { + return self->mouseWheelCaptures(); +} + +void ScintillaEdit_SetCursor(ScintillaEdit* self, intptr_t cursorType) { + self->setCursor(static_cast(cursorType)); +} + +intptr_t ScintillaEdit_Cursor(const ScintillaEdit* self) { + sptr_t _ret = self->cursor(); + return static_cast(_ret); +} + +void ScintillaEdit_SetControlCharSymbol(ScintillaEdit* self, intptr_t symbol) { + self->setControlCharSymbol(static_cast(symbol)); +} + +intptr_t ScintillaEdit_ControlCharSymbol(const ScintillaEdit* self) { + sptr_t _ret = self->controlCharSymbol(); + return static_cast(_ret); +} + +void ScintillaEdit_WordPartLeft(ScintillaEdit* self) { + self->wordPartLeft(); +} + +void ScintillaEdit_WordPartLeftExtend(ScintillaEdit* self) { + self->wordPartLeftExtend(); +} + +void ScintillaEdit_WordPartRight(ScintillaEdit* self) { + self->wordPartRight(); +} + +void ScintillaEdit_WordPartRightExtend(ScintillaEdit* self) { + self->wordPartRightExtend(); +} + +void ScintillaEdit_SetVisiblePolicy(ScintillaEdit* self, intptr_t visiblePolicy, intptr_t visibleSlop) { + self->setVisiblePolicy(static_cast(visiblePolicy), static_cast(visibleSlop)); +} + +void ScintillaEdit_DelLineLeft(ScintillaEdit* self) { + self->delLineLeft(); +} + +void ScintillaEdit_DelLineRight(ScintillaEdit* self) { + self->delLineRight(); +} + +void ScintillaEdit_SetXOffset(ScintillaEdit* self, intptr_t xOffset) { + self->setXOffset(static_cast(xOffset)); +} + +intptr_t ScintillaEdit_XOffset(const ScintillaEdit* self) { + sptr_t _ret = self->xOffset(); + return static_cast(_ret); +} + +void ScintillaEdit_ChooseCaretX(ScintillaEdit* self) { + self->chooseCaretX(); +} + +void ScintillaEdit_GrabFocus(ScintillaEdit* self) { + self->grabFocus(); +} + +void ScintillaEdit_SetXCaretPolicy(ScintillaEdit* self, intptr_t caretPolicy, intptr_t caretSlop) { + self->setXCaretPolicy(static_cast(caretPolicy), static_cast(caretSlop)); +} + +void ScintillaEdit_SetYCaretPolicy(ScintillaEdit* self, intptr_t caretPolicy, intptr_t caretSlop) { + self->setYCaretPolicy(static_cast(caretPolicy), static_cast(caretSlop)); +} + +void ScintillaEdit_SetPrintWrapMode(ScintillaEdit* self, intptr_t wrapMode) { + self->setPrintWrapMode(static_cast(wrapMode)); +} + +intptr_t ScintillaEdit_PrintWrapMode(const ScintillaEdit* self) { + sptr_t _ret = self->printWrapMode(); + return static_cast(_ret); +} + +void ScintillaEdit_SetHotspotActiveFore(ScintillaEdit* self, bool useSetting, intptr_t fore) { + self->setHotspotActiveFore(useSetting, static_cast(fore)); +} + +intptr_t ScintillaEdit_HotspotActiveFore(const ScintillaEdit* self) { + sptr_t _ret = self->hotspotActiveFore(); + return static_cast(_ret); +} + +void ScintillaEdit_SetHotspotActiveBack(ScintillaEdit* self, bool useSetting, intptr_t back) { + self->setHotspotActiveBack(useSetting, static_cast(back)); +} + +intptr_t ScintillaEdit_HotspotActiveBack(const ScintillaEdit* self) { + sptr_t _ret = self->hotspotActiveBack(); + return static_cast(_ret); +} + +void ScintillaEdit_SetHotspotActiveUnderline(ScintillaEdit* self, bool underline) { + self->setHotspotActiveUnderline(underline); +} + +bool ScintillaEdit_HotspotActiveUnderline(const ScintillaEdit* self) { + return self->hotspotActiveUnderline(); +} + +void ScintillaEdit_SetHotspotSingleLine(ScintillaEdit* self, bool singleLine) { + self->setHotspotSingleLine(singleLine); +} + +bool ScintillaEdit_HotspotSingleLine(const ScintillaEdit* self) { + return self->hotspotSingleLine(); +} + +void ScintillaEdit_ParaDown(ScintillaEdit* self) { + self->paraDown(); +} + +void ScintillaEdit_ParaDownExtend(ScintillaEdit* self) { + self->paraDownExtend(); +} + +void ScintillaEdit_ParaUp(ScintillaEdit* self) { + self->paraUp(); +} + +void ScintillaEdit_ParaUpExtend(ScintillaEdit* self) { + self->paraUpExtend(); +} + +intptr_t ScintillaEdit_PositionBefore(ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->positionBefore(static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_PositionAfter(ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->positionAfter(static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_PositionRelative(ScintillaEdit* self, intptr_t pos, intptr_t relative) { + sptr_t _ret = self->positionRelative(static_cast(pos), static_cast(relative)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_PositionRelativeCodeUnits(ScintillaEdit* self, intptr_t pos, intptr_t relative) { + sptr_t _ret = self->positionRelativeCodeUnits(static_cast(pos), static_cast(relative)); + return static_cast(_ret); +} + +void ScintillaEdit_CopyRange(ScintillaEdit* self, intptr_t start, intptr_t end) { + self->copyRange(static_cast(start), static_cast(end)); +} + +void ScintillaEdit_CopyText(ScintillaEdit* self, intptr_t length, const char* text) { + self->copyText(static_cast(length), text); +} + +void ScintillaEdit_SetSelectionMode(ScintillaEdit* self, intptr_t selectionMode) { + self->setSelectionMode(static_cast(selectionMode)); +} + +void ScintillaEdit_ChangeSelectionMode(ScintillaEdit* self, intptr_t selectionMode) { + self->changeSelectionMode(static_cast(selectionMode)); +} + +intptr_t ScintillaEdit_SelectionMode(const ScintillaEdit* self) { + sptr_t _ret = self->selectionMode(); + return static_cast(_ret); +} + +void ScintillaEdit_SetMoveExtendsSelection(ScintillaEdit* self, bool moveExtendsSelection) { + self->setMoveExtendsSelection(moveExtendsSelection); +} + +bool ScintillaEdit_MoveExtendsSelection(const ScintillaEdit* self) { + return self->moveExtendsSelection(); +} + +intptr_t ScintillaEdit_GetLineSelStartPosition(ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->getLineSelStartPosition(static_cast(line)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_GetLineSelEndPosition(ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->getLineSelEndPosition(static_cast(line)); + return static_cast(_ret); +} + +void ScintillaEdit_LineDownRectExtend(ScintillaEdit* self) { + self->lineDownRectExtend(); +} + +void ScintillaEdit_LineUpRectExtend(ScintillaEdit* self) { + self->lineUpRectExtend(); +} + +void ScintillaEdit_CharLeftRectExtend(ScintillaEdit* self) { + self->charLeftRectExtend(); +} + +void ScintillaEdit_CharRightRectExtend(ScintillaEdit* self) { + self->charRightRectExtend(); +} + +void ScintillaEdit_HomeRectExtend(ScintillaEdit* self) { + self->homeRectExtend(); +} + +void ScintillaEdit_VCHomeRectExtend(ScintillaEdit* self) { + self->vCHomeRectExtend(); +} + +void ScintillaEdit_LineEndRectExtend(ScintillaEdit* self) { + self->lineEndRectExtend(); +} + +void ScintillaEdit_PageUpRectExtend(ScintillaEdit* self) { + self->pageUpRectExtend(); +} + +void ScintillaEdit_PageDownRectExtend(ScintillaEdit* self) { + self->pageDownRectExtend(); +} + +void ScintillaEdit_StutteredPageUp(ScintillaEdit* self) { + self->stutteredPageUp(); +} + +void ScintillaEdit_StutteredPageUpExtend(ScintillaEdit* self) { + self->stutteredPageUpExtend(); +} + +void ScintillaEdit_StutteredPageDown(ScintillaEdit* self) { + self->stutteredPageDown(); +} + +void ScintillaEdit_StutteredPageDownExtend(ScintillaEdit* self) { + self->stutteredPageDownExtend(); +} + +void ScintillaEdit_WordLeftEnd(ScintillaEdit* self) { + self->wordLeftEnd(); +} + +void ScintillaEdit_WordLeftEndExtend(ScintillaEdit* self) { + self->wordLeftEndExtend(); +} + +void ScintillaEdit_WordRightEnd(ScintillaEdit* self) { + self->wordRightEnd(); +} + +void ScintillaEdit_WordRightEndExtend(ScintillaEdit* self) { + self->wordRightEndExtend(); +} + +void ScintillaEdit_SetWhitespaceChars(ScintillaEdit* self, const char* characters) { + self->setWhitespaceChars(characters); +} + +struct miqt_string ScintillaEdit_WhitespaceChars(const ScintillaEdit* self) { + QByteArray _qb = self->whitespaceChars(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_SetPunctuationChars(ScintillaEdit* self, const char* characters) { + self->setPunctuationChars(characters); +} + +struct miqt_string ScintillaEdit_PunctuationChars(const ScintillaEdit* self) { + QByteArray _qb = self->punctuationChars(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_SetCharsDefault(ScintillaEdit* self) { + self->setCharsDefault(); +} + +intptr_t ScintillaEdit_AutoCCurrent(const ScintillaEdit* self) { + sptr_t _ret = self->autoCCurrent(); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_AutoCCurrentText(const ScintillaEdit* self) { + QByteArray _qb = self->autoCCurrentText(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_AutoCSetCaseInsensitiveBehaviour(ScintillaEdit* self, intptr_t behaviour) { + self->autoCSetCaseInsensitiveBehaviour(static_cast(behaviour)); +} + +intptr_t ScintillaEdit_AutoCCaseInsensitiveBehaviour(const ScintillaEdit* self) { + sptr_t _ret = self->autoCCaseInsensitiveBehaviour(); + return static_cast(_ret); +} + +void ScintillaEdit_AutoCSetMulti(ScintillaEdit* self, intptr_t multi) { + self->autoCSetMulti(static_cast(multi)); +} + +intptr_t ScintillaEdit_AutoCMulti(const ScintillaEdit* self) { + sptr_t _ret = self->autoCMulti(); + return static_cast(_ret); +} + +void ScintillaEdit_AutoCSetOrder(ScintillaEdit* self, intptr_t order) { + self->autoCSetOrder(static_cast(order)); +} + +intptr_t ScintillaEdit_AutoCOrder(const ScintillaEdit* self) { + sptr_t _ret = self->autoCOrder(); + return static_cast(_ret); +} + +void ScintillaEdit_Allocate(ScintillaEdit* self, intptr_t bytes) { + self->allocate(static_cast(bytes)); +} + +struct miqt_string ScintillaEdit_TargetAsUTF8(ScintillaEdit* self) { + QByteArray _qb = self->targetAsUTF8(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_SetLengthForEncode(ScintillaEdit* self, intptr_t bytes) { + self->setLengthForEncode(static_cast(bytes)); +} + +struct miqt_string ScintillaEdit_EncodedFromUTF8(ScintillaEdit* self, const char* utf8) { + QByteArray _qb = self->encodedFromUTF8(utf8); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_FindColumn(ScintillaEdit* self, intptr_t line, intptr_t column) { + sptr_t _ret = self->findColumn(static_cast(line), static_cast(column)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CaretSticky(const ScintillaEdit* self) { + sptr_t _ret = self->caretSticky(); + return static_cast(_ret); +} + +void ScintillaEdit_SetCaretSticky(ScintillaEdit* self, intptr_t useCaretStickyBehaviour) { + self->setCaretSticky(static_cast(useCaretStickyBehaviour)); +} + +void ScintillaEdit_ToggleCaretSticky(ScintillaEdit* self) { + self->toggleCaretSticky(); +} + +void ScintillaEdit_SetPasteConvertEndings(ScintillaEdit* self, bool convert) { + self->setPasteConvertEndings(convert); +} + +bool ScintillaEdit_PasteConvertEndings(const ScintillaEdit* self) { + return self->pasteConvertEndings(); +} + +void ScintillaEdit_ReplaceRectangular(ScintillaEdit* self, intptr_t length, const char* text) { + self->replaceRectangular(static_cast(length), text); +} + +void ScintillaEdit_SelectionDuplicate(ScintillaEdit* self) { + self->selectionDuplicate(); +} + +void ScintillaEdit_SetCaretLineBackAlpha(ScintillaEdit* self, intptr_t alpha) { + self->setCaretLineBackAlpha(static_cast(alpha)); +} + +intptr_t ScintillaEdit_CaretLineBackAlpha(const ScintillaEdit* self) { + sptr_t _ret = self->caretLineBackAlpha(); + return static_cast(_ret); +} + +void ScintillaEdit_SetCaretStyle(ScintillaEdit* self, intptr_t caretStyle) { + self->setCaretStyle(static_cast(caretStyle)); +} + +intptr_t ScintillaEdit_CaretStyle(const ScintillaEdit* self) { + sptr_t _ret = self->caretStyle(); + return static_cast(_ret); +} + +void ScintillaEdit_SetIndicatorCurrent(ScintillaEdit* self, intptr_t indicator) { + self->setIndicatorCurrent(static_cast(indicator)); +} + +intptr_t ScintillaEdit_IndicatorCurrent(const ScintillaEdit* self) { + sptr_t _ret = self->indicatorCurrent(); + return static_cast(_ret); +} + +void ScintillaEdit_SetIndicatorValue(ScintillaEdit* self, intptr_t value) { + self->setIndicatorValue(static_cast(value)); +} + +intptr_t ScintillaEdit_IndicatorValue(const ScintillaEdit* self) { + sptr_t _ret = self->indicatorValue(); + return static_cast(_ret); +} + +void ScintillaEdit_IndicatorFillRange(ScintillaEdit* self, intptr_t start, intptr_t lengthFill) { + self->indicatorFillRange(static_cast(start), static_cast(lengthFill)); +} + +void ScintillaEdit_IndicatorClearRange(ScintillaEdit* self, intptr_t start, intptr_t lengthClear) { + self->indicatorClearRange(static_cast(start), static_cast(lengthClear)); +} + +intptr_t ScintillaEdit_IndicatorAllOnFor(ScintillaEdit* self, intptr_t pos) { + sptr_t _ret = self->indicatorAllOnFor(static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_IndicatorValueAt(ScintillaEdit* self, intptr_t indicator, intptr_t pos) { + sptr_t _ret = self->indicatorValueAt(static_cast(indicator), static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_IndicatorStart(ScintillaEdit* self, intptr_t indicator, intptr_t pos) { + sptr_t _ret = self->indicatorStart(static_cast(indicator), static_cast(pos)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_IndicatorEnd(ScintillaEdit* self, intptr_t indicator, intptr_t pos) { + sptr_t _ret = self->indicatorEnd(static_cast(indicator), static_cast(pos)); + return static_cast(_ret); +} + +void ScintillaEdit_SetPositionCache(ScintillaEdit* self, intptr_t size) { + self->setPositionCache(static_cast(size)); +} + +intptr_t ScintillaEdit_PositionCache(const ScintillaEdit* self) { + sptr_t _ret = self->positionCache(); + return static_cast(_ret); +} + +void ScintillaEdit_SetLayoutThreads(ScintillaEdit* self, intptr_t threads) { + self->setLayoutThreads(static_cast(threads)); +} + +intptr_t ScintillaEdit_LayoutThreads(const ScintillaEdit* self) { + sptr_t _ret = self->layoutThreads(); + return static_cast(_ret); +} + +void ScintillaEdit_CopyAllowLine(ScintillaEdit* self) { + self->copyAllowLine(); +} + +void ScintillaEdit_CutAllowLine(ScintillaEdit* self) { + self->cutAllowLine(); +} + +void ScintillaEdit_SetCopySeparator(ScintillaEdit* self, const char* separator) { + self->setCopySeparator(separator); +} + +struct miqt_string ScintillaEdit_CopySeparator(const ScintillaEdit* self) { + QByteArray _qb = self->copySeparator(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_CharacterPointer(const ScintillaEdit* self) { + sptr_t _ret = self->characterPointer(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_RangePointer(const ScintillaEdit* self, intptr_t start, intptr_t lengthRange) { + sptr_t _ret = self->rangePointer(static_cast(start), static_cast(lengthRange)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_GapPosition(const ScintillaEdit* self) { + sptr_t _ret = self->gapPosition(); + return static_cast(_ret); +} + +void ScintillaEdit_IndicSetAlpha(ScintillaEdit* self, intptr_t indicator, intptr_t alpha) { + self->indicSetAlpha(static_cast(indicator), static_cast(alpha)); +} + +intptr_t ScintillaEdit_IndicAlpha(const ScintillaEdit* self, intptr_t indicator) { + sptr_t _ret = self->indicAlpha(static_cast(indicator)); + return static_cast(_ret); +} + +void ScintillaEdit_IndicSetOutlineAlpha(ScintillaEdit* self, intptr_t indicator, intptr_t alpha) { + self->indicSetOutlineAlpha(static_cast(indicator), static_cast(alpha)); +} + +intptr_t ScintillaEdit_IndicOutlineAlpha(const ScintillaEdit* self, intptr_t indicator) { + sptr_t _ret = self->indicOutlineAlpha(static_cast(indicator)); + return static_cast(_ret); +} + +void ScintillaEdit_SetExtraAscent(ScintillaEdit* self, intptr_t extraAscent) { + self->setExtraAscent(static_cast(extraAscent)); +} + +intptr_t ScintillaEdit_ExtraAscent(const ScintillaEdit* self) { + sptr_t _ret = self->extraAscent(); + return static_cast(_ret); +} + +void ScintillaEdit_SetExtraDescent(ScintillaEdit* self, intptr_t extraDescent) { + self->setExtraDescent(static_cast(extraDescent)); +} + +intptr_t ScintillaEdit_ExtraDescent(const ScintillaEdit* self) { + sptr_t _ret = self->extraDescent(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_MarkerSymbolDefined(ScintillaEdit* self, intptr_t markerNumber) { + sptr_t _ret = self->markerSymbolDefined(static_cast(markerNumber)); + return static_cast(_ret); +} + +void ScintillaEdit_MarginSetText(ScintillaEdit* self, intptr_t line, const char* text) { + self->marginSetText(static_cast(line), text); +} + +struct miqt_string ScintillaEdit_MarginText(const ScintillaEdit* self, intptr_t line) { + QByteArray _qb = self->marginText(static_cast(line)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_MarginSetStyle(ScintillaEdit* self, intptr_t line, intptr_t style) { + self->marginSetStyle(static_cast(line), static_cast(style)); +} + +intptr_t ScintillaEdit_MarginStyle(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->marginStyle(static_cast(line)); + return static_cast(_ret); +} + +void ScintillaEdit_MarginSetStyles(ScintillaEdit* self, intptr_t line, const char* styles) { + self->marginSetStyles(static_cast(line), styles); +} + +struct miqt_string ScintillaEdit_MarginStyles(const ScintillaEdit* self, intptr_t line) { + QByteArray _qb = self->marginStyles(static_cast(line)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_MarginTextClearAll(ScintillaEdit* self) { + self->marginTextClearAll(); +} + +void ScintillaEdit_MarginSetStyleOffset(ScintillaEdit* self, intptr_t style) { + self->marginSetStyleOffset(static_cast(style)); +} + +intptr_t ScintillaEdit_MarginStyleOffset(const ScintillaEdit* self) { + sptr_t _ret = self->marginStyleOffset(); + return static_cast(_ret); +} + +void ScintillaEdit_SetMarginOptions(ScintillaEdit* self, intptr_t marginOptions) { + self->setMarginOptions(static_cast(marginOptions)); +} + +intptr_t ScintillaEdit_MarginOptions(const ScintillaEdit* self) { + sptr_t _ret = self->marginOptions(); + return static_cast(_ret); +} + +void ScintillaEdit_AnnotationSetText(ScintillaEdit* self, intptr_t line, const char* text) { + self->annotationSetText(static_cast(line), text); +} + +struct miqt_string ScintillaEdit_AnnotationText(const ScintillaEdit* self, intptr_t line) { + QByteArray _qb = self->annotationText(static_cast(line)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_AnnotationSetStyle(ScintillaEdit* self, intptr_t line, intptr_t style) { + self->annotationSetStyle(static_cast(line), static_cast(style)); +} + +intptr_t ScintillaEdit_AnnotationStyle(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->annotationStyle(static_cast(line)); + return static_cast(_ret); +} + +void ScintillaEdit_AnnotationSetStyles(ScintillaEdit* self, intptr_t line, const char* styles) { + self->annotationSetStyles(static_cast(line), styles); +} + +struct miqt_string ScintillaEdit_AnnotationStyles(const ScintillaEdit* self, intptr_t line) { + QByteArray _qb = self->annotationStyles(static_cast(line)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_AnnotationLines(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->annotationLines(static_cast(line)); + return static_cast(_ret); +} + +void ScintillaEdit_AnnotationClearAll(ScintillaEdit* self) { + self->annotationClearAll(); +} + +void ScintillaEdit_AnnotationSetVisible(ScintillaEdit* self, intptr_t visible) { + self->annotationSetVisible(static_cast(visible)); +} + +intptr_t ScintillaEdit_AnnotationVisible(const ScintillaEdit* self) { + sptr_t _ret = self->annotationVisible(); + return static_cast(_ret); +} + +void ScintillaEdit_AnnotationSetStyleOffset(ScintillaEdit* self, intptr_t style) { + self->annotationSetStyleOffset(static_cast(style)); +} + +intptr_t ScintillaEdit_AnnotationStyleOffset(const ScintillaEdit* self) { + sptr_t _ret = self->annotationStyleOffset(); + return static_cast(_ret); +} + +void ScintillaEdit_ReleaseAllExtendedStyles(ScintillaEdit* self) { + self->releaseAllExtendedStyles(); +} + +intptr_t ScintillaEdit_AllocateExtendedStyles(ScintillaEdit* self, intptr_t numberStyles) { + sptr_t _ret = self->allocateExtendedStyles(static_cast(numberStyles)); + return static_cast(_ret); +} + +void ScintillaEdit_AddUndoAction(ScintillaEdit* self, intptr_t token, intptr_t flags) { + self->addUndoAction(static_cast(token), static_cast(flags)); +} + +intptr_t ScintillaEdit_CharPositionFromPoint(ScintillaEdit* self, intptr_t x, intptr_t y) { + sptr_t _ret = self->charPositionFromPoint(static_cast(x), static_cast(y)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CharPositionFromPointClose(ScintillaEdit* self, intptr_t x, intptr_t y) { + sptr_t _ret = self->charPositionFromPointClose(static_cast(x), static_cast(y)); + return static_cast(_ret); +} + +void ScintillaEdit_SetMouseSelectionRectangularSwitch(ScintillaEdit* self, bool mouseSelectionRectangularSwitch) { + self->setMouseSelectionRectangularSwitch(mouseSelectionRectangularSwitch); +} + +bool ScintillaEdit_MouseSelectionRectangularSwitch(const ScintillaEdit* self) { + return self->mouseSelectionRectangularSwitch(); +} + +void ScintillaEdit_SetMultipleSelection(ScintillaEdit* self, bool multipleSelection) { + self->setMultipleSelection(multipleSelection); +} + +bool ScintillaEdit_MultipleSelection(const ScintillaEdit* self) { + return self->multipleSelection(); +} + +void ScintillaEdit_SetAdditionalSelectionTyping(ScintillaEdit* self, bool additionalSelectionTyping) { + self->setAdditionalSelectionTyping(additionalSelectionTyping); +} + +bool ScintillaEdit_AdditionalSelectionTyping(const ScintillaEdit* self) { + return self->additionalSelectionTyping(); +} + +void ScintillaEdit_SetAdditionalCaretsBlink(ScintillaEdit* self, bool additionalCaretsBlink) { + self->setAdditionalCaretsBlink(additionalCaretsBlink); +} + +bool ScintillaEdit_AdditionalCaretsBlink(const ScintillaEdit* self) { + return self->additionalCaretsBlink(); +} + +void ScintillaEdit_SetAdditionalCaretsVisible(ScintillaEdit* self, bool additionalCaretsVisible) { + self->setAdditionalCaretsVisible(additionalCaretsVisible); +} + +bool ScintillaEdit_AdditionalCaretsVisible(const ScintillaEdit* self) { + return self->additionalCaretsVisible(); +} + +intptr_t ScintillaEdit_Selections(const ScintillaEdit* self) { + sptr_t _ret = self->selections(); + return static_cast(_ret); +} + +bool ScintillaEdit_SelectionEmpty(const ScintillaEdit* self) { + return self->selectionEmpty(); +} + +void ScintillaEdit_ClearSelections(ScintillaEdit* self) { + self->clearSelections(); +} + +void ScintillaEdit_SetSelection(ScintillaEdit* self, intptr_t caret, intptr_t anchor) { + self->setSelection(static_cast(caret), static_cast(anchor)); +} + +void ScintillaEdit_AddSelection(ScintillaEdit* self, intptr_t caret, intptr_t anchor) { + self->addSelection(static_cast(caret), static_cast(anchor)); +} + +intptr_t ScintillaEdit_SelectionFromPoint(ScintillaEdit* self, intptr_t x, intptr_t y) { + sptr_t _ret = self->selectionFromPoint(static_cast(x), static_cast(y)); + return static_cast(_ret); +} + +void ScintillaEdit_DropSelectionN(ScintillaEdit* self, intptr_t selection) { + self->dropSelectionN(static_cast(selection)); +} + +void ScintillaEdit_SetMainSelection(ScintillaEdit* self, intptr_t selection) { + self->setMainSelection(static_cast(selection)); +} + +intptr_t ScintillaEdit_MainSelection(const ScintillaEdit* self) { + sptr_t _ret = self->mainSelection(); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelectionNCaret(ScintillaEdit* self, intptr_t selection, intptr_t caret) { + self->setSelectionNCaret(static_cast(selection), static_cast(caret)); +} + +intptr_t ScintillaEdit_SelectionNCaret(const ScintillaEdit* self, intptr_t selection) { + sptr_t _ret = self->selectionNCaret(static_cast(selection)); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelectionNAnchor(ScintillaEdit* self, intptr_t selection, intptr_t anchor) { + self->setSelectionNAnchor(static_cast(selection), static_cast(anchor)); +} + +intptr_t ScintillaEdit_SelectionNAnchor(const ScintillaEdit* self, intptr_t selection) { + sptr_t _ret = self->selectionNAnchor(static_cast(selection)); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelectionNCaretVirtualSpace(ScintillaEdit* self, intptr_t selection, intptr_t space) { + self->setSelectionNCaretVirtualSpace(static_cast(selection), static_cast(space)); +} + +intptr_t ScintillaEdit_SelectionNCaretVirtualSpace(const ScintillaEdit* self, intptr_t selection) { + sptr_t _ret = self->selectionNCaretVirtualSpace(static_cast(selection)); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelectionNAnchorVirtualSpace(ScintillaEdit* self, intptr_t selection, intptr_t space) { + self->setSelectionNAnchorVirtualSpace(static_cast(selection), static_cast(space)); +} + +intptr_t ScintillaEdit_SelectionNAnchorVirtualSpace(const ScintillaEdit* self, intptr_t selection) { + sptr_t _ret = self->selectionNAnchorVirtualSpace(static_cast(selection)); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelectionNStart(ScintillaEdit* self, intptr_t selection, intptr_t anchor) { + self->setSelectionNStart(static_cast(selection), static_cast(anchor)); +} + +intptr_t ScintillaEdit_SelectionNStart(const ScintillaEdit* self, intptr_t selection) { + sptr_t _ret = self->selectionNStart(static_cast(selection)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_SelectionNStartVirtualSpace(const ScintillaEdit* self, intptr_t selection) { + sptr_t _ret = self->selectionNStartVirtualSpace(static_cast(selection)); + return static_cast(_ret); +} + +void ScintillaEdit_SetSelectionNEnd(ScintillaEdit* self, intptr_t selection, intptr_t caret) { + self->setSelectionNEnd(static_cast(selection), static_cast(caret)); +} + +intptr_t ScintillaEdit_SelectionNEndVirtualSpace(const ScintillaEdit* self, intptr_t selection) { + sptr_t _ret = self->selectionNEndVirtualSpace(static_cast(selection)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_SelectionNEnd(const ScintillaEdit* self, intptr_t selection) { + sptr_t _ret = self->selectionNEnd(static_cast(selection)); + return static_cast(_ret); +} + +void ScintillaEdit_SetRectangularSelectionCaret(ScintillaEdit* self, intptr_t caret) { + self->setRectangularSelectionCaret(static_cast(caret)); +} + +intptr_t ScintillaEdit_RectangularSelectionCaret(const ScintillaEdit* self) { + sptr_t _ret = self->rectangularSelectionCaret(); + return static_cast(_ret); +} + +void ScintillaEdit_SetRectangularSelectionAnchor(ScintillaEdit* self, intptr_t anchor) { + self->setRectangularSelectionAnchor(static_cast(anchor)); +} + +intptr_t ScintillaEdit_RectangularSelectionAnchor(const ScintillaEdit* self) { + sptr_t _ret = self->rectangularSelectionAnchor(); + return static_cast(_ret); +} + +void ScintillaEdit_SetRectangularSelectionCaretVirtualSpace(ScintillaEdit* self, intptr_t space) { + self->setRectangularSelectionCaretVirtualSpace(static_cast(space)); +} + +intptr_t ScintillaEdit_RectangularSelectionCaretVirtualSpace(const ScintillaEdit* self) { + sptr_t _ret = self->rectangularSelectionCaretVirtualSpace(); + return static_cast(_ret); +} + +void ScintillaEdit_SetRectangularSelectionAnchorVirtualSpace(ScintillaEdit* self, intptr_t space) { + self->setRectangularSelectionAnchorVirtualSpace(static_cast(space)); +} + +intptr_t ScintillaEdit_RectangularSelectionAnchorVirtualSpace(const ScintillaEdit* self) { + sptr_t _ret = self->rectangularSelectionAnchorVirtualSpace(); + return static_cast(_ret); +} + +void ScintillaEdit_SetVirtualSpaceOptions(ScintillaEdit* self, intptr_t virtualSpaceOptions) { + self->setVirtualSpaceOptions(static_cast(virtualSpaceOptions)); +} + +intptr_t ScintillaEdit_VirtualSpaceOptions(const ScintillaEdit* self) { + sptr_t _ret = self->virtualSpaceOptions(); + return static_cast(_ret); +} + +void ScintillaEdit_SetRectangularSelectionModifier(ScintillaEdit* self, intptr_t modifier) { + self->setRectangularSelectionModifier(static_cast(modifier)); +} + +intptr_t ScintillaEdit_RectangularSelectionModifier(const ScintillaEdit* self) { + sptr_t _ret = self->rectangularSelectionModifier(); + return static_cast(_ret); +} + +void ScintillaEdit_SetAdditionalSelFore(ScintillaEdit* self, intptr_t fore) { + self->setAdditionalSelFore(static_cast(fore)); +} + +void ScintillaEdit_SetAdditionalSelBack(ScintillaEdit* self, intptr_t back) { + self->setAdditionalSelBack(static_cast(back)); +} + +void ScintillaEdit_SetAdditionalSelAlpha(ScintillaEdit* self, intptr_t alpha) { + self->setAdditionalSelAlpha(static_cast(alpha)); +} + +intptr_t ScintillaEdit_AdditionalSelAlpha(const ScintillaEdit* self) { + sptr_t _ret = self->additionalSelAlpha(); + return static_cast(_ret); +} + +void ScintillaEdit_SetAdditionalCaretFore(ScintillaEdit* self, intptr_t fore) { + self->setAdditionalCaretFore(static_cast(fore)); +} + +intptr_t ScintillaEdit_AdditionalCaretFore(const ScintillaEdit* self) { + sptr_t _ret = self->additionalCaretFore(); + return static_cast(_ret); +} + +void ScintillaEdit_RotateSelection(ScintillaEdit* self) { + self->rotateSelection(); +} + +void ScintillaEdit_SwapMainAnchorCaret(ScintillaEdit* self) { + self->swapMainAnchorCaret(); +} + +void ScintillaEdit_MultipleSelectAddNext(ScintillaEdit* self) { + self->multipleSelectAddNext(); +} + +void ScintillaEdit_MultipleSelectAddEach(ScintillaEdit* self) { + self->multipleSelectAddEach(); +} + +intptr_t ScintillaEdit_ChangeLexerState(ScintillaEdit* self, intptr_t start, intptr_t end) { + sptr_t _ret = self->changeLexerState(static_cast(start), static_cast(end)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_ContractedFoldNext(ScintillaEdit* self, intptr_t lineStart) { + sptr_t _ret = self->contractedFoldNext(static_cast(lineStart)); + return static_cast(_ret); +} + +void ScintillaEdit_VerticalCentreCaret(ScintillaEdit* self) { + self->verticalCentreCaret(); +} + +void ScintillaEdit_MoveSelectedLinesUp(ScintillaEdit* self) { + self->moveSelectedLinesUp(); +} + +void ScintillaEdit_MoveSelectedLinesDown(ScintillaEdit* self) { + self->moveSelectedLinesDown(); +} + +void ScintillaEdit_SetIdentifier(ScintillaEdit* self, intptr_t identifier) { + self->setIdentifier(static_cast(identifier)); +} + +intptr_t ScintillaEdit_Identifier(const ScintillaEdit* self) { + sptr_t _ret = self->identifier(); + return static_cast(_ret); +} + +void ScintillaEdit_RGBAImageSetWidth(ScintillaEdit* self, intptr_t width) { + self->rGBAImageSetWidth(static_cast(width)); +} + +void ScintillaEdit_RGBAImageSetHeight(ScintillaEdit* self, intptr_t height) { + self->rGBAImageSetHeight(static_cast(height)); +} + +void ScintillaEdit_RGBAImageSetScale(ScintillaEdit* self, intptr_t scalePercent) { + self->rGBAImageSetScale(static_cast(scalePercent)); +} + +void ScintillaEdit_MarkerDefineRGBAImage(ScintillaEdit* self, intptr_t markerNumber, const char* pixels) { + self->markerDefineRGBAImage(static_cast(markerNumber), pixels); +} + +void ScintillaEdit_RegisterRGBAImage(ScintillaEdit* self, intptr_t typeVal, const char* pixels) { + self->registerRGBAImage(static_cast(typeVal), pixels); +} + +void ScintillaEdit_ScrollToStart(ScintillaEdit* self) { + self->scrollToStart(); +} + +void ScintillaEdit_ScrollToEnd(ScintillaEdit* self) { + self->scrollToEnd(); +} + +void ScintillaEdit_SetTechnology(ScintillaEdit* self, intptr_t technology) { + self->setTechnology(static_cast(technology)); +} + +intptr_t ScintillaEdit_Technology(const ScintillaEdit* self) { + sptr_t _ret = self->technology(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_CreateLoader(ScintillaEdit* self, intptr_t bytes, intptr_t documentOptions) { + sptr_t _ret = self->createLoader(static_cast(bytes), static_cast(documentOptions)); + return static_cast(_ret); +} + +void ScintillaEdit_FindIndicatorShow(ScintillaEdit* self, intptr_t start, intptr_t end) { + self->findIndicatorShow(static_cast(start), static_cast(end)); +} + +void ScintillaEdit_FindIndicatorFlash(ScintillaEdit* self, intptr_t start, intptr_t end) { + self->findIndicatorFlash(static_cast(start), static_cast(end)); +} + +void ScintillaEdit_FindIndicatorHide(ScintillaEdit* self) { + self->findIndicatorHide(); +} + +void ScintillaEdit_VCHomeDisplay(ScintillaEdit* self) { + self->vCHomeDisplay(); +} + +void ScintillaEdit_VCHomeDisplayExtend(ScintillaEdit* self) { + self->vCHomeDisplayExtend(); +} + +bool ScintillaEdit_CaretLineVisibleAlways(const ScintillaEdit* self) { + return self->caretLineVisibleAlways(); +} + +void ScintillaEdit_SetCaretLineVisibleAlways(ScintillaEdit* self, bool alwaysVisible) { + self->setCaretLineVisibleAlways(alwaysVisible); +} + +void ScintillaEdit_SetLineEndTypesAllowed(ScintillaEdit* self, intptr_t lineEndBitSet) { + self->setLineEndTypesAllowed(static_cast(lineEndBitSet)); +} + +intptr_t ScintillaEdit_LineEndTypesAllowed(const ScintillaEdit* self) { + sptr_t _ret = self->lineEndTypesAllowed(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_LineEndTypesActive(const ScintillaEdit* self) { + sptr_t _ret = self->lineEndTypesActive(); + return static_cast(_ret); +} + +void ScintillaEdit_SetRepresentation(ScintillaEdit* self, const char* encodedCharacter, const char* representation) { + self->setRepresentation(encodedCharacter, representation); +} + +struct miqt_string ScintillaEdit_Representation(const ScintillaEdit* self, const char* encodedCharacter) { + QByteArray _qb = self->representation(encodedCharacter); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_ClearRepresentation(ScintillaEdit* self, const char* encodedCharacter) { + self->clearRepresentation(encodedCharacter); +} + +void ScintillaEdit_ClearAllRepresentations(ScintillaEdit* self) { + self->clearAllRepresentations(); +} + +void ScintillaEdit_SetRepresentationAppearance(ScintillaEdit* self, const char* encodedCharacter, intptr_t appearance) { + self->setRepresentationAppearance(encodedCharacter, static_cast(appearance)); +} + +intptr_t ScintillaEdit_RepresentationAppearance(const ScintillaEdit* self, const char* encodedCharacter) { + sptr_t _ret = self->representationAppearance(encodedCharacter); + return static_cast(_ret); +} + +void ScintillaEdit_SetRepresentationColour(ScintillaEdit* self, const char* encodedCharacter, intptr_t colour) { + self->setRepresentationColour(encodedCharacter, static_cast(colour)); +} + +intptr_t ScintillaEdit_RepresentationColour(const ScintillaEdit* self, const char* encodedCharacter) { + sptr_t _ret = self->representationColour(encodedCharacter); + return static_cast(_ret); +} + +void ScintillaEdit_EOLAnnotationSetText(ScintillaEdit* self, intptr_t line, const char* text) { + self->eOLAnnotationSetText(static_cast(line), text); +} + +struct miqt_string ScintillaEdit_EOLAnnotationText(const ScintillaEdit* self, intptr_t line) { + QByteArray _qb = self->eOLAnnotationText(static_cast(line)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_EOLAnnotationSetStyle(ScintillaEdit* self, intptr_t line, intptr_t style) { + self->eOLAnnotationSetStyle(static_cast(line), static_cast(style)); +} + +intptr_t ScintillaEdit_EOLAnnotationStyle(const ScintillaEdit* self, intptr_t line) { + sptr_t _ret = self->eOLAnnotationStyle(static_cast(line)); + return static_cast(_ret); +} + +void ScintillaEdit_EOLAnnotationClearAll(ScintillaEdit* self) { + self->eOLAnnotationClearAll(); +} + +void ScintillaEdit_EOLAnnotationSetVisible(ScintillaEdit* self, intptr_t visible) { + self->eOLAnnotationSetVisible(static_cast(visible)); +} + +intptr_t ScintillaEdit_EOLAnnotationVisible(const ScintillaEdit* self) { + sptr_t _ret = self->eOLAnnotationVisible(); + return static_cast(_ret); +} + +void ScintillaEdit_EOLAnnotationSetStyleOffset(ScintillaEdit* self, intptr_t style) { + self->eOLAnnotationSetStyleOffset(static_cast(style)); +} + +intptr_t ScintillaEdit_EOLAnnotationStyleOffset(const ScintillaEdit* self) { + sptr_t _ret = self->eOLAnnotationStyleOffset(); + return static_cast(_ret); +} + +bool ScintillaEdit_SupportsFeature(const ScintillaEdit* self, intptr_t feature) { + return self->supportsFeature(static_cast(feature)); +} + +intptr_t ScintillaEdit_LineCharacterIndex(const ScintillaEdit* self) { + sptr_t _ret = self->lineCharacterIndex(); + return static_cast(_ret); +} + +void ScintillaEdit_AllocateLineCharacterIndex(ScintillaEdit* self, intptr_t lineCharacterIndex) { + self->allocateLineCharacterIndex(static_cast(lineCharacterIndex)); +} + +void ScintillaEdit_ReleaseLineCharacterIndex(ScintillaEdit* self, intptr_t lineCharacterIndex) { + self->releaseLineCharacterIndex(static_cast(lineCharacterIndex)); +} + +intptr_t ScintillaEdit_LineFromIndexPosition(ScintillaEdit* self, intptr_t pos, intptr_t lineCharacterIndex) { + sptr_t _ret = self->lineFromIndexPosition(static_cast(pos), static_cast(lineCharacterIndex)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_IndexPositionFromLine(ScintillaEdit* self, intptr_t line, intptr_t lineCharacterIndex) { + sptr_t _ret = self->indexPositionFromLine(static_cast(line), static_cast(lineCharacterIndex)); + return static_cast(_ret); +} + +void ScintillaEdit_StartRecord(ScintillaEdit* self) { + self->startRecord(); +} + +void ScintillaEdit_StopRecord(ScintillaEdit* self) { + self->stopRecord(); +} + +intptr_t ScintillaEdit_Lexer(const ScintillaEdit* self) { + sptr_t _ret = self->lexer(); + return static_cast(_ret); +} + +void ScintillaEdit_Colourise(ScintillaEdit* self, intptr_t start, intptr_t end) { + self->colourise(static_cast(start), static_cast(end)); +} + +void ScintillaEdit_SetProperty(ScintillaEdit* self, const char* key, const char* value) { + self->setProperty(key, value); +} + +void ScintillaEdit_SetKeyWords(ScintillaEdit* self, intptr_t keyWordSet, const char* keyWords) { + self->setKeyWords(static_cast(keyWordSet), keyWords); +} + +struct miqt_string ScintillaEdit_Property(const ScintillaEdit* self, const char* key) { + QByteArray _qb = self->property(key); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_PropertyExpanded(const ScintillaEdit* self, const char* key) { + QByteArray _qb = self->propertyExpanded(key); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_PropertyInt(const ScintillaEdit* self, const char* key, intptr_t defaultValue) { + sptr_t _ret = self->propertyInt(key, static_cast(defaultValue)); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_LexerLanguage(const ScintillaEdit* self) { + QByteArray _qb = self->lexerLanguage(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_PrivateLexerCall(ScintillaEdit* self, intptr_t operation, intptr_t pointer) { + sptr_t _ret = self->privateLexerCall(static_cast(operation), static_cast(pointer)); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_PropertyNames(ScintillaEdit* self) { + QByteArray _qb = self->propertyNames(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_PropertyType(ScintillaEdit* self, const char* name) { + sptr_t _ret = self->propertyType(name); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_DescribeProperty(ScintillaEdit* self, const char* name) { + QByteArray _qb = self->describeProperty(name); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_DescribeKeyWordSets(ScintillaEdit* self) { + QByteArray _qb = self->describeKeyWordSets(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_LineEndTypesSupported(const ScintillaEdit* self) { + sptr_t _ret = self->lineEndTypesSupported(); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_AllocateSubStyles(ScintillaEdit* self, intptr_t styleBase, intptr_t numberStyles) { + sptr_t _ret = self->allocateSubStyles(static_cast(styleBase), static_cast(numberStyles)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_SubStylesStart(const ScintillaEdit* self, intptr_t styleBase) { + sptr_t _ret = self->subStylesStart(static_cast(styleBase)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_SubStylesLength(const ScintillaEdit* self, intptr_t styleBase) { + sptr_t _ret = self->subStylesLength(static_cast(styleBase)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_StyleFromSubStyle(const ScintillaEdit* self, intptr_t subStyle) { + sptr_t _ret = self->styleFromSubStyle(static_cast(subStyle)); + return static_cast(_ret); +} + +intptr_t ScintillaEdit_PrimaryStyleFromStyle(const ScintillaEdit* self, intptr_t style) { + sptr_t _ret = self->primaryStyleFromStyle(static_cast(style)); + return static_cast(_ret); +} + +void ScintillaEdit_FreeSubStyles(ScintillaEdit* self) { + self->freeSubStyles(); +} + +void ScintillaEdit_SetIdentifiers(ScintillaEdit* self, intptr_t style, const char* identifiers) { + self->setIdentifiers(static_cast(style), identifiers); +} + +intptr_t ScintillaEdit_DistanceToSecondaryStyles(const ScintillaEdit* self) { + sptr_t _ret = self->distanceToSecondaryStyles(); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_SubStyleBases(const ScintillaEdit* self) { + QByteArray _qb = self->subStyleBases(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +intptr_t ScintillaEdit_NamedStyles(const ScintillaEdit* self) { + sptr_t _ret = self->namedStyles(); + return static_cast(_ret); +} + +struct miqt_string ScintillaEdit_NameOfStyle(ScintillaEdit* self, intptr_t style) { + QByteArray _qb = self->nameOfStyle(static_cast(style)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_TagsOfStyle(ScintillaEdit* self, intptr_t style) { + QByteArray _qb = self->tagsOfStyle(static_cast(style)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_DescriptionOfStyle(ScintillaEdit* self, intptr_t style) { + QByteArray _qb = self->descriptionOfStyle(static_cast(style)); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_SetILexer(ScintillaEdit* self, intptr_t ilexer) { + self->setILexer(static_cast(ilexer)); +} + +intptr_t ScintillaEdit_Bidirectional(const ScintillaEdit* self) { + sptr_t _ret = self->bidirectional(); + return static_cast(_ret); +} + +void ScintillaEdit_SetBidirectional(ScintillaEdit* self, intptr_t bidirectional) { + self->setBidirectional(static_cast(bidirectional)); +} + +struct miqt_string ScintillaEdit_Tr2(const char* s, const char* c) { + QString _ret = ScintillaEdit::tr(s, c); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_Tr3(const char* s, const char* c, int n) { + QString _ret = ScintillaEdit::tr(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_TrUtf82(const char* s, const char* c) { + QString _ret = ScintillaEdit::trUtf8(s, c); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string ScintillaEdit_TrUtf83(const char* s, const char* c, int n) { + QString _ret = ScintillaEdit::trUtf8(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +void ScintillaEdit_Delete(ScintillaEdit* self) { + delete self; +} + diff --git a/qt-extras/scintillaedit/gen_ScintillaEdit.go b/qt-extras/scintillaedit/gen_ScintillaEdit.go new file mode 100644 index 00000000..4a08b89d --- /dev/null +++ b/qt-extras/scintillaedit/gen_ScintillaEdit.go @@ -0,0 +1,9336 @@ +package scintillaedit + +/* + +#include "gen_ScintillaEdit.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "runtime/cgo" + "unsafe" +) + +type std__pointer_safety int + +const ( + Std__relaxed std__pointer_safety = 0 + Std__preferred std__pointer_safety = 1 + Std__strict std__pointer_safety = 2 +) + +type Scintilla__Internal__Edge int + +const ( + Scintilla__Internal__left Scintilla__Internal__Edge = 0 + Scintilla__Internal__top Scintilla__Internal__Edge = 1 + Scintilla__Internal__bottom Scintilla__Internal__Edge = 2 + Scintilla__Internal__right Scintilla__Internal__Edge = 3 +) + +type Scintilla__WhiteSpace int + +const ( + Scintilla__WhiteSpace__Invisible Scintilla__WhiteSpace = 0 + Scintilla__WhiteSpace__VisibleAlways Scintilla__WhiteSpace = 1 + Scintilla__WhiteSpace__VisibleAfterIndent Scintilla__WhiteSpace = 2 + Scintilla__WhiteSpace__VisibleOnlyInIndent Scintilla__WhiteSpace = 3 +) + +type Scintilla__TabDrawMode int + +const ( + Scintilla__LongArrow Scintilla__TabDrawMode = 0 + Scintilla__StrikeOut Scintilla__TabDrawMode = 1 +) + +type Scintilla__EndOfLine int + +const ( + Scintilla__CrLf Scintilla__EndOfLine = 0 + Scintilla__Cr Scintilla__EndOfLine = 1 + Scintilla__Lf Scintilla__EndOfLine = 2 +) + +type Scintilla__IMEInteraction int + +const ( + Scintilla__Windowed Scintilla__IMEInteraction = 0 + Scintilla__Inline Scintilla__IMEInteraction = 1 +) + +type Scintilla__Alpha int + +const ( + Scintilla__Transparent Scintilla__Alpha = 0 + Scintilla__Opaque Scintilla__Alpha = 255 + Scintilla__NoAlpha Scintilla__Alpha = 256 +) + +type Scintilla__CursorShape int + +const ( + Scintilla__CursorShape__Normal Scintilla__CursorShape = -1 + Scintilla__CursorShape__Arrow Scintilla__CursorShape = 2 + Scintilla__CursorShape__Wait Scintilla__CursorShape = 4 + Scintilla__CursorShape__ReverseArrow Scintilla__CursorShape = 7 +) + +type Scintilla__MarkerSymbol int + +const ( + Scintilla__MarkerSymbol__Circle Scintilla__MarkerSymbol = 0 + Scintilla__MarkerSymbol__RoundRect Scintilla__MarkerSymbol = 1 + Scintilla__MarkerSymbol__Arrow Scintilla__MarkerSymbol = 2 + Scintilla__MarkerSymbol__SmallRect Scintilla__MarkerSymbol = 3 + Scintilla__MarkerSymbol__ShortArrow Scintilla__MarkerSymbol = 4 + Scintilla__MarkerSymbol__Empty Scintilla__MarkerSymbol = 5 + Scintilla__MarkerSymbol__ArrowDown Scintilla__MarkerSymbol = 6 + Scintilla__MarkerSymbol__Minus Scintilla__MarkerSymbol = 7 + Scintilla__MarkerSymbol__Plus Scintilla__MarkerSymbol = 8 + Scintilla__MarkerSymbol__VLine Scintilla__MarkerSymbol = 9 + Scintilla__MarkerSymbol__LCorner Scintilla__MarkerSymbol = 10 + Scintilla__MarkerSymbol__TCorner Scintilla__MarkerSymbol = 11 + Scintilla__MarkerSymbol__BoxPlus Scintilla__MarkerSymbol = 12 + Scintilla__MarkerSymbol__BoxPlusConnected Scintilla__MarkerSymbol = 13 + Scintilla__MarkerSymbol__BoxMinus Scintilla__MarkerSymbol = 14 + Scintilla__MarkerSymbol__BoxMinusConnected Scintilla__MarkerSymbol = 15 + Scintilla__MarkerSymbol__LCornerCurve Scintilla__MarkerSymbol = 16 + Scintilla__MarkerSymbol__TCornerCurve Scintilla__MarkerSymbol = 17 + Scintilla__MarkerSymbol__CirclePlus Scintilla__MarkerSymbol = 18 + Scintilla__MarkerSymbol__CirclePlusConnected Scintilla__MarkerSymbol = 19 + Scintilla__MarkerSymbol__CircleMinus Scintilla__MarkerSymbol = 20 + Scintilla__MarkerSymbol__CircleMinusConnected Scintilla__MarkerSymbol = 21 + Scintilla__MarkerSymbol__Background Scintilla__MarkerSymbol = 22 + Scintilla__MarkerSymbol__DotDotDot Scintilla__MarkerSymbol = 23 + Scintilla__MarkerSymbol__Arrows Scintilla__MarkerSymbol = 24 + Scintilla__MarkerSymbol__Pixmap Scintilla__MarkerSymbol = 25 + Scintilla__MarkerSymbol__FullRect Scintilla__MarkerSymbol = 26 + Scintilla__MarkerSymbol__LeftRect Scintilla__MarkerSymbol = 27 + Scintilla__MarkerSymbol__Available Scintilla__MarkerSymbol = 28 + Scintilla__MarkerSymbol__Underline Scintilla__MarkerSymbol = 29 + Scintilla__MarkerSymbol__RgbaImage Scintilla__MarkerSymbol = 30 + Scintilla__MarkerSymbol__Bookmark Scintilla__MarkerSymbol = 31 + Scintilla__MarkerSymbol__VerticalBookmark Scintilla__MarkerSymbol = 32 + Scintilla__MarkerSymbol__Bar Scintilla__MarkerSymbol = 33 + Scintilla__MarkerSymbol__Character Scintilla__MarkerSymbol = 10000 +) + +type Scintilla__MarkerOutline int + +const ( + Scintilla__HistoryRevertedToOrigin Scintilla__MarkerOutline = 21 + Scintilla__HistorySaved Scintilla__MarkerOutline = 22 + Scintilla__HistoryModified Scintilla__MarkerOutline = 23 + Scintilla__HistoryRevertedToModified Scintilla__MarkerOutline = 24 + Scintilla__FolderEnd Scintilla__MarkerOutline = 25 + Scintilla__FolderOpenMid Scintilla__MarkerOutline = 26 + Scintilla__FolderMidTail Scintilla__MarkerOutline = 27 + Scintilla__FolderTail Scintilla__MarkerOutline = 28 + Scintilla__FolderSub Scintilla__MarkerOutline = 29 + Scintilla__Folder Scintilla__MarkerOutline = 30 + Scintilla__FolderOpen Scintilla__MarkerOutline = 31 +) + +type Scintilla__MarginType int + +const ( + Scintilla__MarginType__Symbol Scintilla__MarginType = 0 + Scintilla__MarginType__Number Scintilla__MarginType = 1 + Scintilla__MarginType__Back Scintilla__MarginType = 2 + Scintilla__MarginType__Fore Scintilla__MarginType = 3 + Scintilla__MarginType__Text Scintilla__MarginType = 4 + Scintilla__MarginType__RText Scintilla__MarginType = 5 + Scintilla__MarginType__Colour Scintilla__MarginType = 6 +) + +type Scintilla__StylesCommon int + +const ( + Scintilla__StylesCommon__Default Scintilla__StylesCommon = 32 + Scintilla__StylesCommon__LineNumber Scintilla__StylesCommon = 33 + Scintilla__StylesCommon__BraceLight Scintilla__StylesCommon = 34 + Scintilla__StylesCommon__BraceBad Scintilla__StylesCommon = 35 + Scintilla__StylesCommon__ControlChar Scintilla__StylesCommon = 36 + Scintilla__StylesCommon__IndentGuide Scintilla__StylesCommon = 37 + Scintilla__StylesCommon__CallTip Scintilla__StylesCommon = 38 + Scintilla__StylesCommon__FoldDisplayText Scintilla__StylesCommon = 39 + Scintilla__StylesCommon__LastPredefined Scintilla__StylesCommon = 39 + Scintilla__StylesCommon__Max Scintilla__StylesCommon = 255 +) + +type Scintilla__CharacterSet int + +const ( + Scintilla__CharacterSet__Ansi Scintilla__CharacterSet = 0 + Scintilla__CharacterSet__Default Scintilla__CharacterSet = 1 + Scintilla__CharacterSet__Baltic Scintilla__CharacterSet = 186 + Scintilla__CharacterSet__ChineseBig5 Scintilla__CharacterSet = 136 + Scintilla__CharacterSet__EastEurope Scintilla__CharacterSet = 238 + Scintilla__CharacterSet__GB2312 Scintilla__CharacterSet = 134 + Scintilla__CharacterSet__Greek Scintilla__CharacterSet = 161 + Scintilla__CharacterSet__Hangul Scintilla__CharacterSet = 129 + Scintilla__CharacterSet__Mac Scintilla__CharacterSet = 77 + Scintilla__CharacterSet__Oem Scintilla__CharacterSet = 255 + Scintilla__CharacterSet__Russian Scintilla__CharacterSet = 204 + Scintilla__CharacterSet__Oem866 Scintilla__CharacterSet = 866 + Scintilla__CharacterSet__Cyrillic Scintilla__CharacterSet = 1251 + Scintilla__CharacterSet__ShiftJis Scintilla__CharacterSet = 128 + Scintilla__CharacterSet__Symbol Scintilla__CharacterSet = 2 + Scintilla__CharacterSet__Turkish Scintilla__CharacterSet = 162 + Scintilla__CharacterSet__Johab Scintilla__CharacterSet = 130 + Scintilla__CharacterSet__Hebrew Scintilla__CharacterSet = 177 + Scintilla__CharacterSet__Arabic Scintilla__CharacterSet = 178 + Scintilla__CharacterSet__Vietnamese Scintilla__CharacterSet = 163 + Scintilla__CharacterSet__Thai Scintilla__CharacterSet = 222 + Scintilla__CharacterSet__Iso8859_15 Scintilla__CharacterSet = 1000 +) + +type Scintilla__CaseVisible int + +const ( + Scintilla__Mixed Scintilla__CaseVisible = 0 + Scintilla__Upper Scintilla__CaseVisible = 1 + Scintilla__Lower Scintilla__CaseVisible = 2 + Scintilla__Camel Scintilla__CaseVisible = 3 +) + +type Scintilla__FontWeight int + +const ( + Scintilla__FontWeight__Normal Scintilla__FontWeight = 400 + Scintilla__FontWeight__SemiBold Scintilla__FontWeight = 600 + Scintilla__FontWeight__Bold Scintilla__FontWeight = 700 +) + +type Scintilla__FontStretch int + +const ( + Scintilla__FontStretch__UltraCondensed Scintilla__FontStretch = 1 + Scintilla__FontStretch__ExtraCondensed Scintilla__FontStretch = 2 + Scintilla__FontStretch__Condensed Scintilla__FontStretch = 3 + Scintilla__FontStretch__SemiCondensed Scintilla__FontStretch = 4 + Scintilla__FontStretch__Normal Scintilla__FontStretch = 5 + Scintilla__FontStretch__SemiExpanded Scintilla__FontStretch = 6 + Scintilla__FontStretch__Expanded Scintilla__FontStretch = 7 + Scintilla__FontStretch__ExtraExpanded Scintilla__FontStretch = 8 + Scintilla__FontStretch__UltraExpanded Scintilla__FontStretch = 9 +) + +type Scintilla__Element int + +const ( + Scintilla__Element__List Scintilla__Element = 0 + Scintilla__Element__ListBack Scintilla__Element = 1 + Scintilla__Element__ListSelected Scintilla__Element = 2 + Scintilla__Element__ListSelectedBack Scintilla__Element = 3 + Scintilla__Element__SelectionText Scintilla__Element = 10 + Scintilla__Element__SelectionBack Scintilla__Element = 11 + Scintilla__Element__SelectionAdditionalText Scintilla__Element = 12 + Scintilla__Element__SelectionAdditionalBack Scintilla__Element = 13 + Scintilla__Element__SelectionSecondaryText Scintilla__Element = 14 + Scintilla__Element__SelectionSecondaryBack Scintilla__Element = 15 + Scintilla__Element__SelectionInactiveText Scintilla__Element = 16 + Scintilla__Element__SelectionInactiveBack Scintilla__Element = 17 + Scintilla__Element__SelectionInactiveAdditionalText Scintilla__Element = 18 + Scintilla__Element__SelectionInactiveAdditionalBack Scintilla__Element = 19 + Scintilla__Element__Caret Scintilla__Element = 40 + Scintilla__Element__CaretAdditional Scintilla__Element = 41 + Scintilla__Element__CaretLineBack Scintilla__Element = 50 + Scintilla__Element__WhiteSpace Scintilla__Element = 60 + Scintilla__Element__WhiteSpaceBack Scintilla__Element = 61 + Scintilla__Element__HotSpotActive Scintilla__Element = 70 + Scintilla__Element__HotSpotActiveBack Scintilla__Element = 71 + Scintilla__Element__FoldLine Scintilla__Element = 80 + Scintilla__Element__HiddenLine Scintilla__Element = 81 +) + +type Scintilla__Layer int + +const ( + Scintilla__Base Scintilla__Layer = 0 + Scintilla__UnderText Scintilla__Layer = 1 + Scintilla__OverText Scintilla__Layer = 2 +) + +type Scintilla__IndicatorStyle int + +const ( + Scintilla__IndicatorStyle__Plain Scintilla__IndicatorStyle = 0 + Scintilla__IndicatorStyle__Squiggle Scintilla__IndicatorStyle = 1 + Scintilla__IndicatorStyle__TT Scintilla__IndicatorStyle = 2 + Scintilla__IndicatorStyle__Diagonal Scintilla__IndicatorStyle = 3 + Scintilla__IndicatorStyle__Strike Scintilla__IndicatorStyle = 4 + Scintilla__IndicatorStyle__Hidden Scintilla__IndicatorStyle = 5 + Scintilla__IndicatorStyle__Box Scintilla__IndicatorStyle = 6 + Scintilla__IndicatorStyle__RoundBox Scintilla__IndicatorStyle = 7 + Scintilla__IndicatorStyle__StraightBox Scintilla__IndicatorStyle = 8 + Scintilla__IndicatorStyle__Dash Scintilla__IndicatorStyle = 9 + Scintilla__IndicatorStyle__Dots Scintilla__IndicatorStyle = 10 + Scintilla__IndicatorStyle__SquiggleLow Scintilla__IndicatorStyle = 11 + Scintilla__IndicatorStyle__DotBox Scintilla__IndicatorStyle = 12 + Scintilla__IndicatorStyle__SquigglePixmap Scintilla__IndicatorStyle = 13 + Scintilla__IndicatorStyle__CompositionThick Scintilla__IndicatorStyle = 14 + Scintilla__IndicatorStyle__CompositionThin Scintilla__IndicatorStyle = 15 + Scintilla__IndicatorStyle__FullBox Scintilla__IndicatorStyle = 16 + Scintilla__IndicatorStyle__TextFore Scintilla__IndicatorStyle = 17 + Scintilla__IndicatorStyle__Point Scintilla__IndicatorStyle = 18 + Scintilla__IndicatorStyle__PointCharacter Scintilla__IndicatorStyle = 19 + Scintilla__IndicatorStyle__Gradient Scintilla__IndicatorStyle = 20 + Scintilla__IndicatorStyle__GradientCentre Scintilla__IndicatorStyle = 21 + Scintilla__IndicatorStyle__PointTop Scintilla__IndicatorStyle = 22 +) + +type Scintilla__IndicatorNumbers int + +const ( + Scintilla__IndicatorNumbers__Container Scintilla__IndicatorNumbers = 8 + Scintilla__IndicatorNumbers__Ime Scintilla__IndicatorNumbers = 32 + Scintilla__IndicatorNumbers__ImeMax Scintilla__IndicatorNumbers = 35 + Scintilla__IndicatorNumbers__HistoryRevertedToOriginInsertion Scintilla__IndicatorNumbers = 36 + Scintilla__IndicatorNumbers__HistoryRevertedToOriginDeletion Scintilla__IndicatorNumbers = 37 + Scintilla__IndicatorNumbers__HistorySavedInsertion Scintilla__IndicatorNumbers = 38 + Scintilla__IndicatorNumbers__HistorySavedDeletion Scintilla__IndicatorNumbers = 39 + Scintilla__IndicatorNumbers__HistoryModifiedInsertion Scintilla__IndicatorNumbers = 40 + Scintilla__IndicatorNumbers__HistoryModifiedDeletion Scintilla__IndicatorNumbers = 41 + Scintilla__IndicatorNumbers__HistoryRevertedToModifiedInsertion Scintilla__IndicatorNumbers = 42 + Scintilla__IndicatorNumbers__HistoryRevertedToModifiedDeletion Scintilla__IndicatorNumbers = 43 + Scintilla__IndicatorNumbers__Max Scintilla__IndicatorNumbers = 43 +) + +type Scintilla__IndicValue int + +const ( + Scintilla__Bit Scintilla__IndicValue = 16777216 + Scintilla__Mask Scintilla__IndicValue = 16777215 +) + +type Scintilla__IndicFlag int + +const ( + Scintilla__IndicFlag__None Scintilla__IndicFlag = 0 + Scintilla__IndicFlag__ValueFore Scintilla__IndicFlag = 1 +) + +type Scintilla__AutoCompleteOption int + +const ( + Scintilla__AutoCompleteOption__Normal Scintilla__AutoCompleteOption = 0 + Scintilla__AutoCompleteOption__FixedSize Scintilla__AutoCompleteOption = 1 + Scintilla__AutoCompleteOption__SelectFirstItem Scintilla__AutoCompleteOption = 2 +) + +type Scintilla__IndentView int + +const ( + Scintilla__IndentView__None Scintilla__IndentView = 0 + Scintilla__IndentView__Real Scintilla__IndentView = 1 + Scintilla__IndentView__LookForward Scintilla__IndentView = 2 + Scintilla__IndentView__LookBoth Scintilla__IndentView = 3 +) + +type Scintilla__PrintOption int + +const ( + Scintilla__PrintOption__Normal Scintilla__PrintOption = 0 + Scintilla__PrintOption__InvertLight Scintilla__PrintOption = 1 + Scintilla__PrintOption__BlackOnWhite Scintilla__PrintOption = 2 + Scintilla__PrintOption__ColourOnWhite Scintilla__PrintOption = 3 + Scintilla__PrintOption__ColourOnWhiteDefaultBG Scintilla__PrintOption = 4 + Scintilla__PrintOption__ScreenColours Scintilla__PrintOption = 5 +) + +type Scintilla__FindOption int + +const ( + Scintilla__FindOption__None Scintilla__FindOption = 0 + Scintilla__FindOption__WholeWord Scintilla__FindOption = 2 + Scintilla__FindOption__MatchCase Scintilla__FindOption = 4 + Scintilla__FindOption__WordStart Scintilla__FindOption = 1048576 + Scintilla__FindOption__RegExp Scintilla__FindOption = 2097152 + Scintilla__FindOption__Posix Scintilla__FindOption = 4194304 + Scintilla__FindOption__Cxx11RegEx Scintilla__FindOption = 8388608 +) + +type Scintilla__ChangeHistoryOption int + +const ( + Scintilla__ChangeHistoryOption__Disabled Scintilla__ChangeHistoryOption = 0 + Scintilla__ChangeHistoryOption__Enabled Scintilla__ChangeHistoryOption = 1 + Scintilla__ChangeHistoryOption__Markers Scintilla__ChangeHistoryOption = 2 + Scintilla__ChangeHistoryOption__Indicators Scintilla__ChangeHistoryOption = 4 +) + +type Scintilla__FoldLevel int + +const ( + Scintilla__FoldLevel__None Scintilla__FoldLevel = 0 + Scintilla__FoldLevel__Base Scintilla__FoldLevel = 1024 + Scintilla__FoldLevel__WhiteFlag Scintilla__FoldLevel = 4096 + Scintilla__FoldLevel__HeaderFlag Scintilla__FoldLevel = 8192 + Scintilla__FoldLevel__NumberMask Scintilla__FoldLevel = 4095 +) + +type Scintilla__FoldDisplayTextStyle int + +const ( + Scintilla__FoldDisplayTextStyle__Hidden Scintilla__FoldDisplayTextStyle = 0 + Scintilla__FoldDisplayTextStyle__Standard Scintilla__FoldDisplayTextStyle = 1 + Scintilla__FoldDisplayTextStyle__Boxed Scintilla__FoldDisplayTextStyle = 2 +) + +type Scintilla__FoldAction int + +const ( + Scintilla__Contract Scintilla__FoldAction = 0 + Scintilla__Expand Scintilla__FoldAction = 1 + Scintilla__Toggle Scintilla__FoldAction = 2 + Scintilla__ContractEveryLevel Scintilla__FoldAction = 4 +) + +type Scintilla__AutomaticFold int + +const ( + Scintilla__AutomaticFold__None Scintilla__AutomaticFold = 0 + Scintilla__AutomaticFold__Show Scintilla__AutomaticFold = 1 + Scintilla__AutomaticFold__Click Scintilla__AutomaticFold = 2 + Scintilla__AutomaticFold__Change Scintilla__AutomaticFold = 4 +) + +type Scintilla__FoldFlag int + +const ( + Scintilla__FoldFlag__None Scintilla__FoldFlag = 0 + Scintilla__FoldFlag__LineBeforeExpanded Scintilla__FoldFlag = 2 + Scintilla__FoldFlag__LineBeforeContracted Scintilla__FoldFlag = 4 + Scintilla__FoldFlag__LineAfterExpanded Scintilla__FoldFlag = 8 + Scintilla__FoldFlag__LineAfterContracted Scintilla__FoldFlag = 16 + Scintilla__FoldFlag__LevelNumbers Scintilla__FoldFlag = 64 + Scintilla__FoldFlag__LineState Scintilla__FoldFlag = 128 +) + +type Scintilla__IdleStyling int + +const ( + Scintilla__IdleStyling__None Scintilla__IdleStyling = 0 + Scintilla__IdleStyling__ToVisible Scintilla__IdleStyling = 1 + Scintilla__IdleStyling__AfterVisible Scintilla__IdleStyling = 2 + Scintilla__IdleStyling__All Scintilla__IdleStyling = 3 +) + +type Scintilla__Wrap int + +const ( + Scintilla__Wrap__None Scintilla__Wrap = 0 + Scintilla__Wrap__Word Scintilla__Wrap = 1 + Scintilla__Wrap__Char Scintilla__Wrap = 2 + Scintilla__Wrap__WhiteSpace Scintilla__Wrap = 3 +) + +type Scintilla__WrapVisualFlag int + +const ( + Scintilla__WrapVisualFlag__None Scintilla__WrapVisualFlag = 0 + Scintilla__WrapVisualFlag__End Scintilla__WrapVisualFlag = 1 + Scintilla__WrapVisualFlag__Start Scintilla__WrapVisualFlag = 2 + Scintilla__WrapVisualFlag__Margin Scintilla__WrapVisualFlag = 4 +) + +type Scintilla__WrapVisualLocation int + +const ( + Scintilla__WrapVisualLocation__Default Scintilla__WrapVisualLocation = 0 + Scintilla__WrapVisualLocation__EndByText Scintilla__WrapVisualLocation = 1 + Scintilla__WrapVisualLocation__StartByText Scintilla__WrapVisualLocation = 2 +) + +type Scintilla__WrapIndentMode int + +const ( + Scintilla__Fixed Scintilla__WrapIndentMode = 0 + Scintilla__Same Scintilla__WrapIndentMode = 1 + Scintilla__Indent Scintilla__WrapIndentMode = 2 + Scintilla__DeepIndent Scintilla__WrapIndentMode = 3 +) + +type Scintilla__LineCache int + +const ( + Scintilla__LineCache__None Scintilla__LineCache = 0 + Scintilla__LineCache__Caret Scintilla__LineCache = 1 + Scintilla__LineCache__Page Scintilla__LineCache = 2 + Scintilla__LineCache__Document Scintilla__LineCache = 3 +) + +type Scintilla__PhasesDraw int + +const ( + Scintilla__One Scintilla__PhasesDraw = 0 + Scintilla__Two Scintilla__PhasesDraw = 1 + Scintilla__Multiple Scintilla__PhasesDraw = 2 +) + +type Scintilla__FontQuality int + +const ( + Scintilla__QualityMask Scintilla__FontQuality = 15 + Scintilla__QualityDefault Scintilla__FontQuality = 0 + Scintilla__QualityNonAntialiased Scintilla__FontQuality = 1 + Scintilla__QualityAntialiased Scintilla__FontQuality = 2 + Scintilla__QualityLcdOptimized Scintilla__FontQuality = 3 +) + +type Scintilla__MultiPaste int + +const ( + Scintilla__MultiPaste__Once Scintilla__MultiPaste = 0 + Scintilla__MultiPaste__Each Scintilla__MultiPaste = 1 +) + +type Scintilla__Accessibility int + +const ( + Scintilla__Accessibility__Disabled Scintilla__Accessibility = 0 + Scintilla__Accessibility__Enabled Scintilla__Accessibility = 1 +) + +type Scintilla__EdgeVisualStyle int + +const ( + Scintilla__EdgeVisualStyle__None Scintilla__EdgeVisualStyle = 0 + Scintilla__EdgeVisualStyle__Line Scintilla__EdgeVisualStyle = 1 + Scintilla__EdgeVisualStyle__Background Scintilla__EdgeVisualStyle = 2 + Scintilla__EdgeVisualStyle__MultiLine Scintilla__EdgeVisualStyle = 3 +) + +type Scintilla__PopUp int + +const ( + Scintilla__PopUp__Never Scintilla__PopUp = 0 + Scintilla__PopUp__All Scintilla__PopUp = 1 + Scintilla__PopUp__Text Scintilla__PopUp = 2 +) + +type Scintilla__DocumentOption int + +const ( + Scintilla__DocumentOption__Default Scintilla__DocumentOption = 0 + Scintilla__DocumentOption__StylesNone Scintilla__DocumentOption = 1 + Scintilla__DocumentOption__TextLarge Scintilla__DocumentOption = 256 +) + +type Scintilla__Status int + +const ( + Scintilla__Ok Scintilla__Status = 0 + Scintilla__Failure Scintilla__Status = 1 + Scintilla__BadAlloc Scintilla__Status = 2 + Scintilla__WarnStart Scintilla__Status = 1000 + Scintilla__RegEx Scintilla__Status = 1001 +) + +type Scintilla__VisiblePolicy int + +const ( + Scintilla__VisiblePolicy__Slop Scintilla__VisiblePolicy = 1 + Scintilla__VisiblePolicy__Strict Scintilla__VisiblePolicy = 4 +) + +type Scintilla__CaretPolicy int + +const ( + Scintilla__CaretPolicy__Slop Scintilla__CaretPolicy = 1 + Scintilla__CaretPolicy__Strict Scintilla__CaretPolicy = 4 + Scintilla__CaretPolicy__Jumps Scintilla__CaretPolicy = 16 + Scintilla__CaretPolicy__Even Scintilla__CaretPolicy = 8 +) + +type Scintilla__SelectionMode int + +const ( + Scintilla__SelectionMode__Stream Scintilla__SelectionMode = 0 + Scintilla__SelectionMode__Rectangle Scintilla__SelectionMode = 1 + Scintilla__SelectionMode__Lines Scintilla__SelectionMode = 2 + Scintilla__SelectionMode__Thin Scintilla__SelectionMode = 3 +) + +type Scintilla__CaseInsensitiveBehaviour int + +const ( + Scintilla__RespectCase Scintilla__CaseInsensitiveBehaviour = 0 + Scintilla__IgnoreCase Scintilla__CaseInsensitiveBehaviour = 1 +) + +type Scintilla__MultiAutoComplete int + +const ( + Scintilla__MultiAutoComplete__Once Scintilla__MultiAutoComplete = 0 + Scintilla__MultiAutoComplete__Each Scintilla__MultiAutoComplete = 1 +) + +type Scintilla__Ordering int + +const ( + Scintilla__PreSorted Scintilla__Ordering = 0 + Scintilla__PerformSort Scintilla__Ordering = 1 + Scintilla__Custom Scintilla__Ordering = 2 +) + +type Scintilla__CaretSticky int + +const ( + Scintilla__CaretSticky__Off Scintilla__CaretSticky = 0 + Scintilla__CaretSticky__On Scintilla__CaretSticky = 1 + Scintilla__CaretSticky__WhiteSpace Scintilla__CaretSticky = 2 +) + +type Scintilla__CaretStyle int + +const ( + Scintilla__CaretStyle__Invisible Scintilla__CaretStyle = 0 + Scintilla__CaretStyle__Line Scintilla__CaretStyle = 1 + Scintilla__CaretStyle__Block Scintilla__CaretStyle = 2 + Scintilla__CaretStyle__OverstrikeBar Scintilla__CaretStyle = 0 + Scintilla__CaretStyle__OverstrikeBlock Scintilla__CaretStyle = 16 + Scintilla__CaretStyle__Curses Scintilla__CaretStyle = 32 + Scintilla__CaretStyle__InsMask Scintilla__CaretStyle = 15 + Scintilla__CaretStyle__BlockAfter Scintilla__CaretStyle = 256 +) + +type Scintilla__MarginOption int + +const ( + Scintilla__MarginOption__None Scintilla__MarginOption = 0 + Scintilla__MarginOption__SubLineSelect Scintilla__MarginOption = 1 +) + +type Scintilla__AnnotationVisible int + +const ( + Scintilla__AnnotationVisible__Hidden Scintilla__AnnotationVisible = 0 + Scintilla__AnnotationVisible__Standard Scintilla__AnnotationVisible = 1 + Scintilla__AnnotationVisible__Boxed Scintilla__AnnotationVisible = 2 + Scintilla__AnnotationVisible__Indented Scintilla__AnnotationVisible = 3 +) + +type Scintilla__UndoFlags int + +const ( + Scintilla__UndoFlags__None Scintilla__UndoFlags = 0 + Scintilla__UndoFlags__MayCoalesce Scintilla__UndoFlags = 1 +) + +type Scintilla__VirtualSpace int + +const ( + Scintilla__VirtualSpace__None Scintilla__VirtualSpace = 0 + Scintilla__VirtualSpace__RectangularSelection Scintilla__VirtualSpace = 1 + Scintilla__VirtualSpace__UserAccessible Scintilla__VirtualSpace = 2 + Scintilla__VirtualSpace__NoWrapLineStart Scintilla__VirtualSpace = 4 +) + +type Scintilla__Technology int + +const ( + Scintilla__Technology__Default Scintilla__Technology = 0 + Scintilla__Technology__DirectWrite Scintilla__Technology = 1 + Scintilla__Technology__DirectWriteRetain Scintilla__Technology = 2 + Scintilla__Technology__DirectWriteDC Scintilla__Technology = 3 +) + +type Scintilla__LineEndType int + +const ( + Scintilla__LineEndType__Default Scintilla__LineEndType = 0 + Scintilla__LineEndType__Unicode Scintilla__LineEndType = 1 +) + +type Scintilla__RepresentationAppearance int + +const ( + Scintilla__RepresentationAppearance__Plain Scintilla__RepresentationAppearance = 0 + Scintilla__RepresentationAppearance__Blob Scintilla__RepresentationAppearance = 1 + Scintilla__RepresentationAppearance__Colour Scintilla__RepresentationAppearance = 16 +) + +type Scintilla__EOLAnnotationVisible int + +const ( + Scintilla__EOLAnnotationVisible__Hidden Scintilla__EOLAnnotationVisible = 0 + Scintilla__EOLAnnotationVisible__Standard Scintilla__EOLAnnotationVisible = 1 + Scintilla__EOLAnnotationVisible__Boxed Scintilla__EOLAnnotationVisible = 2 + Scintilla__EOLAnnotationVisible__Stadium Scintilla__EOLAnnotationVisible = 256 + Scintilla__EOLAnnotationVisible__FlatCircle Scintilla__EOLAnnotationVisible = 257 + Scintilla__EOLAnnotationVisible__AngleCircle Scintilla__EOLAnnotationVisible = 258 + Scintilla__EOLAnnotationVisible__CircleFlat Scintilla__EOLAnnotationVisible = 272 + Scintilla__EOLAnnotationVisible__Flats Scintilla__EOLAnnotationVisible = 273 + Scintilla__EOLAnnotationVisible__AngleFlat Scintilla__EOLAnnotationVisible = 274 + Scintilla__EOLAnnotationVisible__CircleAngle Scintilla__EOLAnnotationVisible = 288 + Scintilla__EOLAnnotationVisible__FlatAngle Scintilla__EOLAnnotationVisible = 289 + Scintilla__EOLAnnotationVisible__Angles Scintilla__EOLAnnotationVisible = 290 +) + +type Scintilla__Supports int + +const ( + Scintilla__LineDrawsFinal Scintilla__Supports = 0 + Scintilla__PixelDivisions Scintilla__Supports = 1 + Scintilla__FractionalStrokeWidth Scintilla__Supports = 2 + Scintilla__TranslucentStroke Scintilla__Supports = 3 + Scintilla__PixelModification Scintilla__Supports = 4 + Scintilla__ThreadSafeMeasureWidths Scintilla__Supports = 5 +) + +type Scintilla__LineCharacterIndexType int + +const ( + Scintilla__LineCharacterIndexType__None Scintilla__LineCharacterIndexType = 0 + Scintilla__LineCharacterIndexType__Utf32 Scintilla__LineCharacterIndexType = 1 + Scintilla__LineCharacterIndexType__Utf16 Scintilla__LineCharacterIndexType = 2 +) + +type Scintilla__TypeProperty int + +const ( + Scintilla__Boolean Scintilla__TypeProperty = 0 + Scintilla__Integer Scintilla__TypeProperty = 1 + Scintilla__String Scintilla__TypeProperty = 2 +) + +type Scintilla__ModificationFlags int + +const ( + Scintilla__ModificationFlags__None Scintilla__ModificationFlags = 0 + Scintilla__ModificationFlags__InsertText Scintilla__ModificationFlags = 1 + Scintilla__ModificationFlags__DeleteText Scintilla__ModificationFlags = 2 + Scintilla__ModificationFlags__ChangeStyle Scintilla__ModificationFlags = 4 + Scintilla__ModificationFlags__ChangeFold Scintilla__ModificationFlags = 8 + Scintilla__ModificationFlags__User Scintilla__ModificationFlags = 16 + Scintilla__ModificationFlags__Undo Scintilla__ModificationFlags = 32 + Scintilla__ModificationFlags__Redo Scintilla__ModificationFlags = 64 + Scintilla__ModificationFlags__MultiStepUndoRedo Scintilla__ModificationFlags = 128 + Scintilla__ModificationFlags__LastStepInUndoRedo Scintilla__ModificationFlags = 256 + Scintilla__ModificationFlags__ChangeMarker Scintilla__ModificationFlags = 512 + Scintilla__ModificationFlags__BeforeInsert Scintilla__ModificationFlags = 1024 + Scintilla__ModificationFlags__BeforeDelete Scintilla__ModificationFlags = 2048 + Scintilla__ModificationFlags__MultilineUndoRedo Scintilla__ModificationFlags = 4096 + Scintilla__ModificationFlags__StartAction Scintilla__ModificationFlags = 8192 + Scintilla__ModificationFlags__ChangeIndicator Scintilla__ModificationFlags = 16384 + Scintilla__ModificationFlags__ChangeLineState Scintilla__ModificationFlags = 32768 + Scintilla__ModificationFlags__ChangeMargin Scintilla__ModificationFlags = 65536 + Scintilla__ModificationFlags__ChangeAnnotation Scintilla__ModificationFlags = 131072 + Scintilla__ModificationFlags__Container Scintilla__ModificationFlags = 262144 + Scintilla__ModificationFlags__LexerState Scintilla__ModificationFlags = 524288 + Scintilla__ModificationFlags__InsertCheck Scintilla__ModificationFlags = 1048576 + Scintilla__ModificationFlags__ChangeTabStops Scintilla__ModificationFlags = 2097152 + Scintilla__ModificationFlags__ChangeEOLAnnotation Scintilla__ModificationFlags = 4194304 + Scintilla__ModificationFlags__EventMaskAll Scintilla__ModificationFlags = 8388607 +) + +type Scintilla__Update int + +const ( + Scintilla__Update__None Scintilla__Update = 0 + Scintilla__Update__Content Scintilla__Update = 1 + Scintilla__Update__Selection Scintilla__Update = 2 + Scintilla__Update__VScroll Scintilla__Update = 4 + Scintilla__Update__HScroll Scintilla__Update = 8 +) + +type Scintilla__FocusChange int + +const ( + Scintilla__Change Scintilla__FocusChange = 768 + Scintilla__Setfocus Scintilla__FocusChange = 512 + Scintilla__Killfocus Scintilla__FocusChange = 256 +) + +type Scintilla__Keys int + +const ( + Scintilla__Keys__Down Scintilla__Keys = 300 + Scintilla__Keys__Up Scintilla__Keys = 301 + Scintilla__Keys__Left Scintilla__Keys = 302 + Scintilla__Keys__Right Scintilla__Keys = 303 + Scintilla__Keys__Home Scintilla__Keys = 304 + Scintilla__Keys__End Scintilla__Keys = 305 + Scintilla__Keys__Prior Scintilla__Keys = 306 + Scintilla__Keys__Next Scintilla__Keys = 307 + Scintilla__Keys__Delete Scintilla__Keys = 308 + Scintilla__Keys__Insert Scintilla__Keys = 309 + Scintilla__Keys__Escape Scintilla__Keys = 7 + Scintilla__Keys__Back Scintilla__Keys = 8 + Scintilla__Keys__Tab Scintilla__Keys = 9 + Scintilla__Keys__Return Scintilla__Keys = 13 + Scintilla__Keys__Add Scintilla__Keys = 310 + Scintilla__Keys__Subtract Scintilla__Keys = 311 + Scintilla__Keys__Divide Scintilla__Keys = 312 + Scintilla__Keys__Win Scintilla__Keys = 313 + Scintilla__Keys__RWin Scintilla__Keys = 314 + Scintilla__Keys__Menu Scintilla__Keys = 315 +) + +type Scintilla__KeyMod int + +const ( + Scintilla__Norm Scintilla__KeyMod = 0 + Scintilla__Shift Scintilla__KeyMod = 1 + Scintilla__Ctrl Scintilla__KeyMod = 2 + Scintilla__Alt Scintilla__KeyMod = 4 + Scintilla__Super Scintilla__KeyMod = 8 + Scintilla__Meta Scintilla__KeyMod = 16 +) + +type Scintilla__CompletionMethods int + +const ( + Scintilla__CompletionMethods__FillUp Scintilla__CompletionMethods = 1 + Scintilla__CompletionMethods__DoubleClick Scintilla__CompletionMethods = 2 + Scintilla__CompletionMethods__Tab Scintilla__CompletionMethods = 3 + Scintilla__CompletionMethods__Newline Scintilla__CompletionMethods = 4 + Scintilla__CompletionMethods__Command Scintilla__CompletionMethods = 5 + Scintilla__CompletionMethods__SingleChoice Scintilla__CompletionMethods = 6 +) + +type Scintilla__CharacterSource int + +const ( + Scintilla__DirectInput Scintilla__CharacterSource = 0 + Scintilla__TentativeInput Scintilla__CharacterSource = 1 + Scintilla__ImeResult Scintilla__CharacterSource = 2 +) + +type Scintilla__Bidirectional int + +const ( + Scintilla__Bidirectional__Disabled Scintilla__Bidirectional = 0 + Scintilla__Bidirectional__L2R Scintilla__Bidirectional = 1 + Scintilla__Bidirectional__R2L Scintilla__Bidirectional = 2 +) + +type Scintilla__Notification int + +const ( + Scintilla__Notification__StyleNeeded Scintilla__Notification = 2000 + Scintilla__Notification__CharAdded Scintilla__Notification = 2001 + Scintilla__Notification__SavePointReached Scintilla__Notification = 2002 + Scintilla__Notification__SavePointLeft Scintilla__Notification = 2003 + Scintilla__Notification__ModifyAttemptRO Scintilla__Notification = 2004 + Scintilla__Notification__Key Scintilla__Notification = 2005 + Scintilla__Notification__DoubleClick Scintilla__Notification = 2006 + Scintilla__Notification__UpdateUI Scintilla__Notification = 2007 + Scintilla__Notification__Modified Scintilla__Notification = 2008 + Scintilla__Notification__MacroRecord Scintilla__Notification = 2009 + Scintilla__Notification__MarginClick Scintilla__Notification = 2010 + Scintilla__Notification__NeedShown Scintilla__Notification = 2011 + Scintilla__Notification__Painted Scintilla__Notification = 2013 + Scintilla__Notification__UserListSelection Scintilla__Notification = 2014 + Scintilla__Notification__URIDropped Scintilla__Notification = 2015 + Scintilla__Notification__DwellStart Scintilla__Notification = 2016 + Scintilla__Notification__DwellEnd Scintilla__Notification = 2017 + Scintilla__Notification__Zoom Scintilla__Notification = 2018 + Scintilla__Notification__HotSpotClick Scintilla__Notification = 2019 + Scintilla__Notification__HotSpotDoubleClick Scintilla__Notification = 2020 + Scintilla__Notification__CallTipClick Scintilla__Notification = 2021 + Scintilla__Notification__AutoCSelection Scintilla__Notification = 2022 + Scintilla__Notification__IndicatorClick Scintilla__Notification = 2023 + Scintilla__Notification__IndicatorRelease Scintilla__Notification = 2024 + Scintilla__Notification__AutoCCancelled Scintilla__Notification = 2025 + Scintilla__Notification__AutoCCharDeleted Scintilla__Notification = 2026 + Scintilla__Notification__HotSpotReleaseClick Scintilla__Notification = 2027 + Scintilla__Notification__FocusIn Scintilla__Notification = 2028 + Scintilla__Notification__FocusOut Scintilla__Notification = 2029 + Scintilla__Notification__AutoCCompleted Scintilla__Notification = 2030 + Scintilla__Notification__MarginRightClick Scintilla__Notification = 2031 + Scintilla__Notification__AutoCSelectionChange Scintilla__Notification = 2032 +) + +type Scintilla__Message int + +const ( + Scintilla__Message__AddText Scintilla__Message = 2001 + Scintilla__Message__AddStyledText Scintilla__Message = 2002 + Scintilla__Message__InsertText Scintilla__Message = 2003 + Scintilla__Message__ChangeInsertion Scintilla__Message = 2672 + Scintilla__Message__ClearAll Scintilla__Message = 2004 + Scintilla__Message__DeleteRange Scintilla__Message = 2645 + Scintilla__Message__ClearDocumentStyle Scintilla__Message = 2005 + Scintilla__Message__GetLength Scintilla__Message = 2006 + Scintilla__Message__GetCharAt Scintilla__Message = 2007 + Scintilla__Message__GetCurrentPos Scintilla__Message = 2008 + Scintilla__Message__GetAnchor Scintilla__Message = 2009 + Scintilla__Message__GetStyleAt Scintilla__Message = 2010 + Scintilla__Message__GetStyleIndexAt Scintilla__Message = 2038 + Scintilla__Message__Redo Scintilla__Message = 2011 + Scintilla__Message__SetUndoCollection Scintilla__Message = 2012 + Scintilla__Message__SelectAll Scintilla__Message = 2013 + Scintilla__Message__SetSavePoint Scintilla__Message = 2014 + Scintilla__Message__GetStyledText Scintilla__Message = 2015 + Scintilla__Message__GetStyledTextFull Scintilla__Message = 2778 + Scintilla__Message__CanRedo Scintilla__Message = 2016 + Scintilla__Message__MarkerLineFromHandle Scintilla__Message = 2017 + Scintilla__Message__MarkerDeleteHandle Scintilla__Message = 2018 + Scintilla__Message__MarkerHandleFromLine Scintilla__Message = 2732 + Scintilla__Message__MarkerNumberFromLine Scintilla__Message = 2733 + Scintilla__Message__GetUndoCollection Scintilla__Message = 2019 + Scintilla__Message__GetViewWS Scintilla__Message = 2020 + Scintilla__Message__SetViewWS Scintilla__Message = 2021 + Scintilla__Message__GetTabDrawMode Scintilla__Message = 2698 + Scintilla__Message__SetTabDrawMode Scintilla__Message = 2699 + Scintilla__Message__PositionFromPoint Scintilla__Message = 2022 + Scintilla__Message__PositionFromPointClose Scintilla__Message = 2023 + Scintilla__Message__GotoLine Scintilla__Message = 2024 + Scintilla__Message__GotoPos Scintilla__Message = 2025 + Scintilla__Message__SetAnchor Scintilla__Message = 2026 + Scintilla__Message__GetCurLine Scintilla__Message = 2027 + Scintilla__Message__GetEndStyled Scintilla__Message = 2028 + Scintilla__Message__ConvertEOLs Scintilla__Message = 2029 + Scintilla__Message__GetEOLMode Scintilla__Message = 2030 + Scintilla__Message__SetEOLMode Scintilla__Message = 2031 + Scintilla__Message__StartStyling Scintilla__Message = 2032 + Scintilla__Message__SetStyling Scintilla__Message = 2033 + Scintilla__Message__GetBufferedDraw Scintilla__Message = 2034 + Scintilla__Message__SetBufferedDraw Scintilla__Message = 2035 + Scintilla__Message__SetTabWidth Scintilla__Message = 2036 + Scintilla__Message__GetTabWidth Scintilla__Message = 2121 + Scintilla__Message__SetTabMinimumWidth Scintilla__Message = 2724 + Scintilla__Message__GetTabMinimumWidth Scintilla__Message = 2725 + Scintilla__Message__ClearTabStops Scintilla__Message = 2675 + Scintilla__Message__AddTabStop Scintilla__Message = 2676 + Scintilla__Message__GetNextTabStop Scintilla__Message = 2677 + Scintilla__Message__SetCodePage Scintilla__Message = 2037 + Scintilla__Message__SetFontLocale Scintilla__Message = 2760 + Scintilla__Message__GetFontLocale Scintilla__Message = 2761 + Scintilla__Message__GetIMEInteraction Scintilla__Message = 2678 + Scintilla__Message__SetIMEInteraction Scintilla__Message = 2679 + Scintilla__Message__MarkerDefine Scintilla__Message = 2040 + Scintilla__Message__MarkerSetFore Scintilla__Message = 2041 + Scintilla__Message__MarkerSetBack Scintilla__Message = 2042 + Scintilla__Message__MarkerSetBackSelected Scintilla__Message = 2292 + Scintilla__Message__MarkerSetForeTranslucent Scintilla__Message = 2294 + Scintilla__Message__MarkerSetBackTranslucent Scintilla__Message = 2295 + Scintilla__Message__MarkerSetBackSelectedTranslucent Scintilla__Message = 2296 + Scintilla__Message__MarkerSetStrokeWidth Scintilla__Message = 2297 + Scintilla__Message__MarkerEnableHighlight Scintilla__Message = 2293 + Scintilla__Message__MarkerAdd Scintilla__Message = 2043 + Scintilla__Message__MarkerDelete Scintilla__Message = 2044 + Scintilla__Message__MarkerDeleteAll Scintilla__Message = 2045 + Scintilla__Message__MarkerGet Scintilla__Message = 2046 + Scintilla__Message__MarkerNext Scintilla__Message = 2047 + Scintilla__Message__MarkerPrevious Scintilla__Message = 2048 + Scintilla__Message__MarkerDefinePixmap Scintilla__Message = 2049 + Scintilla__Message__MarkerAddSet Scintilla__Message = 2466 + Scintilla__Message__MarkerSetAlpha Scintilla__Message = 2476 + Scintilla__Message__MarkerGetLayer Scintilla__Message = 2734 + Scintilla__Message__MarkerSetLayer Scintilla__Message = 2735 + Scintilla__Message__SetMarginTypeN Scintilla__Message = 2240 + Scintilla__Message__GetMarginTypeN Scintilla__Message = 2241 + Scintilla__Message__SetMarginWidthN Scintilla__Message = 2242 + Scintilla__Message__GetMarginWidthN Scintilla__Message = 2243 + Scintilla__Message__SetMarginMaskN Scintilla__Message = 2244 + Scintilla__Message__GetMarginMaskN Scintilla__Message = 2245 + Scintilla__Message__SetMarginSensitiveN Scintilla__Message = 2246 + Scintilla__Message__GetMarginSensitiveN Scintilla__Message = 2247 + Scintilla__Message__SetMarginCursorN Scintilla__Message = 2248 + Scintilla__Message__GetMarginCursorN Scintilla__Message = 2249 + Scintilla__Message__SetMarginBackN Scintilla__Message = 2250 + Scintilla__Message__GetMarginBackN Scintilla__Message = 2251 + Scintilla__Message__SetMargins Scintilla__Message = 2252 + Scintilla__Message__GetMargins Scintilla__Message = 2253 + Scintilla__Message__StyleClearAll Scintilla__Message = 2050 + Scintilla__Message__StyleSetFore Scintilla__Message = 2051 + Scintilla__Message__StyleSetBack Scintilla__Message = 2052 + Scintilla__Message__StyleSetBold Scintilla__Message = 2053 + Scintilla__Message__StyleSetItalic Scintilla__Message = 2054 + Scintilla__Message__StyleSetSize Scintilla__Message = 2055 + Scintilla__Message__StyleSetFont Scintilla__Message = 2056 + Scintilla__Message__StyleSetEOLFilled Scintilla__Message = 2057 + Scintilla__Message__StyleResetDefault Scintilla__Message = 2058 + Scintilla__Message__StyleSetUnderline Scintilla__Message = 2059 + Scintilla__Message__StyleGetFore Scintilla__Message = 2481 + Scintilla__Message__StyleGetBack Scintilla__Message = 2482 + Scintilla__Message__StyleGetBold Scintilla__Message = 2483 + Scintilla__Message__StyleGetItalic Scintilla__Message = 2484 + Scintilla__Message__StyleGetSize Scintilla__Message = 2485 + Scintilla__Message__StyleGetFont Scintilla__Message = 2486 + Scintilla__Message__StyleGetEOLFilled Scintilla__Message = 2487 + Scintilla__Message__StyleGetUnderline Scintilla__Message = 2488 + Scintilla__Message__StyleGetCase Scintilla__Message = 2489 + Scintilla__Message__StyleGetCharacterSet Scintilla__Message = 2490 + Scintilla__Message__StyleGetVisible Scintilla__Message = 2491 + Scintilla__Message__StyleGetChangeable Scintilla__Message = 2492 + Scintilla__Message__StyleGetHotSpot Scintilla__Message = 2493 + Scintilla__Message__StyleSetCase Scintilla__Message = 2060 + Scintilla__Message__StyleSetSizeFractional Scintilla__Message = 2061 + Scintilla__Message__StyleGetSizeFractional Scintilla__Message = 2062 + Scintilla__Message__StyleSetWeight Scintilla__Message = 2063 + Scintilla__Message__StyleGetWeight Scintilla__Message = 2064 + Scintilla__Message__StyleSetCharacterSet Scintilla__Message = 2066 + Scintilla__Message__StyleSetHotSpot Scintilla__Message = 2409 + Scintilla__Message__StyleSetCheckMonospaced Scintilla__Message = 2254 + Scintilla__Message__StyleGetCheckMonospaced Scintilla__Message = 2255 + Scintilla__Message__StyleSetStretch Scintilla__Message = 2258 + Scintilla__Message__StyleGetStretch Scintilla__Message = 2259 + Scintilla__Message__StyleSetInvisibleRepresentation Scintilla__Message = 2256 + Scintilla__Message__StyleGetInvisibleRepresentation Scintilla__Message = 2257 + Scintilla__Message__SetElementColour Scintilla__Message = 2753 + Scintilla__Message__GetElementColour Scintilla__Message = 2754 + Scintilla__Message__ResetElementColour Scintilla__Message = 2755 + Scintilla__Message__GetElementIsSet Scintilla__Message = 2756 + Scintilla__Message__GetElementAllowsTranslucent Scintilla__Message = 2757 + Scintilla__Message__GetElementBaseColour Scintilla__Message = 2758 + Scintilla__Message__SetSelFore Scintilla__Message = 2067 + Scintilla__Message__SetSelBack Scintilla__Message = 2068 + Scintilla__Message__GetSelAlpha Scintilla__Message = 2477 + Scintilla__Message__SetSelAlpha Scintilla__Message = 2478 + Scintilla__Message__GetSelEOLFilled Scintilla__Message = 2479 + Scintilla__Message__SetSelEOLFilled Scintilla__Message = 2480 + Scintilla__Message__GetSelectionLayer Scintilla__Message = 2762 + Scintilla__Message__SetSelectionLayer Scintilla__Message = 2763 + Scintilla__Message__GetCaretLineLayer Scintilla__Message = 2764 + Scintilla__Message__SetCaretLineLayer Scintilla__Message = 2765 + Scintilla__Message__GetCaretLineHighlightSubLine Scintilla__Message = 2773 + Scintilla__Message__SetCaretLineHighlightSubLine Scintilla__Message = 2774 + Scintilla__Message__SetCaretFore Scintilla__Message = 2069 + Scintilla__Message__AssignCmdKey Scintilla__Message = 2070 + Scintilla__Message__ClearCmdKey Scintilla__Message = 2071 + Scintilla__Message__ClearAllCmdKeys Scintilla__Message = 2072 + Scintilla__Message__SetStylingEx Scintilla__Message = 2073 + Scintilla__Message__StyleSetVisible Scintilla__Message = 2074 + Scintilla__Message__GetCaretPeriod Scintilla__Message = 2075 + Scintilla__Message__SetCaretPeriod Scintilla__Message = 2076 + Scintilla__Message__SetWordChars Scintilla__Message = 2077 + Scintilla__Message__GetWordChars Scintilla__Message = 2646 + Scintilla__Message__SetCharacterCategoryOptimization Scintilla__Message = 2720 + Scintilla__Message__GetCharacterCategoryOptimization Scintilla__Message = 2721 + Scintilla__Message__BeginUndoAction Scintilla__Message = 2078 + Scintilla__Message__EndUndoAction Scintilla__Message = 2079 + Scintilla__Message__GetUndoSequence Scintilla__Message = 2799 + Scintilla__Message__GetUndoActions Scintilla__Message = 2790 + Scintilla__Message__SetUndoSavePoint Scintilla__Message = 2791 + Scintilla__Message__GetUndoSavePoint Scintilla__Message = 2792 + Scintilla__Message__SetUndoDetach Scintilla__Message = 2793 + Scintilla__Message__GetUndoDetach Scintilla__Message = 2794 + Scintilla__Message__SetUndoTentative Scintilla__Message = 2795 + Scintilla__Message__GetUndoTentative Scintilla__Message = 2796 + Scintilla__Message__SetUndoCurrent Scintilla__Message = 2797 + Scintilla__Message__GetUndoCurrent Scintilla__Message = 2798 + Scintilla__Message__PushUndoActionType Scintilla__Message = 2800 + Scintilla__Message__ChangeLastUndoActionText Scintilla__Message = 2801 + Scintilla__Message__GetUndoActionType Scintilla__Message = 2802 + Scintilla__Message__GetUndoActionPosition Scintilla__Message = 2803 + Scintilla__Message__GetUndoActionText Scintilla__Message = 2804 + Scintilla__Message__IndicSetStyle Scintilla__Message = 2080 + Scintilla__Message__IndicGetStyle Scintilla__Message = 2081 + Scintilla__Message__IndicSetFore Scintilla__Message = 2082 + Scintilla__Message__IndicGetFore Scintilla__Message = 2083 + Scintilla__Message__IndicSetUnder Scintilla__Message = 2510 + Scintilla__Message__IndicGetUnder Scintilla__Message = 2511 + Scintilla__Message__IndicSetHoverStyle Scintilla__Message = 2680 + Scintilla__Message__IndicGetHoverStyle Scintilla__Message = 2681 + Scintilla__Message__IndicSetHoverFore Scintilla__Message = 2682 + Scintilla__Message__IndicGetHoverFore Scintilla__Message = 2683 + Scintilla__Message__IndicSetFlags Scintilla__Message = 2684 + Scintilla__Message__IndicGetFlags Scintilla__Message = 2685 + Scintilla__Message__IndicSetStrokeWidth Scintilla__Message = 2751 + Scintilla__Message__IndicGetStrokeWidth Scintilla__Message = 2752 + Scintilla__Message__SetWhitespaceFore Scintilla__Message = 2084 + Scintilla__Message__SetWhitespaceBack Scintilla__Message = 2085 + Scintilla__Message__SetWhitespaceSize Scintilla__Message = 2086 + Scintilla__Message__GetWhitespaceSize Scintilla__Message = 2087 + Scintilla__Message__SetLineState Scintilla__Message = 2092 + Scintilla__Message__GetLineState Scintilla__Message = 2093 + Scintilla__Message__GetMaxLineState Scintilla__Message = 2094 + Scintilla__Message__GetCaretLineVisible Scintilla__Message = 2095 + Scintilla__Message__SetCaretLineVisible Scintilla__Message = 2096 + Scintilla__Message__GetCaretLineBack Scintilla__Message = 2097 + Scintilla__Message__SetCaretLineBack Scintilla__Message = 2098 + Scintilla__Message__GetCaretLineFrame Scintilla__Message = 2704 + Scintilla__Message__SetCaretLineFrame Scintilla__Message = 2705 + Scintilla__Message__StyleSetChangeable Scintilla__Message = 2099 + Scintilla__Message__AutoCShow Scintilla__Message = 2100 + Scintilla__Message__AutoCCancel Scintilla__Message = 2101 + Scintilla__Message__AutoCActive Scintilla__Message = 2102 + Scintilla__Message__AutoCPosStart Scintilla__Message = 2103 + Scintilla__Message__AutoCComplete Scintilla__Message = 2104 + Scintilla__Message__AutoCStops Scintilla__Message = 2105 + Scintilla__Message__AutoCSetSeparator Scintilla__Message = 2106 + Scintilla__Message__AutoCGetSeparator Scintilla__Message = 2107 + Scintilla__Message__AutoCSelect Scintilla__Message = 2108 + Scintilla__Message__AutoCSetCancelAtStart Scintilla__Message = 2110 + Scintilla__Message__AutoCGetCancelAtStart Scintilla__Message = 2111 + Scintilla__Message__AutoCSetFillUps Scintilla__Message = 2112 + Scintilla__Message__AutoCSetChooseSingle Scintilla__Message = 2113 + Scintilla__Message__AutoCGetChooseSingle Scintilla__Message = 2114 + Scintilla__Message__AutoCSetIgnoreCase Scintilla__Message = 2115 + Scintilla__Message__AutoCGetIgnoreCase Scintilla__Message = 2116 + Scintilla__Message__UserListShow Scintilla__Message = 2117 + Scintilla__Message__AutoCSetAutoHide Scintilla__Message = 2118 + Scintilla__Message__AutoCGetAutoHide Scintilla__Message = 2119 + Scintilla__Message__AutoCSetOptions Scintilla__Message = 2638 + Scintilla__Message__AutoCGetOptions Scintilla__Message = 2639 + Scintilla__Message__AutoCSetDropRestOfWord Scintilla__Message = 2270 + Scintilla__Message__AutoCGetDropRestOfWord Scintilla__Message = 2271 + Scintilla__Message__RegisterImage Scintilla__Message = 2405 + Scintilla__Message__ClearRegisteredImages Scintilla__Message = 2408 + Scintilla__Message__AutoCGetTypeSeparator Scintilla__Message = 2285 + Scintilla__Message__AutoCSetTypeSeparator Scintilla__Message = 2286 + Scintilla__Message__AutoCSetMaxWidth Scintilla__Message = 2208 + Scintilla__Message__AutoCGetMaxWidth Scintilla__Message = 2209 + Scintilla__Message__AutoCSetMaxHeight Scintilla__Message = 2210 + Scintilla__Message__AutoCGetMaxHeight Scintilla__Message = 2211 + Scintilla__Message__AutoCSetStyle Scintilla__Message = 2109 + Scintilla__Message__AutoCGetStyle Scintilla__Message = 2120 + Scintilla__Message__SetIndent Scintilla__Message = 2122 + Scintilla__Message__GetIndent Scintilla__Message = 2123 + Scintilla__Message__SetUseTabs Scintilla__Message = 2124 + Scintilla__Message__GetUseTabs Scintilla__Message = 2125 + Scintilla__Message__SetLineIndentation Scintilla__Message = 2126 + Scintilla__Message__GetLineIndentation Scintilla__Message = 2127 + Scintilla__Message__GetLineIndentPosition Scintilla__Message = 2128 + Scintilla__Message__GetColumn Scintilla__Message = 2129 + Scintilla__Message__CountCharacters Scintilla__Message = 2633 + Scintilla__Message__CountCodeUnits Scintilla__Message = 2715 + Scintilla__Message__SetHScrollBar Scintilla__Message = 2130 + Scintilla__Message__GetHScrollBar Scintilla__Message = 2131 + Scintilla__Message__SetIndentationGuides Scintilla__Message = 2132 + Scintilla__Message__GetIndentationGuides Scintilla__Message = 2133 + Scintilla__Message__SetHighlightGuide Scintilla__Message = 2134 + Scintilla__Message__GetHighlightGuide Scintilla__Message = 2135 + Scintilla__Message__GetLineEndPosition Scintilla__Message = 2136 + Scintilla__Message__GetCodePage Scintilla__Message = 2137 + Scintilla__Message__GetCaretFore Scintilla__Message = 2138 + Scintilla__Message__GetReadOnly Scintilla__Message = 2140 + Scintilla__Message__SetCurrentPos Scintilla__Message = 2141 + Scintilla__Message__SetSelectionStart Scintilla__Message = 2142 + Scintilla__Message__GetSelectionStart Scintilla__Message = 2143 + Scintilla__Message__SetSelectionEnd Scintilla__Message = 2144 + Scintilla__Message__GetSelectionEnd Scintilla__Message = 2145 + Scintilla__Message__SetEmptySelection Scintilla__Message = 2556 + Scintilla__Message__SetPrintMagnification Scintilla__Message = 2146 + Scintilla__Message__GetPrintMagnification Scintilla__Message = 2147 + Scintilla__Message__SetPrintColourMode Scintilla__Message = 2148 + Scintilla__Message__GetPrintColourMode Scintilla__Message = 2149 + Scintilla__Message__FindText Scintilla__Message = 2150 + Scintilla__Message__FindTextFull Scintilla__Message = 2196 + Scintilla__Message__FormatRange Scintilla__Message = 2151 + Scintilla__Message__FormatRangeFull Scintilla__Message = 2777 + Scintilla__Message__SetChangeHistory Scintilla__Message = 2780 + Scintilla__Message__GetChangeHistory Scintilla__Message = 2781 + Scintilla__Message__GetFirstVisibleLine Scintilla__Message = 2152 + Scintilla__Message__GetLine Scintilla__Message = 2153 + Scintilla__Message__GetLineCount Scintilla__Message = 2154 + Scintilla__Message__AllocateLines Scintilla__Message = 2089 + Scintilla__Message__SetMarginLeft Scintilla__Message = 2155 + Scintilla__Message__GetMarginLeft Scintilla__Message = 2156 + Scintilla__Message__SetMarginRight Scintilla__Message = 2157 + Scintilla__Message__GetMarginRight Scintilla__Message = 2158 + Scintilla__Message__GetModify Scintilla__Message = 2159 + Scintilla__Message__SetSel Scintilla__Message = 2160 + Scintilla__Message__GetSelText Scintilla__Message = 2161 + Scintilla__Message__GetTextRange Scintilla__Message = 2162 + Scintilla__Message__GetTextRangeFull Scintilla__Message = 2039 + Scintilla__Message__HideSelection Scintilla__Message = 2163 + Scintilla__Message__GetSelectionHidden Scintilla__Message = 2088 + Scintilla__Message__PointXFromPosition Scintilla__Message = 2164 + Scintilla__Message__PointYFromPosition Scintilla__Message = 2165 + Scintilla__Message__LineFromPosition Scintilla__Message = 2166 + Scintilla__Message__PositionFromLine Scintilla__Message = 2167 + Scintilla__Message__LineScroll Scintilla__Message = 2168 + Scintilla__Message__ScrollCaret Scintilla__Message = 2169 + Scintilla__Message__ScrollRange Scintilla__Message = 2569 + Scintilla__Message__ReplaceSel Scintilla__Message = 2170 + Scintilla__Message__SetReadOnly Scintilla__Message = 2171 + Scintilla__Message__Null Scintilla__Message = 2172 + Scintilla__Message__CanPaste Scintilla__Message = 2173 + Scintilla__Message__CanUndo Scintilla__Message = 2174 + Scintilla__Message__EmptyUndoBuffer Scintilla__Message = 2175 + Scintilla__Message__Undo Scintilla__Message = 2176 + Scintilla__Message__Cut Scintilla__Message = 2177 + Scintilla__Message__Copy Scintilla__Message = 2178 + Scintilla__Message__Paste Scintilla__Message = 2179 + Scintilla__Message__Clear Scintilla__Message = 2180 + Scintilla__Message__SetText Scintilla__Message = 2181 + Scintilla__Message__GetText Scintilla__Message = 2182 + Scintilla__Message__GetTextLength Scintilla__Message = 2183 + Scintilla__Message__GetDirectFunction Scintilla__Message = 2184 + Scintilla__Message__GetDirectStatusFunction Scintilla__Message = 2772 + Scintilla__Message__GetDirectPointer Scintilla__Message = 2185 + Scintilla__Message__SetOvertype Scintilla__Message = 2186 + Scintilla__Message__GetOvertype Scintilla__Message = 2187 + Scintilla__Message__SetCaretWidth Scintilla__Message = 2188 + Scintilla__Message__GetCaretWidth Scintilla__Message = 2189 + Scintilla__Message__SetTargetStart Scintilla__Message = 2190 + Scintilla__Message__GetTargetStart Scintilla__Message = 2191 + Scintilla__Message__SetTargetStartVirtualSpace Scintilla__Message = 2728 + Scintilla__Message__GetTargetStartVirtualSpace Scintilla__Message = 2729 + Scintilla__Message__SetTargetEnd Scintilla__Message = 2192 + Scintilla__Message__GetTargetEnd Scintilla__Message = 2193 + Scintilla__Message__SetTargetEndVirtualSpace Scintilla__Message = 2730 + Scintilla__Message__GetTargetEndVirtualSpace Scintilla__Message = 2731 + Scintilla__Message__SetTargetRange Scintilla__Message = 2686 + Scintilla__Message__GetTargetText Scintilla__Message = 2687 + Scintilla__Message__TargetFromSelection Scintilla__Message = 2287 + Scintilla__Message__TargetWholeDocument Scintilla__Message = 2690 + Scintilla__Message__ReplaceTarget Scintilla__Message = 2194 + Scintilla__Message__ReplaceTargetRE Scintilla__Message = 2195 + Scintilla__Message__ReplaceTargetMinimal Scintilla__Message = 2779 + Scintilla__Message__SearchInTarget Scintilla__Message = 2197 + Scintilla__Message__SetSearchFlags Scintilla__Message = 2198 + Scintilla__Message__GetSearchFlags Scintilla__Message = 2199 + Scintilla__Message__CallTipShow Scintilla__Message = 2200 + Scintilla__Message__CallTipCancel Scintilla__Message = 2201 + Scintilla__Message__CallTipActive Scintilla__Message = 2202 + Scintilla__Message__CallTipPosStart Scintilla__Message = 2203 + Scintilla__Message__CallTipSetPosStart Scintilla__Message = 2214 + Scintilla__Message__CallTipSetHlt Scintilla__Message = 2204 + Scintilla__Message__CallTipSetBack Scintilla__Message = 2205 + Scintilla__Message__CallTipSetFore Scintilla__Message = 2206 + Scintilla__Message__CallTipSetForeHlt Scintilla__Message = 2207 + Scintilla__Message__CallTipUseStyle Scintilla__Message = 2212 + Scintilla__Message__CallTipSetPosition Scintilla__Message = 2213 + Scintilla__Message__VisibleFromDocLine Scintilla__Message = 2220 + Scintilla__Message__DocLineFromVisible Scintilla__Message = 2221 + Scintilla__Message__WrapCount Scintilla__Message = 2235 + Scintilla__Message__SetFoldLevel Scintilla__Message = 2222 + Scintilla__Message__GetFoldLevel Scintilla__Message = 2223 + Scintilla__Message__GetLastChild Scintilla__Message = 2224 + Scintilla__Message__GetFoldParent Scintilla__Message = 2225 + Scintilla__Message__ShowLines Scintilla__Message = 2226 + Scintilla__Message__HideLines Scintilla__Message = 2227 + Scintilla__Message__GetLineVisible Scintilla__Message = 2228 + Scintilla__Message__GetAllLinesVisible Scintilla__Message = 2236 + Scintilla__Message__SetFoldExpanded Scintilla__Message = 2229 + Scintilla__Message__GetFoldExpanded Scintilla__Message = 2230 + Scintilla__Message__ToggleFold Scintilla__Message = 2231 + Scintilla__Message__ToggleFoldShowText Scintilla__Message = 2700 + Scintilla__Message__FoldDisplayTextSetStyle Scintilla__Message = 2701 + Scintilla__Message__FoldDisplayTextGetStyle Scintilla__Message = 2707 + Scintilla__Message__SetDefaultFoldDisplayText Scintilla__Message = 2722 + Scintilla__Message__GetDefaultFoldDisplayText Scintilla__Message = 2723 + Scintilla__Message__FoldLine Scintilla__Message = 2237 + Scintilla__Message__FoldChildren Scintilla__Message = 2238 + Scintilla__Message__ExpandChildren Scintilla__Message = 2239 + Scintilla__Message__FoldAll Scintilla__Message = 2662 + Scintilla__Message__EnsureVisible Scintilla__Message = 2232 + Scintilla__Message__SetAutomaticFold Scintilla__Message = 2663 + Scintilla__Message__GetAutomaticFold Scintilla__Message = 2664 + Scintilla__Message__SetFoldFlags Scintilla__Message = 2233 + Scintilla__Message__EnsureVisibleEnforcePolicy Scintilla__Message = 2234 + Scintilla__Message__SetTabIndents Scintilla__Message = 2260 + Scintilla__Message__GetTabIndents Scintilla__Message = 2261 + Scintilla__Message__SetBackSpaceUnIndents Scintilla__Message = 2262 + Scintilla__Message__GetBackSpaceUnIndents Scintilla__Message = 2263 + Scintilla__Message__SetMouseDwellTime Scintilla__Message = 2264 + Scintilla__Message__GetMouseDwellTime Scintilla__Message = 2265 + Scintilla__Message__WordStartPosition Scintilla__Message = 2266 + Scintilla__Message__WordEndPosition Scintilla__Message = 2267 + Scintilla__Message__IsRangeWord Scintilla__Message = 2691 + Scintilla__Message__SetIdleStyling Scintilla__Message = 2692 + Scintilla__Message__GetIdleStyling Scintilla__Message = 2693 + Scintilla__Message__SetWrapMode Scintilla__Message = 2268 + Scintilla__Message__GetWrapMode Scintilla__Message = 2269 + Scintilla__Message__SetWrapVisualFlags Scintilla__Message = 2460 + Scintilla__Message__GetWrapVisualFlags Scintilla__Message = 2461 + Scintilla__Message__SetWrapVisualFlagsLocation Scintilla__Message = 2462 + Scintilla__Message__GetWrapVisualFlagsLocation Scintilla__Message = 2463 + Scintilla__Message__SetWrapStartIndent Scintilla__Message = 2464 + Scintilla__Message__GetWrapStartIndent Scintilla__Message = 2465 + Scintilla__Message__SetWrapIndentMode Scintilla__Message = 2472 + Scintilla__Message__GetWrapIndentMode Scintilla__Message = 2473 + Scintilla__Message__SetLayoutCache Scintilla__Message = 2272 + Scintilla__Message__GetLayoutCache Scintilla__Message = 2273 + Scintilla__Message__SetScrollWidth Scintilla__Message = 2274 + Scintilla__Message__GetScrollWidth Scintilla__Message = 2275 + Scintilla__Message__SetScrollWidthTracking Scintilla__Message = 2516 + Scintilla__Message__GetScrollWidthTracking Scintilla__Message = 2517 + Scintilla__Message__TextWidth Scintilla__Message = 2276 + Scintilla__Message__SetEndAtLastLine Scintilla__Message = 2277 + Scintilla__Message__GetEndAtLastLine Scintilla__Message = 2278 + Scintilla__Message__TextHeight Scintilla__Message = 2279 + Scintilla__Message__SetVScrollBar Scintilla__Message = 2280 + Scintilla__Message__GetVScrollBar Scintilla__Message = 2281 + Scintilla__Message__AppendText Scintilla__Message = 2282 + Scintilla__Message__GetPhasesDraw Scintilla__Message = 2673 + Scintilla__Message__SetPhasesDraw Scintilla__Message = 2674 + Scintilla__Message__SetFontQuality Scintilla__Message = 2611 + Scintilla__Message__GetFontQuality Scintilla__Message = 2612 + Scintilla__Message__SetFirstVisibleLine Scintilla__Message = 2613 + Scintilla__Message__SetMultiPaste Scintilla__Message = 2614 + Scintilla__Message__GetMultiPaste Scintilla__Message = 2615 + Scintilla__Message__GetTag Scintilla__Message = 2616 + Scintilla__Message__LinesJoin Scintilla__Message = 2288 + Scintilla__Message__LinesSplit Scintilla__Message = 2289 + Scintilla__Message__SetFoldMarginColour Scintilla__Message = 2290 + Scintilla__Message__SetFoldMarginHiColour Scintilla__Message = 2291 + Scintilla__Message__SetAccessibility Scintilla__Message = 2702 + Scintilla__Message__GetAccessibility Scintilla__Message = 2703 + Scintilla__Message__LineDown Scintilla__Message = 2300 + Scintilla__Message__LineDownExtend Scintilla__Message = 2301 + Scintilla__Message__LineUp Scintilla__Message = 2302 + Scintilla__Message__LineUpExtend Scintilla__Message = 2303 + Scintilla__Message__CharLeft Scintilla__Message = 2304 + Scintilla__Message__CharLeftExtend Scintilla__Message = 2305 + Scintilla__Message__CharRight Scintilla__Message = 2306 + Scintilla__Message__CharRightExtend Scintilla__Message = 2307 + Scintilla__Message__WordLeft Scintilla__Message = 2308 + Scintilla__Message__WordLeftExtend Scintilla__Message = 2309 + Scintilla__Message__WordRight Scintilla__Message = 2310 + Scintilla__Message__WordRightExtend Scintilla__Message = 2311 + Scintilla__Message__Home Scintilla__Message = 2312 + Scintilla__Message__HomeExtend Scintilla__Message = 2313 + Scintilla__Message__LineEnd Scintilla__Message = 2314 + Scintilla__Message__LineEndExtend Scintilla__Message = 2315 + Scintilla__Message__DocumentStart Scintilla__Message = 2316 + Scintilla__Message__DocumentStartExtend Scintilla__Message = 2317 + Scintilla__Message__DocumentEnd Scintilla__Message = 2318 + Scintilla__Message__DocumentEndExtend Scintilla__Message = 2319 + Scintilla__Message__PageUp Scintilla__Message = 2320 + Scintilla__Message__PageUpExtend Scintilla__Message = 2321 + Scintilla__Message__PageDown Scintilla__Message = 2322 + Scintilla__Message__PageDownExtend Scintilla__Message = 2323 + Scintilla__Message__EditToggleOvertype Scintilla__Message = 2324 + Scintilla__Message__Cancel Scintilla__Message = 2325 + Scintilla__Message__DeleteBack Scintilla__Message = 2326 + Scintilla__Message__Tab Scintilla__Message = 2327 + Scintilla__Message__LineIndent Scintilla__Message = 2813 + Scintilla__Message__BackTab Scintilla__Message = 2328 + Scintilla__Message__LineDedent Scintilla__Message = 2814 + Scintilla__Message__NewLine Scintilla__Message = 2329 + Scintilla__Message__FormFeed Scintilla__Message = 2330 + Scintilla__Message__VCHome Scintilla__Message = 2331 + Scintilla__Message__VCHomeExtend Scintilla__Message = 2332 + Scintilla__Message__ZoomIn Scintilla__Message = 2333 + Scintilla__Message__ZoomOut Scintilla__Message = 2334 + Scintilla__Message__DelWordLeft Scintilla__Message = 2335 + Scintilla__Message__DelWordRight Scintilla__Message = 2336 + Scintilla__Message__DelWordRightEnd Scintilla__Message = 2518 + Scintilla__Message__LineCut Scintilla__Message = 2337 + Scintilla__Message__LineDelete Scintilla__Message = 2338 + Scintilla__Message__LineTranspose Scintilla__Message = 2339 + Scintilla__Message__LineReverse Scintilla__Message = 2354 + Scintilla__Message__LineDuplicate Scintilla__Message = 2404 + Scintilla__Message__LowerCase Scintilla__Message = 2340 + Scintilla__Message__UpperCase Scintilla__Message = 2341 + Scintilla__Message__LineScrollDown Scintilla__Message = 2342 + Scintilla__Message__LineScrollUp Scintilla__Message = 2343 + Scintilla__Message__DeleteBackNotLine Scintilla__Message = 2344 + Scintilla__Message__HomeDisplay Scintilla__Message = 2345 + Scintilla__Message__HomeDisplayExtend Scintilla__Message = 2346 + Scintilla__Message__LineEndDisplay Scintilla__Message = 2347 + Scintilla__Message__LineEndDisplayExtend Scintilla__Message = 2348 + Scintilla__Message__HomeWrap Scintilla__Message = 2349 + Scintilla__Message__HomeWrapExtend Scintilla__Message = 2450 + Scintilla__Message__LineEndWrap Scintilla__Message = 2451 + Scintilla__Message__LineEndWrapExtend Scintilla__Message = 2452 + Scintilla__Message__VCHomeWrap Scintilla__Message = 2453 + Scintilla__Message__VCHomeWrapExtend Scintilla__Message = 2454 + Scintilla__Message__LineCopy Scintilla__Message = 2455 + Scintilla__Message__MoveCaretInsideView Scintilla__Message = 2401 + Scintilla__Message__LineLength Scintilla__Message = 2350 + Scintilla__Message__BraceHighlight Scintilla__Message = 2351 + Scintilla__Message__BraceHighlightIndicator Scintilla__Message = 2498 + Scintilla__Message__BraceBadLight Scintilla__Message = 2352 + Scintilla__Message__BraceBadLightIndicator Scintilla__Message = 2499 + Scintilla__Message__BraceMatch Scintilla__Message = 2353 + Scintilla__Message__BraceMatchNext Scintilla__Message = 2369 + Scintilla__Message__GetViewEOL Scintilla__Message = 2355 + Scintilla__Message__SetViewEOL Scintilla__Message = 2356 + Scintilla__Message__GetDocPointer Scintilla__Message = 2357 + Scintilla__Message__SetDocPointer Scintilla__Message = 2358 + Scintilla__Message__SetModEventMask Scintilla__Message = 2359 + Scintilla__Message__GetEdgeColumn Scintilla__Message = 2360 + Scintilla__Message__SetEdgeColumn Scintilla__Message = 2361 + Scintilla__Message__GetEdgeMode Scintilla__Message = 2362 + Scintilla__Message__SetEdgeMode Scintilla__Message = 2363 + Scintilla__Message__GetEdgeColour Scintilla__Message = 2364 + Scintilla__Message__SetEdgeColour Scintilla__Message = 2365 + Scintilla__Message__MultiEdgeAddLine Scintilla__Message = 2694 + Scintilla__Message__MultiEdgeClearAll Scintilla__Message = 2695 + Scintilla__Message__GetMultiEdgeColumn Scintilla__Message = 2749 + Scintilla__Message__SearchAnchor Scintilla__Message = 2366 + Scintilla__Message__SearchNext Scintilla__Message = 2367 + Scintilla__Message__SearchPrev Scintilla__Message = 2368 + Scintilla__Message__LinesOnScreen Scintilla__Message = 2370 + Scintilla__Message__UsePopUp Scintilla__Message = 2371 + Scintilla__Message__SelectionIsRectangle Scintilla__Message = 2372 + Scintilla__Message__SetZoom Scintilla__Message = 2373 + Scintilla__Message__GetZoom Scintilla__Message = 2374 + Scintilla__Message__CreateDocument Scintilla__Message = 2375 + Scintilla__Message__AddRefDocument Scintilla__Message = 2376 + Scintilla__Message__ReleaseDocument Scintilla__Message = 2377 + Scintilla__Message__GetDocumentOptions Scintilla__Message = 2379 + Scintilla__Message__GetModEventMask Scintilla__Message = 2378 + Scintilla__Message__SetCommandEvents Scintilla__Message = 2717 + Scintilla__Message__GetCommandEvents Scintilla__Message = 2718 + Scintilla__Message__SetFocus Scintilla__Message = 2380 + Scintilla__Message__GetFocus Scintilla__Message = 2381 + Scintilla__Message__SetStatus Scintilla__Message = 2382 + Scintilla__Message__GetStatus Scintilla__Message = 2383 + Scintilla__Message__SetMouseDownCaptures Scintilla__Message = 2384 + Scintilla__Message__GetMouseDownCaptures Scintilla__Message = 2385 + Scintilla__Message__SetMouseWheelCaptures Scintilla__Message = 2696 + Scintilla__Message__GetMouseWheelCaptures Scintilla__Message = 2697 + Scintilla__Message__SetCursor Scintilla__Message = 2386 + Scintilla__Message__GetCursor Scintilla__Message = 2387 + Scintilla__Message__SetControlCharSymbol Scintilla__Message = 2388 + Scintilla__Message__GetControlCharSymbol Scintilla__Message = 2389 + Scintilla__Message__WordPartLeft Scintilla__Message = 2390 + Scintilla__Message__WordPartLeftExtend Scintilla__Message = 2391 + Scintilla__Message__WordPartRight Scintilla__Message = 2392 + Scintilla__Message__WordPartRightExtend Scintilla__Message = 2393 + Scintilla__Message__SetVisiblePolicy Scintilla__Message = 2394 + Scintilla__Message__DelLineLeft Scintilla__Message = 2395 + Scintilla__Message__DelLineRight Scintilla__Message = 2396 + Scintilla__Message__SetXOffset Scintilla__Message = 2397 + Scintilla__Message__GetXOffset Scintilla__Message = 2398 + Scintilla__Message__ChooseCaretX Scintilla__Message = 2399 + Scintilla__Message__GrabFocus Scintilla__Message = 2400 + Scintilla__Message__SetXCaretPolicy Scintilla__Message = 2402 + Scintilla__Message__SetYCaretPolicy Scintilla__Message = 2403 + Scintilla__Message__SetPrintWrapMode Scintilla__Message = 2406 + Scintilla__Message__GetPrintWrapMode Scintilla__Message = 2407 + Scintilla__Message__SetHotspotActiveFore Scintilla__Message = 2410 + Scintilla__Message__GetHotspotActiveFore Scintilla__Message = 2494 + Scintilla__Message__SetHotspotActiveBack Scintilla__Message = 2411 + Scintilla__Message__GetHotspotActiveBack Scintilla__Message = 2495 + Scintilla__Message__SetHotspotActiveUnderline Scintilla__Message = 2412 + Scintilla__Message__GetHotspotActiveUnderline Scintilla__Message = 2496 + Scintilla__Message__SetHotspotSingleLine Scintilla__Message = 2421 + Scintilla__Message__GetHotspotSingleLine Scintilla__Message = 2497 + Scintilla__Message__ParaDown Scintilla__Message = 2413 + Scintilla__Message__ParaDownExtend Scintilla__Message = 2414 + Scintilla__Message__ParaUp Scintilla__Message = 2415 + Scintilla__Message__ParaUpExtend Scintilla__Message = 2416 + Scintilla__Message__PositionBefore Scintilla__Message = 2417 + Scintilla__Message__PositionAfter Scintilla__Message = 2418 + Scintilla__Message__PositionRelative Scintilla__Message = 2670 + Scintilla__Message__PositionRelativeCodeUnits Scintilla__Message = 2716 + Scintilla__Message__CopyRange Scintilla__Message = 2419 + Scintilla__Message__CopyText Scintilla__Message = 2420 + Scintilla__Message__SetSelectionMode Scintilla__Message = 2422 + Scintilla__Message__ChangeSelectionMode Scintilla__Message = 2659 + Scintilla__Message__GetSelectionMode Scintilla__Message = 2423 + Scintilla__Message__SetMoveExtendsSelection Scintilla__Message = 2719 + Scintilla__Message__GetMoveExtendsSelection Scintilla__Message = 2706 + Scintilla__Message__GetLineSelStartPosition Scintilla__Message = 2424 + Scintilla__Message__GetLineSelEndPosition Scintilla__Message = 2425 + Scintilla__Message__LineDownRectExtend Scintilla__Message = 2426 + Scintilla__Message__LineUpRectExtend Scintilla__Message = 2427 + Scintilla__Message__CharLeftRectExtend Scintilla__Message = 2428 + Scintilla__Message__CharRightRectExtend Scintilla__Message = 2429 + Scintilla__Message__HomeRectExtend Scintilla__Message = 2430 + Scintilla__Message__VCHomeRectExtend Scintilla__Message = 2431 + Scintilla__Message__LineEndRectExtend Scintilla__Message = 2432 + Scintilla__Message__PageUpRectExtend Scintilla__Message = 2433 + Scintilla__Message__PageDownRectExtend Scintilla__Message = 2434 + Scintilla__Message__StutteredPageUp Scintilla__Message = 2435 + Scintilla__Message__StutteredPageUpExtend Scintilla__Message = 2436 + Scintilla__Message__StutteredPageDown Scintilla__Message = 2437 + Scintilla__Message__StutteredPageDownExtend Scintilla__Message = 2438 + Scintilla__Message__WordLeftEnd Scintilla__Message = 2439 + Scintilla__Message__WordLeftEndExtend Scintilla__Message = 2440 + Scintilla__Message__WordRightEnd Scintilla__Message = 2441 + Scintilla__Message__WordRightEndExtend Scintilla__Message = 2442 + Scintilla__Message__SetWhitespaceChars Scintilla__Message = 2443 + Scintilla__Message__GetWhitespaceChars Scintilla__Message = 2647 + Scintilla__Message__SetPunctuationChars Scintilla__Message = 2648 + Scintilla__Message__GetPunctuationChars Scintilla__Message = 2649 + Scintilla__Message__SetCharsDefault Scintilla__Message = 2444 + Scintilla__Message__AutoCGetCurrent Scintilla__Message = 2445 + Scintilla__Message__AutoCGetCurrentText Scintilla__Message = 2610 + Scintilla__Message__AutoCSetCaseInsensitiveBehaviour Scintilla__Message = 2634 + Scintilla__Message__AutoCGetCaseInsensitiveBehaviour Scintilla__Message = 2635 + Scintilla__Message__AutoCSetMulti Scintilla__Message = 2636 + Scintilla__Message__AutoCGetMulti Scintilla__Message = 2637 + Scintilla__Message__AutoCSetOrder Scintilla__Message = 2660 + Scintilla__Message__AutoCGetOrder Scintilla__Message = 2661 + Scintilla__Message__Allocate Scintilla__Message = 2446 + Scintilla__Message__TargetAsUTF8 Scintilla__Message = 2447 + Scintilla__Message__SetLengthForEncode Scintilla__Message = 2448 + Scintilla__Message__EncodedFromUTF8 Scintilla__Message = 2449 + Scintilla__Message__FindColumn Scintilla__Message = 2456 + Scintilla__Message__GetCaretSticky Scintilla__Message = 2457 + Scintilla__Message__SetCaretSticky Scintilla__Message = 2458 + Scintilla__Message__ToggleCaretSticky Scintilla__Message = 2459 + Scintilla__Message__SetPasteConvertEndings Scintilla__Message = 2467 + Scintilla__Message__GetPasteConvertEndings Scintilla__Message = 2468 + Scintilla__Message__ReplaceRectangular Scintilla__Message = 2771 + Scintilla__Message__SelectionDuplicate Scintilla__Message = 2469 + Scintilla__Message__SetCaretLineBackAlpha Scintilla__Message = 2470 + Scintilla__Message__GetCaretLineBackAlpha Scintilla__Message = 2471 + Scintilla__Message__SetCaretStyle Scintilla__Message = 2512 + Scintilla__Message__GetCaretStyle Scintilla__Message = 2513 + Scintilla__Message__SetIndicatorCurrent Scintilla__Message = 2500 + Scintilla__Message__GetIndicatorCurrent Scintilla__Message = 2501 + Scintilla__Message__SetIndicatorValue Scintilla__Message = 2502 + Scintilla__Message__GetIndicatorValue Scintilla__Message = 2503 + Scintilla__Message__IndicatorFillRange Scintilla__Message = 2504 + Scintilla__Message__IndicatorClearRange Scintilla__Message = 2505 + Scintilla__Message__IndicatorAllOnFor Scintilla__Message = 2506 + Scintilla__Message__IndicatorValueAt Scintilla__Message = 2507 + Scintilla__Message__IndicatorStart Scintilla__Message = 2508 + Scintilla__Message__IndicatorEnd Scintilla__Message = 2509 + Scintilla__Message__SetPositionCache Scintilla__Message = 2514 + Scintilla__Message__GetPositionCache Scintilla__Message = 2515 + Scintilla__Message__SetLayoutThreads Scintilla__Message = 2775 + Scintilla__Message__GetLayoutThreads Scintilla__Message = 2776 + Scintilla__Message__CopyAllowLine Scintilla__Message = 2519 + Scintilla__Message__CutAllowLine Scintilla__Message = 2810 + Scintilla__Message__SetCopySeparator Scintilla__Message = 2811 + Scintilla__Message__GetCopySeparator Scintilla__Message = 2812 + Scintilla__Message__GetCharacterPointer Scintilla__Message = 2520 + Scintilla__Message__GetRangePointer Scintilla__Message = 2643 + Scintilla__Message__GetGapPosition Scintilla__Message = 2644 + Scintilla__Message__IndicSetAlpha Scintilla__Message = 2523 + Scintilla__Message__IndicGetAlpha Scintilla__Message = 2524 + Scintilla__Message__IndicSetOutlineAlpha Scintilla__Message = 2558 + Scintilla__Message__IndicGetOutlineAlpha Scintilla__Message = 2559 + Scintilla__Message__SetExtraAscent Scintilla__Message = 2525 + Scintilla__Message__GetExtraAscent Scintilla__Message = 2526 + Scintilla__Message__SetExtraDescent Scintilla__Message = 2527 + Scintilla__Message__GetExtraDescent Scintilla__Message = 2528 + Scintilla__Message__MarkerSymbolDefined Scintilla__Message = 2529 + Scintilla__Message__MarginSetText Scintilla__Message = 2530 + Scintilla__Message__MarginGetText Scintilla__Message = 2531 + Scintilla__Message__MarginSetStyle Scintilla__Message = 2532 + Scintilla__Message__MarginGetStyle Scintilla__Message = 2533 + Scintilla__Message__MarginSetStyles Scintilla__Message = 2534 + Scintilla__Message__MarginGetStyles Scintilla__Message = 2535 + Scintilla__Message__MarginTextClearAll Scintilla__Message = 2536 + Scintilla__Message__MarginSetStyleOffset Scintilla__Message = 2537 + Scintilla__Message__MarginGetStyleOffset Scintilla__Message = 2538 + Scintilla__Message__SetMarginOptions Scintilla__Message = 2539 + Scintilla__Message__GetMarginOptions Scintilla__Message = 2557 + Scintilla__Message__AnnotationSetText Scintilla__Message = 2540 + Scintilla__Message__AnnotationGetText Scintilla__Message = 2541 + Scintilla__Message__AnnotationSetStyle Scintilla__Message = 2542 + Scintilla__Message__AnnotationGetStyle Scintilla__Message = 2543 + Scintilla__Message__AnnotationSetStyles Scintilla__Message = 2544 + Scintilla__Message__AnnotationGetStyles Scintilla__Message = 2545 + Scintilla__Message__AnnotationGetLines Scintilla__Message = 2546 + Scintilla__Message__AnnotationClearAll Scintilla__Message = 2547 + Scintilla__Message__AnnotationSetVisible Scintilla__Message = 2548 + Scintilla__Message__AnnotationGetVisible Scintilla__Message = 2549 + Scintilla__Message__AnnotationSetStyleOffset Scintilla__Message = 2550 + Scintilla__Message__AnnotationGetStyleOffset Scintilla__Message = 2551 + Scintilla__Message__ReleaseAllExtendedStyles Scintilla__Message = 2552 + Scintilla__Message__AllocateExtendedStyles Scintilla__Message = 2553 + Scintilla__Message__AddUndoAction Scintilla__Message = 2560 + Scintilla__Message__CharPositionFromPoint Scintilla__Message = 2561 + Scintilla__Message__CharPositionFromPointClose Scintilla__Message = 2562 + Scintilla__Message__SetMouseSelectionRectangularSwitch Scintilla__Message = 2668 + Scintilla__Message__GetMouseSelectionRectangularSwitch Scintilla__Message = 2669 + Scintilla__Message__SetMultipleSelection Scintilla__Message = 2563 + Scintilla__Message__GetMultipleSelection Scintilla__Message = 2564 + Scintilla__Message__SetAdditionalSelectionTyping Scintilla__Message = 2565 + Scintilla__Message__GetAdditionalSelectionTyping Scintilla__Message = 2566 + Scintilla__Message__SetAdditionalCaretsBlink Scintilla__Message = 2567 + Scintilla__Message__GetAdditionalCaretsBlink Scintilla__Message = 2568 + Scintilla__Message__SetAdditionalCaretsVisible Scintilla__Message = 2608 + Scintilla__Message__GetAdditionalCaretsVisible Scintilla__Message = 2609 + Scintilla__Message__GetSelections Scintilla__Message = 2570 + Scintilla__Message__GetSelectionEmpty Scintilla__Message = 2650 + Scintilla__Message__ClearSelections Scintilla__Message = 2571 + Scintilla__Message__SetSelection Scintilla__Message = 2572 + Scintilla__Message__AddSelection Scintilla__Message = 2573 + Scintilla__Message__SelectionFromPoint Scintilla__Message = 2474 + Scintilla__Message__DropSelectionN Scintilla__Message = 2671 + Scintilla__Message__SetMainSelection Scintilla__Message = 2574 + Scintilla__Message__GetMainSelection Scintilla__Message = 2575 + Scintilla__Message__SetSelectionNCaret Scintilla__Message = 2576 + Scintilla__Message__GetSelectionNCaret Scintilla__Message = 2577 + Scintilla__Message__SetSelectionNAnchor Scintilla__Message = 2578 + Scintilla__Message__GetSelectionNAnchor Scintilla__Message = 2579 + Scintilla__Message__SetSelectionNCaretVirtualSpace Scintilla__Message = 2580 + Scintilla__Message__GetSelectionNCaretVirtualSpace Scintilla__Message = 2581 + Scintilla__Message__SetSelectionNAnchorVirtualSpace Scintilla__Message = 2582 + Scintilla__Message__GetSelectionNAnchorVirtualSpace Scintilla__Message = 2583 + Scintilla__Message__SetSelectionNStart Scintilla__Message = 2584 + Scintilla__Message__GetSelectionNStart Scintilla__Message = 2585 + Scintilla__Message__GetSelectionNStartVirtualSpace Scintilla__Message = 2726 + Scintilla__Message__SetSelectionNEnd Scintilla__Message = 2586 + Scintilla__Message__GetSelectionNEndVirtualSpace Scintilla__Message = 2727 + Scintilla__Message__GetSelectionNEnd Scintilla__Message = 2587 + Scintilla__Message__SetRectangularSelectionCaret Scintilla__Message = 2588 + Scintilla__Message__GetRectangularSelectionCaret Scintilla__Message = 2589 + Scintilla__Message__SetRectangularSelectionAnchor Scintilla__Message = 2590 + Scintilla__Message__GetRectangularSelectionAnchor Scintilla__Message = 2591 + Scintilla__Message__SetRectangularSelectionCaretVirtualSpace Scintilla__Message = 2592 + Scintilla__Message__GetRectangularSelectionCaretVirtualSpace Scintilla__Message = 2593 + Scintilla__Message__SetRectangularSelectionAnchorVirtualSpace Scintilla__Message = 2594 + Scintilla__Message__GetRectangularSelectionAnchorVirtualSpace Scintilla__Message = 2595 + Scintilla__Message__SetVirtualSpaceOptions Scintilla__Message = 2596 + Scintilla__Message__GetVirtualSpaceOptions Scintilla__Message = 2597 + Scintilla__Message__SetRectangularSelectionModifier Scintilla__Message = 2598 + Scintilla__Message__GetRectangularSelectionModifier Scintilla__Message = 2599 + Scintilla__Message__SetAdditionalSelFore Scintilla__Message = 2600 + Scintilla__Message__SetAdditionalSelBack Scintilla__Message = 2601 + Scintilla__Message__SetAdditionalSelAlpha Scintilla__Message = 2602 + Scintilla__Message__GetAdditionalSelAlpha Scintilla__Message = 2603 + Scintilla__Message__SetAdditionalCaretFore Scintilla__Message = 2604 + Scintilla__Message__GetAdditionalCaretFore Scintilla__Message = 2605 + Scintilla__Message__RotateSelection Scintilla__Message = 2606 + Scintilla__Message__SwapMainAnchorCaret Scintilla__Message = 2607 + Scintilla__Message__MultipleSelectAddNext Scintilla__Message = 2688 + Scintilla__Message__MultipleSelectAddEach Scintilla__Message = 2689 + Scintilla__Message__ChangeLexerState Scintilla__Message = 2617 + Scintilla__Message__ContractedFoldNext Scintilla__Message = 2618 + Scintilla__Message__VerticalCentreCaret Scintilla__Message = 2619 + Scintilla__Message__MoveSelectedLinesUp Scintilla__Message = 2620 + Scintilla__Message__MoveSelectedLinesDown Scintilla__Message = 2621 + Scintilla__Message__SetIdentifier Scintilla__Message = 2622 + Scintilla__Message__GetIdentifier Scintilla__Message = 2623 + Scintilla__Message__RGBAImageSetWidth Scintilla__Message = 2624 + Scintilla__Message__RGBAImageSetHeight Scintilla__Message = 2625 + Scintilla__Message__RGBAImageSetScale Scintilla__Message = 2651 + Scintilla__Message__MarkerDefineRGBAImage Scintilla__Message = 2626 + Scintilla__Message__RegisterRGBAImage Scintilla__Message = 2627 + Scintilla__Message__ScrollToStart Scintilla__Message = 2628 + Scintilla__Message__ScrollToEnd Scintilla__Message = 2629 + Scintilla__Message__SetTechnology Scintilla__Message = 2630 + Scintilla__Message__GetTechnology Scintilla__Message = 2631 + Scintilla__Message__CreateLoader Scintilla__Message = 2632 + Scintilla__Message__FindIndicatorShow Scintilla__Message = 2640 + Scintilla__Message__FindIndicatorFlash Scintilla__Message = 2641 + Scintilla__Message__FindIndicatorHide Scintilla__Message = 2642 + Scintilla__Message__VCHomeDisplay Scintilla__Message = 2652 + Scintilla__Message__VCHomeDisplayExtend Scintilla__Message = 2653 + Scintilla__Message__GetCaretLineVisibleAlways Scintilla__Message = 2654 + Scintilla__Message__SetCaretLineVisibleAlways Scintilla__Message = 2655 + Scintilla__Message__SetLineEndTypesAllowed Scintilla__Message = 2656 + Scintilla__Message__GetLineEndTypesAllowed Scintilla__Message = 2657 + Scintilla__Message__GetLineEndTypesActive Scintilla__Message = 2658 + Scintilla__Message__SetRepresentation Scintilla__Message = 2665 + Scintilla__Message__GetRepresentation Scintilla__Message = 2666 + Scintilla__Message__ClearRepresentation Scintilla__Message = 2667 + Scintilla__Message__ClearAllRepresentations Scintilla__Message = 2770 + Scintilla__Message__SetRepresentationAppearance Scintilla__Message = 2766 + Scintilla__Message__GetRepresentationAppearance Scintilla__Message = 2767 + Scintilla__Message__SetRepresentationColour Scintilla__Message = 2768 + Scintilla__Message__GetRepresentationColour Scintilla__Message = 2769 + Scintilla__Message__EOLAnnotationSetText Scintilla__Message = 2740 + Scintilla__Message__EOLAnnotationGetText Scintilla__Message = 2741 + Scintilla__Message__EOLAnnotationSetStyle Scintilla__Message = 2742 + Scintilla__Message__EOLAnnotationGetStyle Scintilla__Message = 2743 + Scintilla__Message__EOLAnnotationClearAll Scintilla__Message = 2744 + Scintilla__Message__EOLAnnotationSetVisible Scintilla__Message = 2745 + Scintilla__Message__EOLAnnotationGetVisible Scintilla__Message = 2746 + Scintilla__Message__EOLAnnotationSetStyleOffset Scintilla__Message = 2747 + Scintilla__Message__EOLAnnotationGetStyleOffset Scintilla__Message = 2748 + Scintilla__Message__SupportsFeature Scintilla__Message = 2750 + Scintilla__Message__GetLineCharacterIndex Scintilla__Message = 2710 + Scintilla__Message__AllocateLineCharacterIndex Scintilla__Message = 2711 + Scintilla__Message__ReleaseLineCharacterIndex Scintilla__Message = 2712 + Scintilla__Message__LineFromIndexPosition Scintilla__Message = 2713 + Scintilla__Message__IndexPositionFromLine Scintilla__Message = 2714 + Scintilla__Message__StartRecord Scintilla__Message = 3001 + Scintilla__Message__StopRecord Scintilla__Message = 3002 + Scintilla__Message__GetLexer Scintilla__Message = 4002 + Scintilla__Message__Colourise Scintilla__Message = 4003 + Scintilla__Message__SetProperty Scintilla__Message = 4004 + Scintilla__Message__SetKeyWords Scintilla__Message = 4005 + Scintilla__Message__GetProperty Scintilla__Message = 4008 + Scintilla__Message__GetPropertyExpanded Scintilla__Message = 4009 + Scintilla__Message__GetPropertyInt Scintilla__Message = 4010 + Scintilla__Message__GetLexerLanguage Scintilla__Message = 4012 + Scintilla__Message__PrivateLexerCall Scintilla__Message = 4013 + Scintilla__Message__PropertyNames Scintilla__Message = 4014 + Scintilla__Message__PropertyType Scintilla__Message = 4015 + Scintilla__Message__DescribeProperty Scintilla__Message = 4016 + Scintilla__Message__DescribeKeyWordSets Scintilla__Message = 4017 + Scintilla__Message__GetLineEndTypesSupported Scintilla__Message = 4018 + Scintilla__Message__AllocateSubStyles Scintilla__Message = 4020 + Scintilla__Message__GetSubStylesStart Scintilla__Message = 4021 + Scintilla__Message__GetSubStylesLength Scintilla__Message = 4022 + Scintilla__Message__GetStyleFromSubStyle Scintilla__Message = 4027 + Scintilla__Message__GetPrimaryStyleFromStyle Scintilla__Message = 4028 + Scintilla__Message__FreeSubStyles Scintilla__Message = 4023 + Scintilla__Message__SetIdentifiers Scintilla__Message = 4024 + Scintilla__Message__DistanceToSecondaryStyles Scintilla__Message = 4025 + Scintilla__Message__GetSubStyleBases Scintilla__Message = 4026 + Scintilla__Message__GetNamedStyles Scintilla__Message = 4029 + Scintilla__Message__NameOfStyle Scintilla__Message = 4030 + Scintilla__Message__TagsOfStyle Scintilla__Message = 4031 + Scintilla__Message__DescriptionOfStyle Scintilla__Message = 4032 + Scintilla__Message__SetILexer Scintilla__Message = 4033 + Scintilla__Message__GetBidirectional Scintilla__Message = 2708 + Scintilla__Message__SetBidirectional Scintilla__Message = 2709 +) + +type Scintilla__Internal__Surface__Ends int + +const ( + Scintilla__Internal__Surface__semiCircles Scintilla__Internal__Surface__Ends = 0 + Scintilla__Internal__Surface__leftFlat Scintilla__Internal__Surface__Ends = 1 + Scintilla__Internal__Surface__leftAngle Scintilla__Internal__Surface__Ends = 2 + Scintilla__Internal__Surface__rightFlat Scintilla__Internal__Surface__Ends = 16 + Scintilla__Internal__Surface__rightAngle Scintilla__Internal__Surface__Ends = 32 +) + +type Scintilla__Internal__Surface__GradientOptions int + +const ( + Scintilla__Internal__Surface__leftToRight Scintilla__Internal__Surface__GradientOptions = 0 + Scintilla__Internal__Surface__topToBottom Scintilla__Internal__Surface__GradientOptions = 1 +) + +type Scintilla__Internal__Window__Cursor int + +const ( + Scintilla__Internal__Window__invalid Scintilla__Internal__Window__Cursor = 0 + Scintilla__Internal__Window__text Scintilla__Internal__Window__Cursor = 1 + Scintilla__Internal__Window__arrow Scintilla__Internal__Window__Cursor = 2 + Scintilla__Internal__Window__up Scintilla__Internal__Window__Cursor = 3 + Scintilla__Internal__Window__wait Scintilla__Internal__Window__Cursor = 4 + Scintilla__Internal__Window__horizontal Scintilla__Internal__Window__Cursor = 5 + Scintilla__Internal__Window__vertical Scintilla__Internal__Window__Cursor = 6 + Scintilla__Internal__Window__reverseArrow Scintilla__Internal__Window__Cursor = 7 + Scintilla__Internal__Window__hand Scintilla__Internal__Window__Cursor = 8 +) + +type Scintilla__Internal__ListBoxEvent__EventType int + +const ( + Scintilla__Internal__ListBoxEvent__selectionChange Scintilla__Internal__ListBoxEvent__EventType = 0 + Scintilla__Internal__ListBoxEvent__doubleClick Scintilla__Internal__ListBoxEvent__EventType = 1 +) + +type Scintilla__Internal__Point struct { + h *C.Scintilla__Internal__Point +} + +func (this *Scintilla__Internal__Point) cPointer() *C.Scintilla__Internal__Point { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__Point) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__Point(h *C.Scintilla__Internal__Point) *Scintilla__Internal__Point { + if h == nil { + return nil + } + return &Scintilla__Internal__Point{h: h} +} + +func UnsafeNewScintilla__Internal__Point(h unsafe.Pointer) *Scintilla__Internal__Point { + return newScintilla__Internal__Point((*C.Scintilla__Internal__Point)(h)) +} + +// NewScintilla__Internal__Point constructs a new Scintilla::Internal::Point object. +func NewScintilla__Internal__Point() *Scintilla__Internal__Point { + ret := C.Scintilla__Internal__Point_new() + return newScintilla__Internal__Point(ret) +} + +// NewScintilla__Internal__Point2 constructs a new Scintilla::Internal::Point object. +func NewScintilla__Internal__Point2(param1 *Scintilla__Internal__Point) *Scintilla__Internal__Point { + ret := C.Scintilla__Internal__Point_new2(param1.cPointer()) + return newScintilla__Internal__Point(ret) +} + +// NewScintilla__Internal__Point3 constructs a new Scintilla::Internal::Point object. +func NewScintilla__Internal__Point3(x_ float64) *Scintilla__Internal__Point { + ret := C.Scintilla__Internal__Point_new3((C.double)(x_)) + return newScintilla__Internal__Point(ret) +} + +// NewScintilla__Internal__Point4 constructs a new Scintilla::Internal::Point object. +func NewScintilla__Internal__Point4(x_ float64, y_ float64) *Scintilla__Internal__Point { + ret := C.Scintilla__Internal__Point_new4((C.double)(x_), (C.double)(y_)) + return newScintilla__Internal__Point(ret) +} + +func Scintilla__Internal__Point_FromInts(x_ int, y_ int) *Scintilla__Internal__Point { + _ret := C.Scintilla__Internal__Point_FromInts((C.int)(x_), (C.int)(y_)) + _goptr := newScintilla__Internal__Point(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__Point) OperatorEqual(other Scintilla__Internal__Point) bool { + return (bool)(C.Scintilla__Internal__Point_OperatorEqual(this.h, other.cPointer())) +} + +func (this *Scintilla__Internal__Point) OperatorNotEqual(other Scintilla__Internal__Point) bool { + return (bool)(C.Scintilla__Internal__Point_OperatorNotEqual(this.h, other.cPointer())) +} + +func (this *Scintilla__Internal__Point) OperatorPlus(other Scintilla__Internal__Point) *Scintilla__Internal__Point { + _ret := C.Scintilla__Internal__Point_OperatorPlus(this.h, other.cPointer()) + _goptr := newScintilla__Internal__Point(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__Point) OperatorMinus(other Scintilla__Internal__Point) *Scintilla__Internal__Point { + _ret := C.Scintilla__Internal__Point_OperatorMinus(this.h, other.cPointer()) + _goptr := newScintilla__Internal__Point(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__Point) Delete() { + C.Scintilla__Internal__Point_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__Point) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__Point) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__Interval struct { + h *C.Scintilla__Internal__Interval +} + +func (this *Scintilla__Internal__Interval) cPointer() *C.Scintilla__Internal__Interval { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__Interval) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__Interval(h *C.Scintilla__Internal__Interval) *Scintilla__Internal__Interval { + if h == nil { + return nil + } + return &Scintilla__Internal__Interval{h: h} +} + +func UnsafeNewScintilla__Internal__Interval(h unsafe.Pointer) *Scintilla__Internal__Interval { + return newScintilla__Internal__Interval((*C.Scintilla__Internal__Interval)(h)) +} + +func (this *Scintilla__Internal__Interval) OperatorEqual(other *Scintilla__Internal__Interval) bool { + return (bool)(C.Scintilla__Internal__Interval_OperatorEqual(this.h, other.cPointer())) +} + +func (this *Scintilla__Internal__Interval) Width() float64 { + return (float64)(C.Scintilla__Internal__Interval_Width(this.h)) +} + +func (this *Scintilla__Internal__Interval) Empty() bool { + return (bool)(C.Scintilla__Internal__Interval_Empty(this.h)) +} + +func (this *Scintilla__Internal__Interval) Intersects(other Scintilla__Internal__Interval) bool { + return (bool)(C.Scintilla__Internal__Interval_Intersects(this.h, other.cPointer())) +} + +func (this *Scintilla__Internal__Interval) Offset(offset float64) *Scintilla__Internal__Interval { + _ret := C.Scintilla__Internal__Interval_Offset(this.h, (C.double)(offset)) + _goptr := newScintilla__Internal__Interval(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__Interval) Delete() { + C.Scintilla__Internal__Interval_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__Interval) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__Interval) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__PRectangle struct { + h *C.Scintilla__Internal__PRectangle +} + +func (this *Scintilla__Internal__PRectangle) cPointer() *C.Scintilla__Internal__PRectangle { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__PRectangle) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__PRectangle(h *C.Scintilla__Internal__PRectangle) *Scintilla__Internal__PRectangle { + if h == nil { + return nil + } + return &Scintilla__Internal__PRectangle{h: h} +} + +func UnsafeNewScintilla__Internal__PRectangle(h unsafe.Pointer) *Scintilla__Internal__PRectangle { + return newScintilla__Internal__PRectangle((*C.Scintilla__Internal__PRectangle)(h)) +} + +// NewScintilla__Internal__PRectangle constructs a new Scintilla::Internal::PRectangle object. +func NewScintilla__Internal__PRectangle() *Scintilla__Internal__PRectangle { + ret := C.Scintilla__Internal__PRectangle_new() + return newScintilla__Internal__PRectangle(ret) +} + +// NewScintilla__Internal__PRectangle2 constructs a new Scintilla::Internal::PRectangle object. +func NewScintilla__Internal__PRectangle2(param1 *Scintilla__Internal__PRectangle) *Scintilla__Internal__PRectangle { + ret := C.Scintilla__Internal__PRectangle_new2(param1.cPointer()) + return newScintilla__Internal__PRectangle(ret) +} + +// NewScintilla__Internal__PRectangle3 constructs a new Scintilla::Internal::PRectangle object. +func NewScintilla__Internal__PRectangle3(left_ float64) *Scintilla__Internal__PRectangle { + ret := C.Scintilla__Internal__PRectangle_new3((C.double)(left_)) + return newScintilla__Internal__PRectangle(ret) +} + +// NewScintilla__Internal__PRectangle4 constructs a new Scintilla::Internal::PRectangle object. +func NewScintilla__Internal__PRectangle4(left_ float64, top_ float64) *Scintilla__Internal__PRectangle { + ret := C.Scintilla__Internal__PRectangle_new4((C.double)(left_), (C.double)(top_)) + return newScintilla__Internal__PRectangle(ret) +} + +// NewScintilla__Internal__PRectangle5 constructs a new Scintilla::Internal::PRectangle object. +func NewScintilla__Internal__PRectangle5(left_ float64, top_ float64, right_ float64) *Scintilla__Internal__PRectangle { + ret := C.Scintilla__Internal__PRectangle_new5((C.double)(left_), (C.double)(top_), (C.double)(right_)) + return newScintilla__Internal__PRectangle(ret) +} + +// NewScintilla__Internal__PRectangle6 constructs a new Scintilla::Internal::PRectangle object. +func NewScintilla__Internal__PRectangle6(left_ float64, top_ float64, right_ float64, bottom_ float64) *Scintilla__Internal__PRectangle { + ret := C.Scintilla__Internal__PRectangle_new6((C.double)(left_), (C.double)(top_), (C.double)(right_), (C.double)(bottom_)) + return newScintilla__Internal__PRectangle(ret) +} + +func Scintilla__Internal__PRectangle_FromInts(left_ int, top_ int, right_ int, bottom_ int) *Scintilla__Internal__PRectangle { + _ret := C.Scintilla__Internal__PRectangle_FromInts((C.int)(left_), (C.int)(top_), (C.int)(right_), (C.int)(bottom_)) + _goptr := newScintilla__Internal__PRectangle(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__PRectangle) OperatorEqual(rc *Scintilla__Internal__PRectangle) bool { + return (bool)(C.Scintilla__Internal__PRectangle_OperatorEqual(this.h, rc.cPointer())) +} + +func (this *Scintilla__Internal__PRectangle) Contains(pt Scintilla__Internal__Point) bool { + return (bool)(C.Scintilla__Internal__PRectangle_Contains(this.h, pt.cPointer())) +} + +func (this *Scintilla__Internal__PRectangle) ContainsWholePixel(pt Scintilla__Internal__Point) bool { + return (bool)(C.Scintilla__Internal__PRectangle_ContainsWholePixel(this.h, pt.cPointer())) +} + +func (this *Scintilla__Internal__PRectangle) ContainsWithRc(rc Scintilla__Internal__PRectangle) bool { + return (bool)(C.Scintilla__Internal__PRectangle_ContainsWithRc(this.h, rc.cPointer())) +} + +func (this *Scintilla__Internal__PRectangle) Intersects(other Scintilla__Internal__PRectangle) bool { + return (bool)(C.Scintilla__Internal__PRectangle_Intersects(this.h, other.cPointer())) +} + +func (this *Scintilla__Internal__PRectangle) IntersectsWithHorizontalBounds(horizontalBounds Scintilla__Internal__Interval) bool { + return (bool)(C.Scintilla__Internal__PRectangle_IntersectsWithHorizontalBounds(this.h, horizontalBounds.cPointer())) +} + +func (this *Scintilla__Internal__PRectangle) Move(xDelta float64, yDelta float64) { + C.Scintilla__Internal__PRectangle_Move(this.h, (C.double)(xDelta), (C.double)(yDelta)) +} + +func (this *Scintilla__Internal__PRectangle) WithHorizontalBounds(horizontal Scintilla__Internal__Interval) *Scintilla__Internal__PRectangle { + _ret := C.Scintilla__Internal__PRectangle_WithHorizontalBounds(this.h, horizontal.cPointer()) + _goptr := newScintilla__Internal__PRectangle(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__PRectangle) Inset(delta float64) *Scintilla__Internal__PRectangle { + _ret := C.Scintilla__Internal__PRectangle_Inset(this.h, (C.double)(delta)) + _goptr := newScintilla__Internal__PRectangle(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__PRectangle) InsetWithDelta(delta Scintilla__Internal__Point) *Scintilla__Internal__PRectangle { + _ret := C.Scintilla__Internal__PRectangle_InsetWithDelta(this.h, delta.cPointer()) + _goptr := newScintilla__Internal__PRectangle(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__PRectangle) Centre() *Scintilla__Internal__Point { + _ret := C.Scintilla__Internal__PRectangle_Centre(this.h) + _goptr := newScintilla__Internal__Point(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__PRectangle) Width() float64 { + return (float64)(C.Scintilla__Internal__PRectangle_Width(this.h)) +} + +func (this *Scintilla__Internal__PRectangle) Height() float64 { + return (float64)(C.Scintilla__Internal__PRectangle_Height(this.h)) +} + +func (this *Scintilla__Internal__PRectangle) Empty() bool { + return (bool)(C.Scintilla__Internal__PRectangle_Empty(this.h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__PRectangle) Delete() { + C.Scintilla__Internal__PRectangle_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__PRectangle) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__PRectangle) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__ColourRGBA struct { + h *C.Scintilla__Internal__ColourRGBA +} + +func (this *Scintilla__Internal__ColourRGBA) cPointer() *C.Scintilla__Internal__ColourRGBA { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__ColourRGBA) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__ColourRGBA(h *C.Scintilla__Internal__ColourRGBA) *Scintilla__Internal__ColourRGBA { + if h == nil { + return nil + } + return &Scintilla__Internal__ColourRGBA{h: h} +} + +func UnsafeNewScintilla__Internal__ColourRGBA(h unsafe.Pointer) *Scintilla__Internal__ColourRGBA { + return newScintilla__Internal__ColourRGBA((*C.Scintilla__Internal__ColourRGBA)(h)) +} + +// NewScintilla__Internal__ColourRGBA constructs a new Scintilla::Internal::ColourRGBA object. +func NewScintilla__Internal__ColourRGBA() *Scintilla__Internal__ColourRGBA { + ret := C.Scintilla__Internal__ColourRGBA_new() + return newScintilla__Internal__ColourRGBA(ret) +} + +// NewScintilla__Internal__ColourRGBA2 constructs a new Scintilla::Internal::ColourRGBA object. +func NewScintilla__Internal__ColourRGBA2(red uint, green uint, blue uint) *Scintilla__Internal__ColourRGBA { + ret := C.Scintilla__Internal__ColourRGBA_new2((C.uint)(red), (C.uint)(green), (C.uint)(blue)) + return newScintilla__Internal__ColourRGBA(ret) +} + +// NewScintilla__Internal__ColourRGBA3 constructs a new Scintilla::Internal::ColourRGBA object. +func NewScintilla__Internal__ColourRGBA3(cd Scintilla__Internal__ColourRGBA, alpha uint) *Scintilla__Internal__ColourRGBA { + ret := C.Scintilla__Internal__ColourRGBA_new3(cd.cPointer(), (C.uint)(alpha)) + return newScintilla__Internal__ColourRGBA(ret) +} + +// NewScintilla__Internal__ColourRGBA4 constructs a new Scintilla::Internal::ColourRGBA object. +func NewScintilla__Internal__ColourRGBA4(param1 *Scintilla__Internal__ColourRGBA) *Scintilla__Internal__ColourRGBA { + ret := C.Scintilla__Internal__ColourRGBA_new4(param1.cPointer()) + return newScintilla__Internal__ColourRGBA(ret) +} + +// NewScintilla__Internal__ColourRGBA5 constructs a new Scintilla::Internal::ColourRGBA object. +func NewScintilla__Internal__ColourRGBA5(co_ int) *Scintilla__Internal__ColourRGBA { + ret := C.Scintilla__Internal__ColourRGBA_new5((C.int)(co_)) + return newScintilla__Internal__ColourRGBA(ret) +} + +// NewScintilla__Internal__ColourRGBA6 constructs a new Scintilla::Internal::ColourRGBA object. +func NewScintilla__Internal__ColourRGBA6(red uint, green uint, blue uint, alpha uint) *Scintilla__Internal__ColourRGBA { + ret := C.Scintilla__Internal__ColourRGBA_new6((C.uint)(red), (C.uint)(green), (C.uint)(blue), (C.uint)(alpha)) + return newScintilla__Internal__ColourRGBA(ret) +} + +func Scintilla__Internal__ColourRGBA_FromRGB(co_ int) *Scintilla__Internal__ColourRGBA { + _ret := C.Scintilla__Internal__ColourRGBA_FromRGB((C.int)(co_)) + _goptr := newScintilla__Internal__ColourRGBA(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func Scintilla__Internal__ColourRGBA_Grey(grey uint) *Scintilla__Internal__ColourRGBA { + _ret := C.Scintilla__Internal__ColourRGBA_Grey((C.uint)(grey)) + _goptr := newScintilla__Internal__ColourRGBA(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func Scintilla__Internal__ColourRGBA_FromIpRGB(co_ uintptr) *Scintilla__Internal__ColourRGBA { + _ret := C.Scintilla__Internal__ColourRGBA_FromIpRGB((C.intptr_t)(co_)) + _goptr := newScintilla__Internal__ColourRGBA(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__ColourRGBA) WithoutAlpha() *Scintilla__Internal__ColourRGBA { + _ret := C.Scintilla__Internal__ColourRGBA_WithoutAlpha(this.h) + _goptr := newScintilla__Internal__ColourRGBA(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__ColourRGBA) Opaque() *Scintilla__Internal__ColourRGBA { + _ret := C.Scintilla__Internal__ColourRGBA_Opaque(this.h) + _goptr := newScintilla__Internal__ColourRGBA(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__ColourRGBA) AsInteger() int { + return (int)(C.Scintilla__Internal__ColourRGBA_AsInteger(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) OpaqueRGB() int { + return (int)(C.Scintilla__Internal__ColourRGBA_OpaqueRGB(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) GetRed() byte { + return (byte)(C.Scintilla__Internal__ColourRGBA_GetRed(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) GetGreen() byte { + return (byte)(C.Scintilla__Internal__ColourRGBA_GetGreen(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) GetBlue() byte { + return (byte)(C.Scintilla__Internal__ColourRGBA_GetBlue(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) GetAlpha() byte { + return (byte)(C.Scintilla__Internal__ColourRGBA_GetAlpha(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) GetRedComponent() float32 { + return (float32)(C.Scintilla__Internal__ColourRGBA_GetRedComponent(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) GetGreenComponent() float32 { + return (float32)(C.Scintilla__Internal__ColourRGBA_GetGreenComponent(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) GetBlueComponent() float32 { + return (float32)(C.Scintilla__Internal__ColourRGBA_GetBlueComponent(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) GetAlphaComponent() float32 { + return (float32)(C.Scintilla__Internal__ColourRGBA_GetAlphaComponent(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) OperatorEqual(other *Scintilla__Internal__ColourRGBA) bool { + return (bool)(C.Scintilla__Internal__ColourRGBA_OperatorEqual(this.h, other.cPointer())) +} + +func (this *Scintilla__Internal__ColourRGBA) IsOpaque() bool { + return (bool)(C.Scintilla__Internal__ColourRGBA_IsOpaque(this.h)) +} + +func (this *Scintilla__Internal__ColourRGBA) MixedWith(other Scintilla__Internal__ColourRGBA) *Scintilla__Internal__ColourRGBA { + _ret := C.Scintilla__Internal__ColourRGBA_MixedWith(this.h, other.cPointer()) + _goptr := newScintilla__Internal__ColourRGBA(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__ColourRGBA) MixedWith2(other Scintilla__Internal__ColourRGBA, proportion float64) *Scintilla__Internal__ColourRGBA { + _ret := C.Scintilla__Internal__ColourRGBA_MixedWith2(this.h, other.cPointer(), (C.double)(proportion)) + _goptr := newScintilla__Internal__ColourRGBA(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__ColourRGBA) OperatorAssign(param1 *Scintilla__Internal__ColourRGBA) { + C.Scintilla__Internal__ColourRGBA_OperatorAssign(this.h, param1.cPointer()) +} + +func Scintilla__Internal__ColourRGBA_Grey2(grey uint, alpha uint) *Scintilla__Internal__ColourRGBA { + _ret := C.Scintilla__Internal__ColourRGBA_Grey2((C.uint)(grey), (C.uint)(alpha)) + _goptr := newScintilla__Internal__ColourRGBA(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__ColourRGBA) Delete() { + C.Scintilla__Internal__ColourRGBA_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__ColourRGBA) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__ColourRGBA) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__Stroke struct { + h *C.Scintilla__Internal__Stroke +} + +func (this *Scintilla__Internal__Stroke) cPointer() *C.Scintilla__Internal__Stroke { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__Stroke) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__Stroke(h *C.Scintilla__Internal__Stroke) *Scintilla__Internal__Stroke { + if h == nil { + return nil + } + return &Scintilla__Internal__Stroke{h: h} +} + +func UnsafeNewScintilla__Internal__Stroke(h unsafe.Pointer) *Scintilla__Internal__Stroke { + return newScintilla__Internal__Stroke((*C.Scintilla__Internal__Stroke)(h)) +} + +// NewScintilla__Internal__Stroke constructs a new Scintilla::Internal::Stroke object. +func NewScintilla__Internal__Stroke(colour_ Scintilla__Internal__ColourRGBA) *Scintilla__Internal__Stroke { + ret := C.Scintilla__Internal__Stroke_new(colour_.cPointer()) + return newScintilla__Internal__Stroke(ret) +} + +// NewScintilla__Internal__Stroke2 constructs a new Scintilla::Internal::Stroke object. +func NewScintilla__Internal__Stroke2(param1 *Scintilla__Internal__Stroke) *Scintilla__Internal__Stroke { + ret := C.Scintilla__Internal__Stroke_new2(param1.cPointer()) + return newScintilla__Internal__Stroke(ret) +} + +// NewScintilla__Internal__Stroke3 constructs a new Scintilla::Internal::Stroke object. +func NewScintilla__Internal__Stroke3(colour_ Scintilla__Internal__ColourRGBA, width_ float64) *Scintilla__Internal__Stroke { + ret := C.Scintilla__Internal__Stroke_new3(colour_.cPointer(), (C.double)(width_)) + return newScintilla__Internal__Stroke(ret) +} + +func (this *Scintilla__Internal__Stroke) WidthF() float32 { + return (float32)(C.Scintilla__Internal__Stroke_WidthF(this.h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__Stroke) Delete() { + C.Scintilla__Internal__Stroke_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__Stroke) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__Stroke) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__Fill struct { + h *C.Scintilla__Internal__Fill +} + +func (this *Scintilla__Internal__Fill) cPointer() *C.Scintilla__Internal__Fill { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__Fill) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__Fill(h *C.Scintilla__Internal__Fill) *Scintilla__Internal__Fill { + if h == nil { + return nil + } + return &Scintilla__Internal__Fill{h: h} +} + +func UnsafeNewScintilla__Internal__Fill(h unsafe.Pointer) *Scintilla__Internal__Fill { + return newScintilla__Internal__Fill((*C.Scintilla__Internal__Fill)(h)) +} + +// NewScintilla__Internal__Fill constructs a new Scintilla::Internal::Fill object. +func NewScintilla__Internal__Fill(colour_ Scintilla__Internal__ColourRGBA) *Scintilla__Internal__Fill { + ret := C.Scintilla__Internal__Fill_new(colour_.cPointer()) + return newScintilla__Internal__Fill(ret) +} + +// NewScintilla__Internal__Fill2 constructs a new Scintilla::Internal::Fill object. +func NewScintilla__Internal__Fill2(param1 *Scintilla__Internal__Fill) *Scintilla__Internal__Fill { + ret := C.Scintilla__Internal__Fill_new2(param1.cPointer()) + return newScintilla__Internal__Fill(ret) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__Fill) Delete() { + C.Scintilla__Internal__Fill_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__Fill) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__Fill) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__FillStroke struct { + h *C.Scintilla__Internal__FillStroke +} + +func (this *Scintilla__Internal__FillStroke) cPointer() *C.Scintilla__Internal__FillStroke { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__FillStroke) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__FillStroke(h *C.Scintilla__Internal__FillStroke) *Scintilla__Internal__FillStroke { + if h == nil { + return nil + } + return &Scintilla__Internal__FillStroke{h: h} +} + +func UnsafeNewScintilla__Internal__FillStroke(h unsafe.Pointer) *Scintilla__Internal__FillStroke { + return newScintilla__Internal__FillStroke((*C.Scintilla__Internal__FillStroke)(h)) +} + +// NewScintilla__Internal__FillStroke constructs a new Scintilla::Internal::FillStroke object. +func NewScintilla__Internal__FillStroke(colourFill_ Scintilla__Internal__ColourRGBA, colourStroke_ Scintilla__Internal__ColourRGBA) *Scintilla__Internal__FillStroke { + ret := C.Scintilla__Internal__FillStroke_new(colourFill_.cPointer(), colourStroke_.cPointer()) + return newScintilla__Internal__FillStroke(ret) +} + +// NewScintilla__Internal__FillStroke2 constructs a new Scintilla::Internal::FillStroke object. +func NewScintilla__Internal__FillStroke2(colourBoth Scintilla__Internal__ColourRGBA) *Scintilla__Internal__FillStroke { + ret := C.Scintilla__Internal__FillStroke_new2(colourBoth.cPointer()) + return newScintilla__Internal__FillStroke(ret) +} + +// NewScintilla__Internal__FillStroke3 constructs a new Scintilla::Internal::FillStroke object. +func NewScintilla__Internal__FillStroke3(colourFill_ Scintilla__Internal__ColourRGBA, colourStroke_ Scintilla__Internal__ColourRGBA, widthStroke_ float64) *Scintilla__Internal__FillStroke { + ret := C.Scintilla__Internal__FillStroke_new3(colourFill_.cPointer(), colourStroke_.cPointer(), (C.double)(widthStroke_)) + return newScintilla__Internal__FillStroke(ret) +} + +// NewScintilla__Internal__FillStroke4 constructs a new Scintilla::Internal::FillStroke object. +func NewScintilla__Internal__FillStroke4(colourBoth Scintilla__Internal__ColourRGBA, widthStroke_ float64) *Scintilla__Internal__FillStroke { + ret := C.Scintilla__Internal__FillStroke_new4(colourBoth.cPointer(), (C.double)(widthStroke_)) + return newScintilla__Internal__FillStroke(ret) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__FillStroke) Delete() { + C.Scintilla__Internal__FillStroke_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__FillStroke) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__FillStroke) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__ColourStop struct { + h *C.Scintilla__Internal__ColourStop +} + +func (this *Scintilla__Internal__ColourStop) cPointer() *C.Scintilla__Internal__ColourStop { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__ColourStop) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__ColourStop(h *C.Scintilla__Internal__ColourStop) *Scintilla__Internal__ColourStop { + if h == nil { + return nil + } + return &Scintilla__Internal__ColourStop{h: h} +} + +func UnsafeNewScintilla__Internal__ColourStop(h unsafe.Pointer) *Scintilla__Internal__ColourStop { + return newScintilla__Internal__ColourStop((*C.Scintilla__Internal__ColourStop)(h)) +} + +// NewScintilla__Internal__ColourStop constructs a new Scintilla::Internal::ColourStop object. +func NewScintilla__Internal__ColourStop(position_ float64, colour_ Scintilla__Internal__ColourRGBA) *Scintilla__Internal__ColourStop { + ret := C.Scintilla__Internal__ColourStop_new((C.double)(position_), colour_.cPointer()) + return newScintilla__Internal__ColourStop(ret) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__ColourStop) Delete() { + C.Scintilla__Internal__ColourStop_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__ColourStop) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__ColourStop) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__CharacterRange struct { + h *C.Scintilla__CharacterRange +} + +func (this *Scintilla__CharacterRange) cPointer() *C.Scintilla__CharacterRange { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__CharacterRange) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__CharacterRange(h *C.Scintilla__CharacterRange) *Scintilla__CharacterRange { + if h == nil { + return nil + } + return &Scintilla__CharacterRange{h: h} +} + +func UnsafeNewScintilla__CharacterRange(h unsafe.Pointer) *Scintilla__CharacterRange { + return newScintilla__CharacterRange((*C.Scintilla__CharacterRange)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__CharacterRange) Delete() { + C.Scintilla__CharacterRange_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__CharacterRange) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__CharacterRange) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__CharacterRangeFull struct { + h *C.Scintilla__CharacterRangeFull +} + +func (this *Scintilla__CharacterRangeFull) cPointer() *C.Scintilla__CharacterRangeFull { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__CharacterRangeFull) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__CharacterRangeFull(h *C.Scintilla__CharacterRangeFull) *Scintilla__CharacterRangeFull { + if h == nil { + return nil + } + return &Scintilla__CharacterRangeFull{h: h} +} + +func UnsafeNewScintilla__CharacterRangeFull(h unsafe.Pointer) *Scintilla__CharacterRangeFull { + return newScintilla__CharacterRangeFull((*C.Scintilla__CharacterRangeFull)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__CharacterRangeFull) Delete() { + C.Scintilla__CharacterRangeFull_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__CharacterRangeFull) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__CharacterRangeFull) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__TextRange struct { + h *C.Scintilla__TextRange +} + +func (this *Scintilla__TextRange) cPointer() *C.Scintilla__TextRange { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__TextRange) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__TextRange(h *C.Scintilla__TextRange) *Scintilla__TextRange { + if h == nil { + return nil + } + return &Scintilla__TextRange{h: h} +} + +func UnsafeNewScintilla__TextRange(h unsafe.Pointer) *Scintilla__TextRange { + return newScintilla__TextRange((*C.Scintilla__TextRange)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__TextRange) Delete() { + C.Scintilla__TextRange_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__TextRange) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__TextRange) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__TextRangeFull struct { + h *C.Scintilla__TextRangeFull +} + +func (this *Scintilla__TextRangeFull) cPointer() *C.Scintilla__TextRangeFull { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__TextRangeFull) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__TextRangeFull(h *C.Scintilla__TextRangeFull) *Scintilla__TextRangeFull { + if h == nil { + return nil + } + return &Scintilla__TextRangeFull{h: h} +} + +func UnsafeNewScintilla__TextRangeFull(h unsafe.Pointer) *Scintilla__TextRangeFull { + return newScintilla__TextRangeFull((*C.Scintilla__TextRangeFull)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__TextRangeFull) Delete() { + C.Scintilla__TextRangeFull_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__TextRangeFull) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__TextRangeFull) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__TextToFind struct { + h *C.Scintilla__TextToFind +} + +func (this *Scintilla__TextToFind) cPointer() *C.Scintilla__TextToFind { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__TextToFind) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__TextToFind(h *C.Scintilla__TextToFind) *Scintilla__TextToFind { + if h == nil { + return nil + } + return &Scintilla__TextToFind{h: h} +} + +func UnsafeNewScintilla__TextToFind(h unsafe.Pointer) *Scintilla__TextToFind { + return newScintilla__TextToFind((*C.Scintilla__TextToFind)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__TextToFind) Delete() { + C.Scintilla__TextToFind_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__TextToFind) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__TextToFind) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__TextToFindFull struct { + h *C.Scintilla__TextToFindFull +} + +func (this *Scintilla__TextToFindFull) cPointer() *C.Scintilla__TextToFindFull { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__TextToFindFull) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__TextToFindFull(h *C.Scintilla__TextToFindFull) *Scintilla__TextToFindFull { + if h == nil { + return nil + } + return &Scintilla__TextToFindFull{h: h} +} + +func UnsafeNewScintilla__TextToFindFull(h unsafe.Pointer) *Scintilla__TextToFindFull { + return newScintilla__TextToFindFull((*C.Scintilla__TextToFindFull)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__TextToFindFull) Delete() { + C.Scintilla__TextToFindFull_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__TextToFindFull) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__TextToFindFull) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Rectangle struct { + h *C.Scintilla__Rectangle +} + +func (this *Scintilla__Rectangle) cPointer() *C.Scintilla__Rectangle { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Rectangle) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Rectangle(h *C.Scintilla__Rectangle) *Scintilla__Rectangle { + if h == nil { + return nil + } + return &Scintilla__Rectangle{h: h} +} + +func UnsafeNewScintilla__Rectangle(h unsafe.Pointer) *Scintilla__Rectangle { + return newScintilla__Rectangle((*C.Scintilla__Rectangle)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Rectangle) Delete() { + C.Scintilla__Rectangle_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Rectangle) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Rectangle) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__RangeToFormat struct { + h *C.Scintilla__RangeToFormat +} + +func (this *Scintilla__RangeToFormat) cPointer() *C.Scintilla__RangeToFormat { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__RangeToFormat) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__RangeToFormat(h *C.Scintilla__RangeToFormat) *Scintilla__RangeToFormat { + if h == nil { + return nil + } + return &Scintilla__RangeToFormat{h: h} +} + +func UnsafeNewScintilla__RangeToFormat(h unsafe.Pointer) *Scintilla__RangeToFormat { + return newScintilla__RangeToFormat((*C.Scintilla__RangeToFormat)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__RangeToFormat) Delete() { + C.Scintilla__RangeToFormat_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__RangeToFormat) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__RangeToFormat) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__RangeToFormatFull struct { + h *C.Scintilla__RangeToFormatFull +} + +func (this *Scintilla__RangeToFormatFull) cPointer() *C.Scintilla__RangeToFormatFull { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__RangeToFormatFull) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__RangeToFormatFull(h *C.Scintilla__RangeToFormatFull) *Scintilla__RangeToFormatFull { + if h == nil { + return nil + } + return &Scintilla__RangeToFormatFull{h: h} +} + +func UnsafeNewScintilla__RangeToFormatFull(h unsafe.Pointer) *Scintilla__RangeToFormatFull { + return newScintilla__RangeToFormatFull((*C.Scintilla__RangeToFormatFull)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__RangeToFormatFull) Delete() { + C.Scintilla__RangeToFormatFull_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__RangeToFormatFull) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__RangeToFormatFull) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__NotifyHeader struct { + h *C.Scintilla__NotifyHeader +} + +func (this *Scintilla__NotifyHeader) cPointer() *C.Scintilla__NotifyHeader { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__NotifyHeader) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__NotifyHeader(h *C.Scintilla__NotifyHeader) *Scintilla__NotifyHeader { + if h == nil { + return nil + } + return &Scintilla__NotifyHeader{h: h} +} + +func UnsafeNewScintilla__NotifyHeader(h unsafe.Pointer) *Scintilla__NotifyHeader { + return newScintilla__NotifyHeader((*C.Scintilla__NotifyHeader)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__NotifyHeader) Delete() { + C.Scintilla__NotifyHeader_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__NotifyHeader) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__NotifyHeader) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__NotificationData struct { + h *C.Scintilla__NotificationData +} + +func (this *Scintilla__NotificationData) cPointer() *C.Scintilla__NotificationData { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__NotificationData) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__NotificationData(h *C.Scintilla__NotificationData) *Scintilla__NotificationData { + if h == nil { + return nil + } + return &Scintilla__NotificationData{h: h} +} + +func UnsafeNewScintilla__NotificationData(h unsafe.Pointer) *Scintilla__NotificationData { + return newScintilla__NotificationData((*C.Scintilla__NotificationData)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__NotificationData) Delete() { + C.Scintilla__NotificationData_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__NotificationData) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__NotificationData) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__FontParameters struct { + h *C.Scintilla__Internal__FontParameters +} + +func (this *Scintilla__Internal__FontParameters) cPointer() *C.Scintilla__Internal__FontParameters { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__FontParameters) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__FontParameters(h *C.Scintilla__Internal__FontParameters) *Scintilla__Internal__FontParameters { + if h == nil { + return nil + } + return &Scintilla__Internal__FontParameters{h: h} +} + +func UnsafeNewScintilla__Internal__FontParameters(h unsafe.Pointer) *Scintilla__Internal__FontParameters { + return newScintilla__Internal__FontParameters((*C.Scintilla__Internal__FontParameters)(h)) +} + +// NewScintilla__Internal__FontParameters constructs a new Scintilla::Internal::FontParameters object. +func NewScintilla__Internal__FontParameters(faceName_ string) *Scintilla__Internal__FontParameters { + faceName__Cstring := C.CString(faceName_) + defer C.free(unsafe.Pointer(faceName__Cstring)) + ret := C.Scintilla__Internal__FontParameters_new(faceName__Cstring) + return newScintilla__Internal__FontParameters(ret) +} + +// NewScintilla__Internal__FontParameters2 constructs a new Scintilla::Internal::FontParameters object. +func NewScintilla__Internal__FontParameters2(faceName_ string, size_ float64) *Scintilla__Internal__FontParameters { + faceName__Cstring := C.CString(faceName_) + defer C.free(unsafe.Pointer(faceName__Cstring)) + ret := C.Scintilla__Internal__FontParameters_new2(faceName__Cstring, (C.double)(size_)) + return newScintilla__Internal__FontParameters(ret) +} + +// NewScintilla__Internal__FontParameters3 constructs a new Scintilla::Internal::FontParameters object. +func NewScintilla__Internal__FontParameters3(faceName_ string, size_ float64, weight_ Scintilla__FontWeight) *Scintilla__Internal__FontParameters { + faceName__Cstring := C.CString(faceName_) + defer C.free(unsafe.Pointer(faceName__Cstring)) + ret := C.Scintilla__Internal__FontParameters_new3(faceName__Cstring, (C.double)(size_), (C.int)(weight_)) + return newScintilla__Internal__FontParameters(ret) +} + +// NewScintilla__Internal__FontParameters4 constructs a new Scintilla::Internal::FontParameters object. +func NewScintilla__Internal__FontParameters4(faceName_ string, size_ float64, weight_ Scintilla__FontWeight, italic_ bool) *Scintilla__Internal__FontParameters { + faceName__Cstring := C.CString(faceName_) + defer C.free(unsafe.Pointer(faceName__Cstring)) + ret := C.Scintilla__Internal__FontParameters_new4(faceName__Cstring, (C.double)(size_), (C.int)(weight_), (C.bool)(italic_)) + return newScintilla__Internal__FontParameters(ret) +} + +// NewScintilla__Internal__FontParameters5 constructs a new Scintilla::Internal::FontParameters object. +func NewScintilla__Internal__FontParameters5(faceName_ string, size_ float64, weight_ Scintilla__FontWeight, italic_ bool, extraFontFlag_ Scintilla__FontQuality) *Scintilla__Internal__FontParameters { + faceName__Cstring := C.CString(faceName_) + defer C.free(unsafe.Pointer(faceName__Cstring)) + ret := C.Scintilla__Internal__FontParameters_new5(faceName__Cstring, (C.double)(size_), (C.int)(weight_), (C.bool)(italic_), (C.int)(extraFontFlag_)) + return newScintilla__Internal__FontParameters(ret) +} + +// NewScintilla__Internal__FontParameters6 constructs a new Scintilla::Internal::FontParameters object. +func NewScintilla__Internal__FontParameters6(faceName_ string, size_ float64, weight_ Scintilla__FontWeight, italic_ bool, extraFontFlag_ Scintilla__FontQuality, technology_ Scintilla__Technology) *Scintilla__Internal__FontParameters { + faceName__Cstring := C.CString(faceName_) + defer C.free(unsafe.Pointer(faceName__Cstring)) + ret := C.Scintilla__Internal__FontParameters_new6(faceName__Cstring, (C.double)(size_), (C.int)(weight_), (C.bool)(italic_), (C.int)(extraFontFlag_), (C.int)(technology_)) + return newScintilla__Internal__FontParameters(ret) +} + +// NewScintilla__Internal__FontParameters7 constructs a new Scintilla::Internal::FontParameters object. +func NewScintilla__Internal__FontParameters7(faceName_ string, size_ float64, weight_ Scintilla__FontWeight, italic_ bool, extraFontFlag_ Scintilla__FontQuality, technology_ Scintilla__Technology, characterSet_ Scintilla__CharacterSet) *Scintilla__Internal__FontParameters { + faceName__Cstring := C.CString(faceName_) + defer C.free(unsafe.Pointer(faceName__Cstring)) + ret := C.Scintilla__Internal__FontParameters_new7(faceName__Cstring, (C.double)(size_), (C.int)(weight_), (C.bool)(italic_), (C.int)(extraFontFlag_), (C.int)(technology_), (C.int)(characterSet_)) + return newScintilla__Internal__FontParameters(ret) +} + +// NewScintilla__Internal__FontParameters8 constructs a new Scintilla::Internal::FontParameters object. +func NewScintilla__Internal__FontParameters8(faceName_ string, size_ float64, weight_ Scintilla__FontWeight, italic_ bool, extraFontFlag_ Scintilla__FontQuality, technology_ Scintilla__Technology, characterSet_ Scintilla__CharacterSet, localeName_ string) *Scintilla__Internal__FontParameters { + faceName__Cstring := C.CString(faceName_) + defer C.free(unsafe.Pointer(faceName__Cstring)) + localeName__Cstring := C.CString(localeName_) + defer C.free(unsafe.Pointer(localeName__Cstring)) + ret := C.Scintilla__Internal__FontParameters_new8(faceName__Cstring, (C.double)(size_), (C.int)(weight_), (C.bool)(italic_), (C.int)(extraFontFlag_), (C.int)(technology_), (C.int)(characterSet_), localeName__Cstring) + return newScintilla__Internal__FontParameters(ret) +} + +// NewScintilla__Internal__FontParameters9 constructs a new Scintilla::Internal::FontParameters object. +func NewScintilla__Internal__FontParameters9(faceName_ string, size_ float64, weight_ Scintilla__FontWeight, italic_ bool, extraFontFlag_ Scintilla__FontQuality, technology_ Scintilla__Technology, characterSet_ Scintilla__CharacterSet, localeName_ string, stretch_ Scintilla__FontStretch) *Scintilla__Internal__FontParameters { + faceName__Cstring := C.CString(faceName_) + defer C.free(unsafe.Pointer(faceName__Cstring)) + localeName__Cstring := C.CString(localeName_) + defer C.free(unsafe.Pointer(localeName__Cstring)) + ret := C.Scintilla__Internal__FontParameters_new9(faceName__Cstring, (C.double)(size_), (C.int)(weight_), (C.bool)(italic_), (C.int)(extraFontFlag_), (C.int)(technology_), (C.int)(characterSet_), localeName__Cstring, (C.int)(stretch_)) + return newScintilla__Internal__FontParameters(ret) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__FontParameters) Delete() { + C.Scintilla__Internal__FontParameters_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__FontParameters) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__FontParameters) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__Font struct { + h *C.Scintilla__Internal__Font +} + +func (this *Scintilla__Internal__Font) cPointer() *C.Scintilla__Internal__Font { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__Font) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__Font(h *C.Scintilla__Internal__Font) *Scintilla__Internal__Font { + if h == nil { + return nil + } + return &Scintilla__Internal__Font{h: h} +} + +func UnsafeNewScintilla__Internal__Font(h unsafe.Pointer) *Scintilla__Internal__Font { + return newScintilla__Internal__Font((*C.Scintilla__Internal__Font)(h)) +} + +// NewScintilla__Internal__Font constructs a new Scintilla::Internal::Font object. +func NewScintilla__Internal__Font() *Scintilla__Internal__Font { + ret := C.Scintilla__Internal__Font_new() + return newScintilla__Internal__Font(ret) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__Font) Delete() { + C.Scintilla__Internal__Font_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__Font) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__Font) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__IScreenLine struct { + h *C.Scintilla__Internal__IScreenLine +} + +func (this *Scintilla__Internal__IScreenLine) cPointer() *C.Scintilla__Internal__IScreenLine { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__IScreenLine) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__IScreenLine(h *C.Scintilla__Internal__IScreenLine) *Scintilla__Internal__IScreenLine { + if h == nil { + return nil + } + return &Scintilla__Internal__IScreenLine{h: h} +} + +func UnsafeNewScintilla__Internal__IScreenLine(h unsafe.Pointer) *Scintilla__Internal__IScreenLine { + return newScintilla__Internal__IScreenLine((*C.Scintilla__Internal__IScreenLine)(h)) +} + +func (this *Scintilla__Internal__IScreenLine) Length() uint64 { + return (uint64)(C.Scintilla__Internal__IScreenLine_Length(this.h)) +} + +func (this *Scintilla__Internal__IScreenLine) RepresentationCount() uint64 { + return (uint64)(C.Scintilla__Internal__IScreenLine_RepresentationCount(this.h)) +} + +func (this *Scintilla__Internal__IScreenLine) Width() float64 { + return (float64)(C.Scintilla__Internal__IScreenLine_Width(this.h)) +} + +func (this *Scintilla__Internal__IScreenLine) Height() float64 { + return (float64)(C.Scintilla__Internal__IScreenLine_Height(this.h)) +} + +func (this *Scintilla__Internal__IScreenLine) TabWidth() float64 { + return (float64)(C.Scintilla__Internal__IScreenLine_TabWidth(this.h)) +} + +func (this *Scintilla__Internal__IScreenLine) TabWidthMinimumPixels() float64 { + return (float64)(C.Scintilla__Internal__IScreenLine_TabWidthMinimumPixels(this.h)) +} + +func (this *Scintilla__Internal__IScreenLine) FontOfPosition(position uint64) *Scintilla__Internal__Font { + return UnsafeNewScintilla__Internal__Font(unsafe.Pointer(C.Scintilla__Internal__IScreenLine_FontOfPosition(this.h, (C.size_t)(position)))) +} + +func (this *Scintilla__Internal__IScreenLine) RepresentationWidth(position uint64) float64 { + return (float64)(C.Scintilla__Internal__IScreenLine_RepresentationWidth(this.h, (C.size_t)(position))) +} + +func (this *Scintilla__Internal__IScreenLine) TabPositionAfter(xPosition float64) float64 { + return (float64)(C.Scintilla__Internal__IScreenLine_TabPositionAfter(this.h, (C.double)(xPosition))) +} + +func (this *Scintilla__Internal__IScreenLine) OperatorAssign(param1 *Scintilla__Internal__IScreenLine) { + C.Scintilla__Internal__IScreenLine_OperatorAssign(this.h, param1.cPointer()) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__IScreenLine) Delete() { + C.Scintilla__Internal__IScreenLine_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__IScreenLine) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__IScreenLine) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__IScreenLineLayout struct { + h *C.Scintilla__Internal__IScreenLineLayout +} + +func (this *Scintilla__Internal__IScreenLineLayout) cPointer() *C.Scintilla__Internal__IScreenLineLayout { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__IScreenLineLayout) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__IScreenLineLayout(h *C.Scintilla__Internal__IScreenLineLayout) *Scintilla__Internal__IScreenLineLayout { + if h == nil { + return nil + } + return &Scintilla__Internal__IScreenLineLayout{h: h} +} + +func UnsafeNewScintilla__Internal__IScreenLineLayout(h unsafe.Pointer) *Scintilla__Internal__IScreenLineLayout { + return newScintilla__Internal__IScreenLineLayout((*C.Scintilla__Internal__IScreenLineLayout)(h)) +} + +func (this *Scintilla__Internal__IScreenLineLayout) PositionFromX(xDistance float64, charPosition bool) uint64 { + return (uint64)(C.Scintilla__Internal__IScreenLineLayout_PositionFromX(this.h, (C.double)(xDistance), (C.bool)(charPosition))) +} + +func (this *Scintilla__Internal__IScreenLineLayout) XFromPosition(caretPosition uint64) float64 { + return (float64)(C.Scintilla__Internal__IScreenLineLayout_XFromPosition(this.h, (C.size_t)(caretPosition))) +} + +func (this *Scintilla__Internal__IScreenLineLayout) OperatorAssign(param1 *Scintilla__Internal__IScreenLineLayout) { + C.Scintilla__Internal__IScreenLineLayout_OperatorAssign(this.h, param1.cPointer()) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__IScreenLineLayout) Delete() { + C.Scintilla__Internal__IScreenLineLayout_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__IScreenLineLayout) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__IScreenLineLayout) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__SurfaceMode struct { + h *C.Scintilla__Internal__SurfaceMode +} + +func (this *Scintilla__Internal__SurfaceMode) cPointer() *C.Scintilla__Internal__SurfaceMode { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__SurfaceMode) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__SurfaceMode(h *C.Scintilla__Internal__SurfaceMode) *Scintilla__Internal__SurfaceMode { + if h == nil { + return nil + } + return &Scintilla__Internal__SurfaceMode{h: h} +} + +func UnsafeNewScintilla__Internal__SurfaceMode(h unsafe.Pointer) *Scintilla__Internal__SurfaceMode { + return newScintilla__Internal__SurfaceMode((*C.Scintilla__Internal__SurfaceMode)(h)) +} + +// NewScintilla__Internal__SurfaceMode constructs a new Scintilla::Internal::SurfaceMode object. +func NewScintilla__Internal__SurfaceMode() *Scintilla__Internal__SurfaceMode { + ret := C.Scintilla__Internal__SurfaceMode_new() + return newScintilla__Internal__SurfaceMode(ret) +} + +// NewScintilla__Internal__SurfaceMode2 constructs a new Scintilla::Internal::SurfaceMode object. +func NewScintilla__Internal__SurfaceMode2(codePage_ int, bidiR2L_ bool) *Scintilla__Internal__SurfaceMode { + ret := C.Scintilla__Internal__SurfaceMode_new2((C.int)(codePage_), (C.bool)(bidiR2L_)) + return newScintilla__Internal__SurfaceMode(ret) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__SurfaceMode) Delete() { + C.Scintilla__Internal__SurfaceMode_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__SurfaceMode) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__SurfaceMode) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__Surface struct { + h *C.Scintilla__Internal__Surface +} + +func (this *Scintilla__Internal__Surface) cPointer() *C.Scintilla__Internal__Surface { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__Surface) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__Surface(h *C.Scintilla__Internal__Surface) *Scintilla__Internal__Surface { + if h == nil { + return nil + } + return &Scintilla__Internal__Surface{h: h} +} + +func UnsafeNewScintilla__Internal__Surface(h unsafe.Pointer) *Scintilla__Internal__Surface { + return newScintilla__Internal__Surface((*C.Scintilla__Internal__Surface)(h)) +} + +func (this *Scintilla__Internal__Surface) Init(wid unsafe.Pointer) { + C.Scintilla__Internal__Surface_Init(this.h, wid) +} + +func (this *Scintilla__Internal__Surface) Init2(sid unsafe.Pointer, wid unsafe.Pointer) { + C.Scintilla__Internal__Surface_Init2(this.h, sid, wid) +} + +func (this *Scintilla__Internal__Surface) SetMode(mode Scintilla__Internal__SurfaceMode) { + C.Scintilla__Internal__Surface_SetMode(this.h, mode.cPointer()) +} + +func (this *Scintilla__Internal__Surface) Release() { + C.Scintilla__Internal__Surface_Release(this.h) +} + +func (this *Scintilla__Internal__Surface) SupportsFeature(feature Scintilla__Supports) int { + return (int)(C.Scintilla__Internal__Surface_SupportsFeature(this.h, (C.int)(feature))) +} + +func (this *Scintilla__Internal__Surface) Initialised() bool { + return (bool)(C.Scintilla__Internal__Surface_Initialised(this.h)) +} + +func (this *Scintilla__Internal__Surface) LogPixelsY() int { + return (int)(C.Scintilla__Internal__Surface_LogPixelsY(this.h)) +} + +func (this *Scintilla__Internal__Surface) PixelDivisions() int { + return (int)(C.Scintilla__Internal__Surface_PixelDivisions(this.h)) +} + +func (this *Scintilla__Internal__Surface) DeviceHeightFont(points int) int { + return (int)(C.Scintilla__Internal__Surface_DeviceHeightFont(this.h, (C.int)(points))) +} + +func (this *Scintilla__Internal__Surface) LineDraw(start Scintilla__Internal__Point, end Scintilla__Internal__Point, stroke Scintilla__Internal__Stroke) { + C.Scintilla__Internal__Surface_LineDraw(this.h, start.cPointer(), end.cPointer(), stroke.cPointer()) +} + +func (this *Scintilla__Internal__Surface) PolyLine(pts *Scintilla__Internal__Point, npts uint64, stroke Scintilla__Internal__Stroke) { + C.Scintilla__Internal__Surface_PolyLine(this.h, pts.cPointer(), (C.size_t)(npts), stroke.cPointer()) +} + +func (this *Scintilla__Internal__Surface) Polygon(pts *Scintilla__Internal__Point, npts uint64, fillStroke Scintilla__Internal__FillStroke) { + C.Scintilla__Internal__Surface_Polygon(this.h, pts.cPointer(), (C.size_t)(npts), fillStroke.cPointer()) +} + +func (this *Scintilla__Internal__Surface) RectangleDraw(rc Scintilla__Internal__PRectangle, fillStroke Scintilla__Internal__FillStroke) { + C.Scintilla__Internal__Surface_RectangleDraw(this.h, rc.cPointer(), fillStroke.cPointer()) +} + +func (this *Scintilla__Internal__Surface) RectangleFrame(rc Scintilla__Internal__PRectangle, stroke Scintilla__Internal__Stroke) { + C.Scintilla__Internal__Surface_RectangleFrame(this.h, rc.cPointer(), stroke.cPointer()) +} + +func (this *Scintilla__Internal__Surface) FillRectangle(rc Scintilla__Internal__PRectangle, fill Scintilla__Internal__Fill) { + C.Scintilla__Internal__Surface_FillRectangle(this.h, rc.cPointer(), fill.cPointer()) +} + +func (this *Scintilla__Internal__Surface) FillRectangleAligned(rc Scintilla__Internal__PRectangle, fill Scintilla__Internal__Fill) { + C.Scintilla__Internal__Surface_FillRectangleAligned(this.h, rc.cPointer(), fill.cPointer()) +} + +func (this *Scintilla__Internal__Surface) FillRectangle2(rc Scintilla__Internal__PRectangle, surfacePattern *Scintilla__Internal__Surface) { + C.Scintilla__Internal__Surface_FillRectangle2(this.h, rc.cPointer(), surfacePattern.cPointer()) +} + +func (this *Scintilla__Internal__Surface) RoundedRectangle(rc Scintilla__Internal__PRectangle, fillStroke Scintilla__Internal__FillStroke) { + C.Scintilla__Internal__Surface_RoundedRectangle(this.h, rc.cPointer(), fillStroke.cPointer()) +} + +func (this *Scintilla__Internal__Surface) AlphaRectangle(rc Scintilla__Internal__PRectangle, cornerSize float64, fillStroke Scintilla__Internal__FillStroke) { + C.Scintilla__Internal__Surface_AlphaRectangle(this.h, rc.cPointer(), (C.double)(cornerSize), fillStroke.cPointer()) +} + +func (this *Scintilla__Internal__Surface) DrawRGBAImage(rc Scintilla__Internal__PRectangle, width int, height int, pixelsImage *byte) { + C.Scintilla__Internal__Surface_DrawRGBAImage(this.h, rc.cPointer(), (C.int)(width), (C.int)(height), (*C.uchar)(unsafe.Pointer(pixelsImage))) +} + +func (this *Scintilla__Internal__Surface) Ellipse(rc Scintilla__Internal__PRectangle, fillStroke Scintilla__Internal__FillStroke) { + C.Scintilla__Internal__Surface_Ellipse(this.h, rc.cPointer(), fillStroke.cPointer()) +} + +func (this *Scintilla__Internal__Surface) Stadium(rc Scintilla__Internal__PRectangle, fillStroke Scintilla__Internal__FillStroke, ends Scintilla__Internal__Surface__Ends) { + C.Scintilla__Internal__Surface_Stadium(this.h, rc.cPointer(), fillStroke.cPointer(), (C.int)(ends)) +} + +func (this *Scintilla__Internal__Surface) Copy(rc Scintilla__Internal__PRectangle, from Scintilla__Internal__Point, surfaceSource *Scintilla__Internal__Surface) { + C.Scintilla__Internal__Surface_Copy(this.h, rc.cPointer(), from.cPointer(), surfaceSource.cPointer()) +} + +func (this *Scintilla__Internal__Surface) Ascent(font_ *Scintilla__Internal__Font) float64 { + return (float64)(C.Scintilla__Internal__Surface_Ascent(this.h, font_.cPointer())) +} + +func (this *Scintilla__Internal__Surface) Descent(font_ *Scintilla__Internal__Font) float64 { + return (float64)(C.Scintilla__Internal__Surface_Descent(this.h, font_.cPointer())) +} + +func (this *Scintilla__Internal__Surface) InternalLeading(font_ *Scintilla__Internal__Font) float64 { + return (float64)(C.Scintilla__Internal__Surface_InternalLeading(this.h, font_.cPointer())) +} + +func (this *Scintilla__Internal__Surface) Height(font_ *Scintilla__Internal__Font) float64 { + return (float64)(C.Scintilla__Internal__Surface_Height(this.h, font_.cPointer())) +} + +func (this *Scintilla__Internal__Surface) AverageCharWidth(font_ *Scintilla__Internal__Font) float64 { + return (float64)(C.Scintilla__Internal__Surface_AverageCharWidth(this.h, font_.cPointer())) +} + +func (this *Scintilla__Internal__Surface) SetClip(rc Scintilla__Internal__PRectangle) { + C.Scintilla__Internal__Surface_SetClip(this.h, rc.cPointer()) +} + +func (this *Scintilla__Internal__Surface) PopClip() { + C.Scintilla__Internal__Surface_PopClip(this.h) +} + +func (this *Scintilla__Internal__Surface) FlushCachedState() { + C.Scintilla__Internal__Surface_FlushCachedState(this.h) +} + +func (this *Scintilla__Internal__Surface) FlushDrawing() { + C.Scintilla__Internal__Surface_FlushDrawing(this.h) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__Surface) Delete() { + C.Scintilla__Internal__Surface_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__Surface) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__Surface) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__Window struct { + h *C.Scintilla__Internal__Window +} + +func (this *Scintilla__Internal__Window) cPointer() *C.Scintilla__Internal__Window { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__Window) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__Window(h *C.Scintilla__Internal__Window) *Scintilla__Internal__Window { + if h == nil { + return nil + } + return &Scintilla__Internal__Window{h: h} +} + +func UnsafeNewScintilla__Internal__Window(h unsafe.Pointer) *Scintilla__Internal__Window { + return newScintilla__Internal__Window((*C.Scintilla__Internal__Window)(h)) +} + +// NewScintilla__Internal__Window constructs a new Scintilla::Internal::Window object. +func NewScintilla__Internal__Window() *Scintilla__Internal__Window { + ret := C.Scintilla__Internal__Window_new() + return newScintilla__Internal__Window(ret) +} + +func (this *Scintilla__Internal__Window) OperatorAssign(wid_ unsafe.Pointer) { + C.Scintilla__Internal__Window_OperatorAssign(this.h, wid_) +} + +func (this *Scintilla__Internal__Window) GetID() unsafe.Pointer { + return (unsafe.Pointer)(C.Scintilla__Internal__Window_GetID(this.h)) +} + +func (this *Scintilla__Internal__Window) Created() bool { + return (bool)(C.Scintilla__Internal__Window_Created(this.h)) +} + +func (this *Scintilla__Internal__Window) Destroy() { + C.Scintilla__Internal__Window_Destroy(this.h) +} + +func (this *Scintilla__Internal__Window) GetPosition() *Scintilla__Internal__PRectangle { + _ret := C.Scintilla__Internal__Window_GetPosition(this.h) + _goptr := newScintilla__Internal__PRectangle(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__Window) SetPosition(rc Scintilla__Internal__PRectangle) { + C.Scintilla__Internal__Window_SetPosition(this.h, rc.cPointer()) +} + +func (this *Scintilla__Internal__Window) SetPositionRelative(rc Scintilla__Internal__PRectangle, relativeTo *Scintilla__Internal__Window) { + C.Scintilla__Internal__Window_SetPositionRelative(this.h, rc.cPointer(), relativeTo.cPointer()) +} + +func (this *Scintilla__Internal__Window) GetClientPosition() *Scintilla__Internal__PRectangle { + _ret := C.Scintilla__Internal__Window_GetClientPosition(this.h) + _goptr := newScintilla__Internal__PRectangle(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__Window) Show() { + C.Scintilla__Internal__Window_Show(this.h) +} + +func (this *Scintilla__Internal__Window) InvalidateAll() { + C.Scintilla__Internal__Window_InvalidateAll(this.h) +} + +func (this *Scintilla__Internal__Window) InvalidateRectangle(rc Scintilla__Internal__PRectangle) { + C.Scintilla__Internal__Window_InvalidateRectangle(this.h, rc.cPointer()) +} + +func (this *Scintilla__Internal__Window) SetCursor(curs Scintilla__Internal__Window__Cursor) { + C.Scintilla__Internal__Window_SetCursor(this.h, (C.int)(curs)) +} + +func (this *Scintilla__Internal__Window) GetMonitorRect(pt Scintilla__Internal__Point) *Scintilla__Internal__PRectangle { + _ret := C.Scintilla__Internal__Window_GetMonitorRect(this.h, pt.cPointer()) + _goptr := newScintilla__Internal__PRectangle(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__Window) Show1(show bool) { + C.Scintilla__Internal__Window_Show1(this.h, (C.bool)(show)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__Window) Delete() { + C.Scintilla__Internal__Window_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__Window) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__Window) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__ListBoxEvent struct { + h *C.Scintilla__Internal__ListBoxEvent +} + +func (this *Scintilla__Internal__ListBoxEvent) cPointer() *C.Scintilla__Internal__ListBoxEvent { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__ListBoxEvent) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__ListBoxEvent(h *C.Scintilla__Internal__ListBoxEvent) *Scintilla__Internal__ListBoxEvent { + if h == nil { + return nil + } + return &Scintilla__Internal__ListBoxEvent{h: h} +} + +func UnsafeNewScintilla__Internal__ListBoxEvent(h unsafe.Pointer) *Scintilla__Internal__ListBoxEvent { + return newScintilla__Internal__ListBoxEvent((*C.Scintilla__Internal__ListBoxEvent)(h)) +} + +// NewScintilla__Internal__ListBoxEvent constructs a new Scintilla::Internal::ListBoxEvent object. +func NewScintilla__Internal__ListBoxEvent(event_ Scintilla__Internal__ListBoxEvent__EventType) *Scintilla__Internal__ListBoxEvent { + ret := C.Scintilla__Internal__ListBoxEvent_new((C.int)(event_)) + return newScintilla__Internal__ListBoxEvent(ret) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__ListBoxEvent) Delete() { + C.Scintilla__Internal__ListBoxEvent_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__ListBoxEvent) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__ListBoxEvent) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__IListBoxDelegate struct { + h *C.Scintilla__Internal__IListBoxDelegate +} + +func (this *Scintilla__Internal__IListBoxDelegate) cPointer() *C.Scintilla__Internal__IListBoxDelegate { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__IListBoxDelegate) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__IListBoxDelegate(h *C.Scintilla__Internal__IListBoxDelegate) *Scintilla__Internal__IListBoxDelegate { + if h == nil { + return nil + } + return &Scintilla__Internal__IListBoxDelegate{h: h} +} + +func UnsafeNewScintilla__Internal__IListBoxDelegate(h unsafe.Pointer) *Scintilla__Internal__IListBoxDelegate { + return newScintilla__Internal__IListBoxDelegate((*C.Scintilla__Internal__IListBoxDelegate)(h)) +} + +func (this *Scintilla__Internal__IListBoxDelegate) ListNotify(plbe *Scintilla__Internal__ListBoxEvent) { + C.Scintilla__Internal__IListBoxDelegate_ListNotify(this.h, plbe.cPointer()) +} + +func (this *Scintilla__Internal__IListBoxDelegate) OperatorAssign(param1 *Scintilla__Internal__IListBoxDelegate) { + C.Scintilla__Internal__IListBoxDelegate_OperatorAssign(this.h, param1.cPointer()) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__IListBoxDelegate) Delete() { + C.Scintilla__Internal__IListBoxDelegate_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__IListBoxDelegate) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__IListBoxDelegate) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__ListOptions struct { + h *C.Scintilla__Internal__ListOptions +} + +func (this *Scintilla__Internal__ListOptions) cPointer() *C.Scintilla__Internal__ListOptions { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__ListOptions) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__ListOptions(h *C.Scintilla__Internal__ListOptions) *Scintilla__Internal__ListOptions { + if h == nil { + return nil + } + return &Scintilla__Internal__ListOptions{h: h} +} + +func UnsafeNewScintilla__Internal__ListOptions(h unsafe.Pointer) *Scintilla__Internal__ListOptions { + return newScintilla__Internal__ListOptions((*C.Scintilla__Internal__ListOptions)(h)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__ListOptions) Delete() { + C.Scintilla__Internal__ListOptions_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__ListOptions) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__ListOptions) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__ListBox struct { + h *C.Scintilla__Internal__ListBox + *Scintilla__Internal__Window +} + +func (this *Scintilla__Internal__ListBox) cPointer() *C.Scintilla__Internal__ListBox { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__ListBox) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__ListBox(h *C.Scintilla__Internal__ListBox) *Scintilla__Internal__ListBox { + if h == nil { + return nil + } + return &Scintilla__Internal__ListBox{h: h, Scintilla__Internal__Window: UnsafeNewScintilla__Internal__Window(unsafe.Pointer(h))} +} + +func UnsafeNewScintilla__Internal__ListBox(h unsafe.Pointer) *Scintilla__Internal__ListBox { + return newScintilla__Internal__ListBox((*C.Scintilla__Internal__ListBox)(h)) +} + +func (this *Scintilla__Internal__ListBox) SetFont(font *Scintilla__Internal__Font) { + C.Scintilla__Internal__ListBox_SetFont(this.h, font.cPointer()) +} + +func (this *Scintilla__Internal__ListBox) Create(parent *Scintilla__Internal__Window, ctrlID int, location Scintilla__Internal__Point, lineHeight_ int, unicodeMode_ bool, technology_ Scintilla__Technology) { + C.Scintilla__Internal__ListBox_Create(this.h, parent.cPointer(), (C.int)(ctrlID), location.cPointer(), (C.int)(lineHeight_), (C.bool)(unicodeMode_), (C.int)(technology_)) +} + +func (this *Scintilla__Internal__ListBox) SetAverageCharWidth(width int) { + C.Scintilla__Internal__ListBox_SetAverageCharWidth(this.h, (C.int)(width)) +} + +func (this *Scintilla__Internal__ListBox) SetVisibleRows(rows int) { + C.Scintilla__Internal__ListBox_SetVisibleRows(this.h, (C.int)(rows)) +} + +func (this *Scintilla__Internal__ListBox) GetVisibleRows() int { + return (int)(C.Scintilla__Internal__ListBox_GetVisibleRows(this.h)) +} + +func (this *Scintilla__Internal__ListBox) GetDesiredRect() *Scintilla__Internal__PRectangle { + _ret := C.Scintilla__Internal__ListBox_GetDesiredRect(this.h) + _goptr := newScintilla__Internal__PRectangle(_ret) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *Scintilla__Internal__ListBox) CaretFromEdge() int { + return (int)(C.Scintilla__Internal__ListBox_CaretFromEdge(this.h)) +} + +func (this *Scintilla__Internal__ListBox) Clear() { + C.Scintilla__Internal__ListBox_Clear(this.h) +} + +func (this *Scintilla__Internal__ListBox) Append(s string) { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + C.Scintilla__Internal__ListBox_Append(this.h, s_Cstring) +} + +func (this *Scintilla__Internal__ListBox) Length() int { + return (int)(C.Scintilla__Internal__ListBox_Length(this.h)) +} + +func (this *Scintilla__Internal__ListBox) Select(n int) { + C.Scintilla__Internal__ListBox_Select(this.h, (C.int)(n)) +} + +func (this *Scintilla__Internal__ListBox) GetSelection() int { + return (int)(C.Scintilla__Internal__ListBox_GetSelection(this.h)) +} + +func (this *Scintilla__Internal__ListBox) Find(prefix string) int { + prefix_Cstring := C.CString(prefix) + defer C.free(unsafe.Pointer(prefix_Cstring)) + return (int)(C.Scintilla__Internal__ListBox_Find(this.h, prefix_Cstring)) +} + +func (this *Scintilla__Internal__ListBox) RegisterImage(typeVal int, xpm_data string) { + xpm_data_Cstring := C.CString(xpm_data) + defer C.free(unsafe.Pointer(xpm_data_Cstring)) + C.Scintilla__Internal__ListBox_RegisterImage(this.h, (C.int)(typeVal), xpm_data_Cstring) +} + +func (this *Scintilla__Internal__ListBox) RegisterRGBAImage(typeVal int, width int, height int, pixelsImage *byte) { + C.Scintilla__Internal__ListBox_RegisterRGBAImage(this.h, (C.int)(typeVal), (C.int)(width), (C.int)(height), (*C.uchar)(unsafe.Pointer(pixelsImage))) +} + +func (this *Scintilla__Internal__ListBox) ClearRegisteredImages() { + C.Scintilla__Internal__ListBox_ClearRegisteredImages(this.h) +} + +func (this *Scintilla__Internal__ListBox) SetDelegate(lbDelegate *Scintilla__Internal__IListBoxDelegate) { + C.Scintilla__Internal__ListBox_SetDelegate(this.h, lbDelegate.cPointer()) +} + +func (this *Scintilla__Internal__ListBox) SetList(list string, separator int8, typesep int8) { + list_Cstring := C.CString(list) + defer C.free(unsafe.Pointer(list_Cstring)) + C.Scintilla__Internal__ListBox_SetList(this.h, list_Cstring, (C.char)(separator), (C.char)(typesep)) +} + +func (this *Scintilla__Internal__ListBox) SetOptions(options_ Scintilla__Internal__ListOptions) { + C.Scintilla__Internal__ListBox_SetOptions(this.h, options_.cPointer()) +} + +func (this *Scintilla__Internal__ListBox) Append2(s string, typeVal int) { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + C.Scintilla__Internal__ListBox_Append2(this.h, s_Cstring, (C.int)(typeVal)) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__ListBox) Delete() { + C.Scintilla__Internal__ListBox_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__ListBox) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__ListBox) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Scintilla__Internal__Menu struct { + h *C.Scintilla__Internal__Menu +} + +func (this *Scintilla__Internal__Menu) cPointer() *C.Scintilla__Internal__Menu { + if this == nil { + return nil + } + return this.h +} + +func (this *Scintilla__Internal__Menu) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintilla__Internal__Menu(h *C.Scintilla__Internal__Menu) *Scintilla__Internal__Menu { + if h == nil { + return nil + } + return &Scintilla__Internal__Menu{h: h} +} + +func UnsafeNewScintilla__Internal__Menu(h unsafe.Pointer) *Scintilla__Internal__Menu { + return newScintilla__Internal__Menu((*C.Scintilla__Internal__Menu)(h)) +} + +// NewScintilla__Internal__Menu constructs a new Scintilla::Internal::Menu object. +func NewScintilla__Internal__Menu() *Scintilla__Internal__Menu { + ret := C.Scintilla__Internal__Menu_new() + return newScintilla__Internal__Menu(ret) +} + +func (this *Scintilla__Internal__Menu) GetID() unsafe.Pointer { + return (unsafe.Pointer)(C.Scintilla__Internal__Menu_GetID(this.h)) +} + +func (this *Scintilla__Internal__Menu) CreatePopUp() { + C.Scintilla__Internal__Menu_CreatePopUp(this.h) +} + +func (this *Scintilla__Internal__Menu) Destroy() { + C.Scintilla__Internal__Menu_Destroy(this.h) +} + +func (this *Scintilla__Internal__Menu) Show(pt Scintilla__Internal__Point, w *Scintilla__Internal__Window) { + C.Scintilla__Internal__Menu_Show(this.h, pt.cPointer(), w.cPointer()) +} + +// Delete this object from C++ memory. +func (this *Scintilla__Internal__Menu) Delete() { + C.Scintilla__Internal__Menu_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Scintilla__Internal__Menu) GoGC() { + runtime.SetFinalizer(this, func(this *Scintilla__Internal__Menu) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_CharacterRange struct { + h *C.Sci_CharacterRange +} + +func (this *Sci_CharacterRange) cPointer() *C.Sci_CharacterRange { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_CharacterRange) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_CharacterRange(h *C.Sci_CharacterRange) *Sci_CharacterRange { + if h == nil { + return nil + } + return &Sci_CharacterRange{h: h} +} + +func UnsafeNewSci_CharacterRange(h unsafe.Pointer) *Sci_CharacterRange { + return newSci_CharacterRange((*C.Sci_CharacterRange)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_CharacterRange) Delete() { + C.Sci_CharacterRange_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_CharacterRange) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_CharacterRange) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_CharacterRangeFull struct { + h *C.Sci_CharacterRangeFull +} + +func (this *Sci_CharacterRangeFull) cPointer() *C.Sci_CharacterRangeFull { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_CharacterRangeFull) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_CharacterRangeFull(h *C.Sci_CharacterRangeFull) *Sci_CharacterRangeFull { + if h == nil { + return nil + } + return &Sci_CharacterRangeFull{h: h} +} + +func UnsafeNewSci_CharacterRangeFull(h unsafe.Pointer) *Sci_CharacterRangeFull { + return newSci_CharacterRangeFull((*C.Sci_CharacterRangeFull)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_CharacterRangeFull) Delete() { + C.Sci_CharacterRangeFull_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_CharacterRangeFull) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_CharacterRangeFull) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_TextRange struct { + h *C.Sci_TextRange +} + +func (this *Sci_TextRange) cPointer() *C.Sci_TextRange { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_TextRange) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_TextRange(h *C.Sci_TextRange) *Sci_TextRange { + if h == nil { + return nil + } + return &Sci_TextRange{h: h} +} + +func UnsafeNewSci_TextRange(h unsafe.Pointer) *Sci_TextRange { + return newSci_TextRange((*C.Sci_TextRange)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_TextRange) Delete() { + C.Sci_TextRange_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_TextRange) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_TextRange) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_TextRangeFull struct { + h *C.Sci_TextRangeFull +} + +func (this *Sci_TextRangeFull) cPointer() *C.Sci_TextRangeFull { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_TextRangeFull) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_TextRangeFull(h *C.Sci_TextRangeFull) *Sci_TextRangeFull { + if h == nil { + return nil + } + return &Sci_TextRangeFull{h: h} +} + +func UnsafeNewSci_TextRangeFull(h unsafe.Pointer) *Sci_TextRangeFull { + return newSci_TextRangeFull((*C.Sci_TextRangeFull)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_TextRangeFull) Delete() { + C.Sci_TextRangeFull_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_TextRangeFull) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_TextRangeFull) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_TextToFind struct { + h *C.Sci_TextToFind +} + +func (this *Sci_TextToFind) cPointer() *C.Sci_TextToFind { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_TextToFind) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_TextToFind(h *C.Sci_TextToFind) *Sci_TextToFind { + if h == nil { + return nil + } + return &Sci_TextToFind{h: h} +} + +func UnsafeNewSci_TextToFind(h unsafe.Pointer) *Sci_TextToFind { + return newSci_TextToFind((*C.Sci_TextToFind)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_TextToFind) Delete() { + C.Sci_TextToFind_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_TextToFind) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_TextToFind) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_TextToFindFull struct { + h *C.Sci_TextToFindFull +} + +func (this *Sci_TextToFindFull) cPointer() *C.Sci_TextToFindFull { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_TextToFindFull) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_TextToFindFull(h *C.Sci_TextToFindFull) *Sci_TextToFindFull { + if h == nil { + return nil + } + return &Sci_TextToFindFull{h: h} +} + +func UnsafeNewSci_TextToFindFull(h unsafe.Pointer) *Sci_TextToFindFull { + return newSci_TextToFindFull((*C.Sci_TextToFindFull)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_TextToFindFull) Delete() { + C.Sci_TextToFindFull_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_TextToFindFull) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_TextToFindFull) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_Rectangle struct { + h *C.Sci_Rectangle +} + +func (this *Sci_Rectangle) cPointer() *C.Sci_Rectangle { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_Rectangle) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_Rectangle(h *C.Sci_Rectangle) *Sci_Rectangle { + if h == nil { + return nil + } + return &Sci_Rectangle{h: h} +} + +func UnsafeNewSci_Rectangle(h unsafe.Pointer) *Sci_Rectangle { + return newSci_Rectangle((*C.Sci_Rectangle)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_Rectangle) Delete() { + C.Sci_Rectangle_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_Rectangle) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_Rectangle) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_RangeToFormat struct { + h *C.Sci_RangeToFormat +} + +func (this *Sci_RangeToFormat) cPointer() *C.Sci_RangeToFormat { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_RangeToFormat) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_RangeToFormat(h *C.Sci_RangeToFormat) *Sci_RangeToFormat { + if h == nil { + return nil + } + return &Sci_RangeToFormat{h: h} +} + +func UnsafeNewSci_RangeToFormat(h unsafe.Pointer) *Sci_RangeToFormat { + return newSci_RangeToFormat((*C.Sci_RangeToFormat)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_RangeToFormat) Delete() { + C.Sci_RangeToFormat_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_RangeToFormat) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_RangeToFormat) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_RangeToFormatFull struct { + h *C.Sci_RangeToFormatFull +} + +func (this *Sci_RangeToFormatFull) cPointer() *C.Sci_RangeToFormatFull { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_RangeToFormatFull) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_RangeToFormatFull(h *C.Sci_RangeToFormatFull) *Sci_RangeToFormatFull { + if h == nil { + return nil + } + return &Sci_RangeToFormatFull{h: h} +} + +func UnsafeNewSci_RangeToFormatFull(h unsafe.Pointer) *Sci_RangeToFormatFull { + return newSci_RangeToFormatFull((*C.Sci_RangeToFormatFull)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_RangeToFormatFull) Delete() { + C.Sci_RangeToFormatFull_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_RangeToFormatFull) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_RangeToFormatFull) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type Sci_NotifyHeader struct { + h *C.Sci_NotifyHeader +} + +func (this *Sci_NotifyHeader) cPointer() *C.Sci_NotifyHeader { + if this == nil { + return nil + } + return this.h +} + +func (this *Sci_NotifyHeader) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSci_NotifyHeader(h *C.Sci_NotifyHeader) *Sci_NotifyHeader { + if h == nil { + return nil + } + return &Sci_NotifyHeader{h: h} +} + +func UnsafeNewSci_NotifyHeader(h unsafe.Pointer) *Sci_NotifyHeader { + return newSci_NotifyHeader((*C.Sci_NotifyHeader)(h)) +} + +// Delete this object from C++ memory. +func (this *Sci_NotifyHeader) Delete() { + C.Sci_NotifyHeader_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *Sci_NotifyHeader) GoGC() { + runtime.SetFinalizer(this, func(this *Sci_NotifyHeader) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type SCNotification struct { + h *C.SCNotification +} + +func (this *SCNotification) cPointer() *C.SCNotification { + if this == nil { + return nil + } + return this.h +} + +func (this *SCNotification) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newSCNotification(h *C.SCNotification) *SCNotification { + if h == nil { + return nil + } + return &SCNotification{h: h} +} + +func UnsafeNewSCNotification(h unsafe.Pointer) *SCNotification { + return newSCNotification((*C.SCNotification)(h)) +} + +// Delete this object from C++ memory. +func (this *SCNotification) Delete() { + C.SCNotification_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *SCNotification) GoGC() { + runtime.SetFinalizer(this, func(this *SCNotification) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type ScintillaEditBase struct { + h *C.ScintillaEditBase + *qt.QAbstractScrollArea +} + +func (this *ScintillaEditBase) cPointer() *C.ScintillaEditBase { + if this == nil { + return nil + } + return this.h +} + +func (this *ScintillaEditBase) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintillaEditBase(h *C.ScintillaEditBase) *ScintillaEditBase { + if h == nil { + return nil + } + return &ScintillaEditBase{h: h, QAbstractScrollArea: qt.UnsafeNewQAbstractScrollArea(unsafe.Pointer(h))} +} + +func UnsafeNewScintillaEditBase(h unsafe.Pointer) *ScintillaEditBase { + return newScintillaEditBase((*C.ScintillaEditBase)(h)) +} + +// NewScintillaEditBase constructs a new ScintillaEditBase object. +func NewScintillaEditBase() *ScintillaEditBase { + ret := C.ScintillaEditBase_new() + return newScintillaEditBase(ret) +} + +// NewScintillaEditBase2 constructs a new ScintillaEditBase object. +func NewScintillaEditBase2(parent *qt.QWidget) *ScintillaEditBase { + ret := C.ScintillaEditBase_new2((*C.QWidget)(parent.UnsafePointer())) + return newScintillaEditBase(ret) +} + +func (this *ScintillaEditBase) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.ScintillaEditBase_MetaObject(this.h))) +} + +func (this *ScintillaEditBase) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.ScintillaEditBase_Metacast(this.h, param1_Cstring)) +} + +func ScintillaEditBase_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEditBase_Tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaEditBase_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEditBase_TrUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *ScintillaEditBase) Send(iMessage uint) uintptr { + return (uintptr)(C.ScintillaEditBase_Send(this.h, (C.uint)(iMessage))) +} + +func (this *ScintillaEditBase) Sends(iMessage uint) uintptr { + return (uintptr)(C.ScintillaEditBase_Sends(this.h, (C.uint)(iMessage))) +} + +func (this *ScintillaEditBase) ScrollHorizontal(value int) { + C.ScintillaEditBase_ScrollHorizontal(this.h, (C.int)(value)) +} + +func (this *ScintillaEditBase) ScrollVertical(value int) { + C.ScintillaEditBase_ScrollVertical(this.h, (C.int)(value)) +} + +func (this *ScintillaEditBase) NotifyParent(scn Scintilla__NotificationData) { + C.ScintillaEditBase_NotifyParent(this.h, scn.cPointer()) +} + +func (this *ScintillaEditBase) EventCommand(wParam uintptr, lParam uintptr) { + C.ScintillaEditBase_EventCommand(this.h, (C.uintptr_t)(wParam), (C.intptr_t)(lParam)) +} + +func (this *ScintillaEditBase) HorizontalScrolled(value int) { + C.ScintillaEditBase_HorizontalScrolled(this.h, (C.int)(value)) +} +func (this *ScintillaEditBase) OnHorizontalScrolled(slot func(value int)) { + C.ScintillaEditBase_connect_HorizontalScrolled(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_HorizontalScrolled +func miqt_exec_callback_ScintillaEditBase_HorizontalScrolled(cb C.intptr_t, value C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(value int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(value) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) VerticalScrolled(value int) { + C.ScintillaEditBase_VerticalScrolled(this.h, (C.int)(value)) +} +func (this *ScintillaEditBase) OnVerticalScrolled(slot func(value int)) { + C.ScintillaEditBase_connect_VerticalScrolled(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_VerticalScrolled +func miqt_exec_callback_ScintillaEditBase_VerticalScrolled(cb C.intptr_t, value C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(value int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(value) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) HorizontalRangeChanged(max int, page int) { + C.ScintillaEditBase_HorizontalRangeChanged(this.h, (C.int)(max), (C.int)(page)) +} +func (this *ScintillaEditBase) OnHorizontalRangeChanged(slot func(max int, page int)) { + C.ScintillaEditBase_connect_HorizontalRangeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_HorizontalRangeChanged +func miqt_exec_callback_ScintillaEditBase_HorizontalRangeChanged(cb C.intptr_t, max C.int, page C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(max int, page int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(max) + + slotval2 := (int)(page) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) VerticalRangeChanged(max int, page int) { + C.ScintillaEditBase_VerticalRangeChanged(this.h, (C.int)(max), (C.int)(page)) +} +func (this *ScintillaEditBase) OnVerticalRangeChanged(slot func(max int, page int)) { + C.ScintillaEditBase_connect_VerticalRangeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_VerticalRangeChanged +func miqt_exec_callback_ScintillaEditBase_VerticalRangeChanged(cb C.intptr_t, max C.int, page C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(max int, page int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(max) + + slotval2 := (int)(page) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) NotifyChange() { + C.ScintillaEditBase_NotifyChange(this.h) +} +func (this *ScintillaEditBase) OnNotifyChange(slot func()) { + C.ScintillaEditBase_connect_NotifyChange(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_NotifyChange +func miqt_exec_callback_ScintillaEditBase_NotifyChange(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *ScintillaEditBase) LinesAdded(linesAdded uintptr) { + C.ScintillaEditBase_LinesAdded(this.h, (C.intptr_t)(linesAdded)) +} +func (this *ScintillaEditBase) OnLinesAdded(slot func(linesAdded uintptr)) { + C.ScintillaEditBase_connect_LinesAdded(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_LinesAdded +func miqt_exec_callback_ScintillaEditBase_LinesAdded(cb C.intptr_t, linesAdded C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(linesAdded uintptr)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(linesAdded) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) AboutToCopy(data *qt.QMimeData) { + C.ScintillaEditBase_AboutToCopy(this.h, (*C.QMimeData)(data.UnsafePointer())) +} +func (this *ScintillaEditBase) OnAboutToCopy(slot func(data *qt.QMimeData)) { + C.ScintillaEditBase_connect_AboutToCopy(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_AboutToCopy +func miqt_exec_callback_ScintillaEditBase_AboutToCopy(cb C.intptr_t, data *C.QMimeData) { + gofunc, ok := cgo.Handle(cb).Value().(func(data *qt.QMimeData)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMimeData(unsafe.Pointer(data)) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) StyleNeeded(position uintptr) { + C.ScintillaEditBase_StyleNeeded(this.h, (C.intptr_t)(position)) +} +func (this *ScintillaEditBase) OnStyleNeeded(slot func(position uintptr)) { + C.ScintillaEditBase_connect_StyleNeeded(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_StyleNeeded +func miqt_exec_callback_ScintillaEditBase_StyleNeeded(cb C.intptr_t, position C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(position uintptr)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(position) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) CharAdded(ch int) { + C.ScintillaEditBase_CharAdded(this.h, (C.int)(ch)) +} +func (this *ScintillaEditBase) OnCharAdded(slot func(ch int)) { + C.ScintillaEditBase_connect_CharAdded(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_CharAdded +func miqt_exec_callback_ScintillaEditBase_CharAdded(cb C.intptr_t, ch C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(ch int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(ch) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) SavePointChanged(dirty bool) { + C.ScintillaEditBase_SavePointChanged(this.h, (C.bool)(dirty)) +} +func (this *ScintillaEditBase) OnSavePointChanged(slot func(dirty bool)) { + C.ScintillaEditBase_connect_SavePointChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_SavePointChanged +func miqt_exec_callback_ScintillaEditBase_SavePointChanged(cb C.intptr_t, dirty C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(dirty bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(dirty) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) ModifyAttemptReadOnly() { + C.ScintillaEditBase_ModifyAttemptReadOnly(this.h) +} +func (this *ScintillaEditBase) OnModifyAttemptReadOnly(slot func()) { + C.ScintillaEditBase_connect_ModifyAttemptReadOnly(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_ModifyAttemptReadOnly +func miqt_exec_callback_ScintillaEditBase_ModifyAttemptReadOnly(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *ScintillaEditBase) Key(key int) { + C.ScintillaEditBase_Key(this.h, (C.int)(key)) +} +func (this *ScintillaEditBase) OnKey(slot func(key int)) { + C.ScintillaEditBase_connect_Key(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_Key +func miqt_exec_callback_ScintillaEditBase_Key(cb C.intptr_t, key C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(key int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(key) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) DoubleClick(position uintptr, line uintptr) { + C.ScintillaEditBase_DoubleClick(this.h, (C.intptr_t)(position), (C.intptr_t)(line)) +} +func (this *ScintillaEditBase) OnDoubleClick(slot func(position uintptr, line uintptr)) { + C.ScintillaEditBase_connect_DoubleClick(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_DoubleClick +func miqt_exec_callback_ScintillaEditBase_DoubleClick(cb C.intptr_t, position C.intptr_t, line C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(position uintptr, line uintptr)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(position) + + slotval2 := (uintptr)(line) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) UpdateUi(updated Scintilla__Update) { + C.ScintillaEditBase_UpdateUi(this.h, (C.int)(updated)) +} +func (this *ScintillaEditBase) OnUpdateUi(slot func(updated Scintilla__Update)) { + C.ScintillaEditBase_connect_UpdateUi(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_UpdateUi +func miqt_exec_callback_ScintillaEditBase_UpdateUi(cb C.intptr_t, updated C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(updated Scintilla__Update)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (Scintilla__Update)(updated) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) Modified(typeVal Scintilla__ModificationFlags, position uintptr, length uintptr, linesAdded uintptr, text []byte, line uintptr, foldNow Scintilla__FoldLevel, foldPrev Scintilla__FoldLevel) { + text_alias := C.struct_miqt_string{} + text_alias.data = (*C.char)(unsafe.Pointer(&text[0])) + text_alias.len = C.size_t(len(text)) + C.ScintillaEditBase_Modified(this.h, (C.int)(typeVal), (C.intptr_t)(position), (C.intptr_t)(length), (C.intptr_t)(linesAdded), text_alias, (C.intptr_t)(line), (C.int)(foldNow), (C.int)(foldPrev)) +} +func (this *ScintillaEditBase) OnModified(slot func(typeVal Scintilla__ModificationFlags, position uintptr, length uintptr, linesAdded uintptr, text []byte, line uintptr, foldNow Scintilla__FoldLevel, foldPrev Scintilla__FoldLevel)) { + C.ScintillaEditBase_connect_Modified(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_Modified +func miqt_exec_callback_ScintillaEditBase_Modified(cb C.intptr_t, typeVal C.int, position C.intptr_t, length C.intptr_t, linesAdded C.intptr_t, text C.struct_miqt_string, line C.intptr_t, foldNow C.int, foldPrev C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(typeVal Scintilla__ModificationFlags, position uintptr, length uintptr, linesAdded uintptr, text []byte, line uintptr, foldNow Scintilla__FoldLevel, foldPrev Scintilla__FoldLevel)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (Scintilla__ModificationFlags)(typeVal) + + slotval2 := (uintptr)(position) + + slotval3 := (uintptr)(length) + + slotval4 := (uintptr)(linesAdded) + + var text_bytearray C.struct_miqt_string = text + text_ret := C.GoBytes(unsafe.Pointer(text_bytearray.data), C.int(int64(text_bytearray.len))) + C.free(unsafe.Pointer(text_bytearray.data)) + slotval5 := text_ret + slotval6 := (uintptr)(line) + + slotval7 := (Scintilla__FoldLevel)(foldNow) + + slotval8 := (Scintilla__FoldLevel)(foldPrev) + + gofunc(slotval1, slotval2, slotval3, slotval4, slotval5, slotval6, slotval7, slotval8) +} + +func (this *ScintillaEditBase) MacroRecord(message Scintilla__Message, wParam uintptr, lParam uintptr) { + C.ScintillaEditBase_MacroRecord(this.h, (C.int)(message), (C.uintptr_t)(wParam), (C.intptr_t)(lParam)) +} +func (this *ScintillaEditBase) OnMacroRecord(slot func(message Scintilla__Message, wParam uintptr, lParam uintptr)) { + C.ScintillaEditBase_connect_MacroRecord(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_MacroRecord +func miqt_exec_callback_ScintillaEditBase_MacroRecord(cb C.intptr_t, message C.int, wParam C.uintptr_t, lParam C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(message Scintilla__Message, wParam uintptr, lParam uintptr)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (Scintilla__Message)(message) + + slotval2 := (uintptr)(wParam) + + slotval3 := (uintptr)(lParam) + + gofunc(slotval1, slotval2, slotval3) +} + +func (this *ScintillaEditBase) MarginClicked(position uintptr, modifiers Scintilla__KeyMod, margin int) { + C.ScintillaEditBase_MarginClicked(this.h, (C.intptr_t)(position), (C.int)(modifiers), (C.int)(margin)) +} +func (this *ScintillaEditBase) OnMarginClicked(slot func(position uintptr, modifiers Scintilla__KeyMod, margin int)) { + C.ScintillaEditBase_connect_MarginClicked(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_MarginClicked +func miqt_exec_callback_ScintillaEditBase_MarginClicked(cb C.intptr_t, position C.intptr_t, modifiers C.int, margin C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(position uintptr, modifiers Scintilla__KeyMod, margin int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(position) + + slotval2 := (Scintilla__KeyMod)(modifiers) + + slotval3 := (int)(margin) + + gofunc(slotval1, slotval2, slotval3) +} + +func (this *ScintillaEditBase) TextAreaClicked(line uintptr, modifiers int) { + C.ScintillaEditBase_TextAreaClicked(this.h, (C.intptr_t)(line), (C.int)(modifiers)) +} +func (this *ScintillaEditBase) OnTextAreaClicked(slot func(line uintptr, modifiers int)) { + C.ScintillaEditBase_connect_TextAreaClicked(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_TextAreaClicked +func miqt_exec_callback_ScintillaEditBase_TextAreaClicked(cb C.intptr_t, line C.intptr_t, modifiers C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(line uintptr, modifiers int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(line) + + slotval2 := (int)(modifiers) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) NeedShown(position uintptr, length uintptr) { + C.ScintillaEditBase_NeedShown(this.h, (C.intptr_t)(position), (C.intptr_t)(length)) +} +func (this *ScintillaEditBase) OnNeedShown(slot func(position uintptr, length uintptr)) { + C.ScintillaEditBase_connect_NeedShown(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_NeedShown +func miqt_exec_callback_ScintillaEditBase_NeedShown(cb C.intptr_t, position C.intptr_t, length C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(position uintptr, length uintptr)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(position) + + slotval2 := (uintptr)(length) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) Painted() { + C.ScintillaEditBase_Painted(this.h) +} +func (this *ScintillaEditBase) OnPainted(slot func()) { + C.ScintillaEditBase_connect_Painted(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_Painted +func miqt_exec_callback_ScintillaEditBase_Painted(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *ScintillaEditBase) UserListSelection() { + C.ScintillaEditBase_UserListSelection(this.h) +} +func (this *ScintillaEditBase) OnUserListSelection(slot func()) { + C.ScintillaEditBase_connect_UserListSelection(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_UserListSelection +func miqt_exec_callback_ScintillaEditBase_UserListSelection(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *ScintillaEditBase) UriDropped(uri string) { + uri_ms := C.struct_miqt_string{} + uri_ms.data = C.CString(uri) + uri_ms.len = C.size_t(len(uri)) + defer C.free(unsafe.Pointer(uri_ms.data)) + C.ScintillaEditBase_UriDropped(this.h, uri_ms) +} +func (this *ScintillaEditBase) OnUriDropped(slot func(uri string)) { + C.ScintillaEditBase_connect_UriDropped(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_UriDropped +func miqt_exec_callback_ScintillaEditBase_UriDropped(cb C.intptr_t, uri C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(uri string)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var uri_ms C.struct_miqt_string = uri + uri_ret := C.GoStringN(uri_ms.data, C.int(int64(uri_ms.len))) + C.free(unsafe.Pointer(uri_ms.data)) + slotval1 := uri_ret + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) DwellStart(x int, y int) { + C.ScintillaEditBase_DwellStart(this.h, (C.int)(x), (C.int)(y)) +} +func (this *ScintillaEditBase) OnDwellStart(slot func(x int, y int)) { + C.ScintillaEditBase_connect_DwellStart(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_DwellStart +func miqt_exec_callback_ScintillaEditBase_DwellStart(cb C.intptr_t, x C.int, y C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(x int, y int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(x) + + slotval2 := (int)(y) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) DwellEnd(x int, y int) { + C.ScintillaEditBase_DwellEnd(this.h, (C.int)(x), (C.int)(y)) +} +func (this *ScintillaEditBase) OnDwellEnd(slot func(x int, y int)) { + C.ScintillaEditBase_connect_DwellEnd(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_DwellEnd +func miqt_exec_callback_ScintillaEditBase_DwellEnd(cb C.intptr_t, x C.int, y C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(x int, y int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(x) + + slotval2 := (int)(y) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) Zoom(zoom int) { + C.ScintillaEditBase_Zoom(this.h, (C.int)(zoom)) +} +func (this *ScintillaEditBase) OnZoom(slot func(zoom int)) { + C.ScintillaEditBase_connect_Zoom(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_Zoom +func miqt_exec_callback_ScintillaEditBase_Zoom(cb C.intptr_t, zoom C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(zoom int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(zoom) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) HotSpotClick(position uintptr, modifiers Scintilla__KeyMod) { + C.ScintillaEditBase_HotSpotClick(this.h, (C.intptr_t)(position), (C.int)(modifiers)) +} +func (this *ScintillaEditBase) OnHotSpotClick(slot func(position uintptr, modifiers Scintilla__KeyMod)) { + C.ScintillaEditBase_connect_HotSpotClick(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_HotSpotClick +func miqt_exec_callback_ScintillaEditBase_HotSpotClick(cb C.intptr_t, position C.intptr_t, modifiers C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(position uintptr, modifiers Scintilla__KeyMod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(position) + + slotval2 := (Scintilla__KeyMod)(modifiers) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) HotSpotDoubleClick(position uintptr, modifiers Scintilla__KeyMod) { + C.ScintillaEditBase_HotSpotDoubleClick(this.h, (C.intptr_t)(position), (C.int)(modifiers)) +} +func (this *ScintillaEditBase) OnHotSpotDoubleClick(slot func(position uintptr, modifiers Scintilla__KeyMod)) { + C.ScintillaEditBase_connect_HotSpotDoubleClick(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_HotSpotDoubleClick +func miqt_exec_callback_ScintillaEditBase_HotSpotDoubleClick(cb C.intptr_t, position C.intptr_t, modifiers C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(position uintptr, modifiers Scintilla__KeyMod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(position) + + slotval2 := (Scintilla__KeyMod)(modifiers) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) CallTipClick() { + C.ScintillaEditBase_CallTipClick(this.h) +} +func (this *ScintillaEditBase) OnCallTipClick(slot func()) { + C.ScintillaEditBase_connect_CallTipClick(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_CallTipClick +func miqt_exec_callback_ScintillaEditBase_CallTipClick(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *ScintillaEditBase) AutoCompleteSelection(position uintptr, text string) { + text_ms := C.struct_miqt_string{} + text_ms.data = C.CString(text) + text_ms.len = C.size_t(len(text)) + defer C.free(unsafe.Pointer(text_ms.data)) + C.ScintillaEditBase_AutoCompleteSelection(this.h, (C.intptr_t)(position), text_ms) +} +func (this *ScintillaEditBase) OnAutoCompleteSelection(slot func(position uintptr, text string)) { + C.ScintillaEditBase_connect_AutoCompleteSelection(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_AutoCompleteSelection +func miqt_exec_callback_ScintillaEditBase_AutoCompleteSelection(cb C.intptr_t, position C.intptr_t, text C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(position uintptr, text string)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(position) + + var text_ms C.struct_miqt_string = text + text_ret := C.GoStringN(text_ms.data, C.int(int64(text_ms.len))) + C.free(unsafe.Pointer(text_ms.data)) + slotval2 := text_ret + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) AutoCompleteCancelled() { + C.ScintillaEditBase_AutoCompleteCancelled(this.h) +} +func (this *ScintillaEditBase) OnAutoCompleteCancelled(slot func()) { + C.ScintillaEditBase_connect_AutoCompleteCancelled(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_AutoCompleteCancelled +func miqt_exec_callback_ScintillaEditBase_AutoCompleteCancelled(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *ScintillaEditBase) FocusChanged(focused bool) { + C.ScintillaEditBase_FocusChanged(this.h, (C.bool)(focused)) +} +func (this *ScintillaEditBase) OnFocusChanged(slot func(focused bool)) { + C.ScintillaEditBase_connect_FocusChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_FocusChanged +func miqt_exec_callback_ScintillaEditBase_FocusChanged(cb C.intptr_t, focused C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(focused bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(focused) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) Notify(pscn *Scintilla__NotificationData) { + C.ScintillaEditBase_Notify(this.h, pscn.cPointer()) +} +func (this *ScintillaEditBase) OnNotify(slot func(pscn *Scintilla__NotificationData)) { + C.ScintillaEditBase_connect_Notify(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_Notify +func miqt_exec_callback_ScintillaEditBase_Notify(cb C.intptr_t, pscn *C.Scintilla__NotificationData) { + gofunc, ok := cgo.Handle(cb).Value().(func(pscn *Scintilla__NotificationData)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := UnsafeNewScintilla__NotificationData(unsafe.Pointer(pscn)) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) Command(wParam uintptr, lParam uintptr) { + C.ScintillaEditBase_Command(this.h, (C.uintptr_t)(wParam), (C.intptr_t)(lParam)) +} +func (this *ScintillaEditBase) OnCommand(slot func(wParam uintptr, lParam uintptr)) { + C.ScintillaEditBase_connect_Command(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_Command +func miqt_exec_callback_ScintillaEditBase_Command(cb C.intptr_t, wParam C.uintptr_t, lParam C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(wParam uintptr, lParam uintptr)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uintptr)(wParam) + + slotval2 := (uintptr)(lParam) + + gofunc(slotval1, slotval2) +} + +func (this *ScintillaEditBase) ButtonPressed(event *qt.QMouseEvent) { + C.ScintillaEditBase_ButtonPressed(this.h, (*C.QMouseEvent)(event.UnsafePointer())) +} +func (this *ScintillaEditBase) OnButtonPressed(slot func(event *qt.QMouseEvent)) { + C.ScintillaEditBase_connect_ButtonPressed(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_ButtonPressed +func miqt_exec_callback_ScintillaEditBase_ButtonPressed(cb C.intptr_t, event *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(event *qt.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMouseEvent(unsafe.Pointer(event)) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) ButtonReleased(event *qt.QMouseEvent) { + C.ScintillaEditBase_ButtonReleased(this.h, (*C.QMouseEvent)(event.UnsafePointer())) +} +func (this *ScintillaEditBase) OnButtonReleased(slot func(event *qt.QMouseEvent)) { + C.ScintillaEditBase_connect_ButtonReleased(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_ButtonReleased +func miqt_exec_callback_ScintillaEditBase_ButtonReleased(cb C.intptr_t, event *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(event *qt.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMouseEvent(unsafe.Pointer(event)) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) KeyPressed(event *qt.QKeyEvent) { + C.ScintillaEditBase_KeyPressed(this.h, (*C.QKeyEvent)(event.UnsafePointer())) +} +func (this *ScintillaEditBase) OnKeyPressed(slot func(event *qt.QKeyEvent)) { + C.ScintillaEditBase_connect_KeyPressed(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_KeyPressed +func miqt_exec_callback_ScintillaEditBase_KeyPressed(cb C.intptr_t, event *C.QKeyEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(event *qt.QKeyEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQKeyEvent(unsafe.Pointer(event)) + + gofunc(slotval1) +} + +func (this *ScintillaEditBase) Resized() { + C.ScintillaEditBase_Resized(this.h) +} +func (this *ScintillaEditBase) OnResized(slot func()) { + C.ScintillaEditBase_connect_Resized(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaEditBase_Resized +func miqt_exec_callback_ScintillaEditBase_Resized(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func ScintillaEditBase_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEditBase_Tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaEditBase_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEditBase_Tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaEditBase_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEditBase_TrUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaEditBase_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEditBase_TrUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *ScintillaEditBase) Send2(iMessage uint, wParam uintptr) uintptr { + return (uintptr)(C.ScintillaEditBase_Send2(this.h, (C.uint)(iMessage), (C.uintptr_t)(wParam))) +} + +func (this *ScintillaEditBase) Send3(iMessage uint, wParam uintptr, lParam uintptr) uintptr { + return (uintptr)(C.ScintillaEditBase_Send3(this.h, (C.uint)(iMessage), (C.uintptr_t)(wParam), (C.intptr_t)(lParam))) +} + +func (this *ScintillaEditBase) Sends2(iMessage uint, wParam uintptr) uintptr { + return (uintptr)(C.ScintillaEditBase_Sends2(this.h, (C.uint)(iMessage), (C.uintptr_t)(wParam))) +} + +func (this *ScintillaEditBase) Sends3(iMessage uint, wParam uintptr, s string) uintptr { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + return (uintptr)(C.ScintillaEditBase_Sends3(this.h, (C.uint)(iMessage), (C.uintptr_t)(wParam), s_Cstring)) +} + +// Delete this object from C++ memory. +func (this *ScintillaEditBase) Delete() { + C.ScintillaEditBase_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *ScintillaEditBase) GoGC() { + runtime.SetFinalizer(this, func(this *ScintillaEditBase) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type ScintillaDocument struct { + h *C.ScintillaDocument + *qt.QObject +} + +func (this *ScintillaDocument) cPointer() *C.ScintillaDocument { + if this == nil { + return nil + } + return this.h +} + +func (this *ScintillaDocument) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintillaDocument(h *C.ScintillaDocument) *ScintillaDocument { + if h == nil { + return nil + } + return &ScintillaDocument{h: h, QObject: qt.UnsafeNewQObject(unsafe.Pointer(h))} +} + +func UnsafeNewScintillaDocument(h unsafe.Pointer) *ScintillaDocument { + return newScintillaDocument((*C.ScintillaDocument)(h)) +} + +// NewScintillaDocument constructs a new ScintillaDocument object. +func NewScintillaDocument() *ScintillaDocument { + ret := C.ScintillaDocument_new() + return newScintillaDocument(ret) +} + +// NewScintillaDocument2 constructs a new ScintillaDocument object. +func NewScintillaDocument2(parent *qt.QObject) *ScintillaDocument { + ret := C.ScintillaDocument_new2((*C.QObject)(parent.UnsafePointer())) + return newScintillaDocument(ret) +} + +// NewScintillaDocument3 constructs a new ScintillaDocument object. +func NewScintillaDocument3(parent *qt.QObject, pdoc_ unsafe.Pointer) *ScintillaDocument { + ret := C.ScintillaDocument_new3((*C.QObject)(parent.UnsafePointer()), pdoc_) + return newScintillaDocument(ret) +} + +func (this *ScintillaDocument) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.ScintillaDocument_MetaObject(this.h))) +} + +func (this *ScintillaDocument) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.ScintillaDocument_Metacast(this.h, param1_Cstring)) +} + +func ScintillaDocument_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaDocument_Tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaDocument_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaDocument_TrUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *ScintillaDocument) Pointer() unsafe.Pointer { + return (unsafe.Pointer)(C.ScintillaDocument_Pointer(this.h)) +} + +func (this *ScintillaDocument) LineFromPosition(pos int) int { + return (int)(C.ScintillaDocument_LineFromPosition(this.h, (C.int)(pos))) +} + +func (this *ScintillaDocument) IsCrLf(pos int) bool { + return (bool)(C.ScintillaDocument_IsCrLf(this.h, (C.int)(pos))) +} + +func (this *ScintillaDocument) DeleteChars(pos int, lenVal int) bool { + return (bool)(C.ScintillaDocument_DeleteChars(this.h, (C.int)(pos), (C.int)(lenVal))) +} + +func (this *ScintillaDocument) Undo() int { + return (int)(C.ScintillaDocument_Undo(this.h)) +} + +func (this *ScintillaDocument) Redo() int { + return (int)(C.ScintillaDocument_Redo(this.h)) +} + +func (this *ScintillaDocument) CanUndo() bool { + return (bool)(C.ScintillaDocument_CanUndo(this.h)) +} + +func (this *ScintillaDocument) CanRedo() bool { + return (bool)(C.ScintillaDocument_CanRedo(this.h)) +} + +func (this *ScintillaDocument) DeleteUndoHistory() { + C.ScintillaDocument_DeleteUndoHistory(this.h) +} + +func (this *ScintillaDocument) SetUndoCollection(collect_undo bool) bool { + return (bool)(C.ScintillaDocument_SetUndoCollection(this.h, (C.bool)(collect_undo))) +} + +func (this *ScintillaDocument) IsCollectingUndo() bool { + return (bool)(C.ScintillaDocument_IsCollectingUndo(this.h)) +} + +func (this *ScintillaDocument) BeginUndoAction() { + C.ScintillaDocument_BeginUndoAction(this.h) +} + +func (this *ScintillaDocument) EndUndoAction() { + C.ScintillaDocument_EndUndoAction(this.h) +} + +func (this *ScintillaDocument) SetSavePoint() { + C.ScintillaDocument_SetSavePoint(this.h) +} + +func (this *ScintillaDocument) IsSavePoint() bool { + return (bool)(C.ScintillaDocument_IsSavePoint(this.h)) +} + +func (this *ScintillaDocument) SetReadOnly(read_only bool) { + C.ScintillaDocument_SetReadOnly(this.h, (C.bool)(read_only)) +} + +func (this *ScintillaDocument) IsReadOnly() bool { + return (bool)(C.ScintillaDocument_IsReadOnly(this.h)) +} + +func (this *ScintillaDocument) InsertString(position int, str []byte) { + str_alias := C.struct_miqt_string{} + str_alias.data = (*C.char)(unsafe.Pointer(&str[0])) + str_alias.len = C.size_t(len(str)) + C.ScintillaDocument_InsertString(this.h, (C.int)(position), str_alias) +} + +func (this *ScintillaDocument) GetCharRange(position int, length int) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaDocument_GetCharRange(this.h, (C.int)(position), (C.int)(length)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaDocument) StyleAt(position int) int8 { + return (int8)(C.ScintillaDocument_StyleAt(this.h, (C.int)(position))) +} + +func (this *ScintillaDocument) LineStart(lineno int) int { + return (int)(C.ScintillaDocument_LineStart(this.h, (C.int)(lineno))) +} + +func (this *ScintillaDocument) LineEnd(lineno int) int { + return (int)(C.ScintillaDocument_LineEnd(this.h, (C.int)(lineno))) +} + +func (this *ScintillaDocument) LineEndPosition(pos int) int { + return (int)(C.ScintillaDocument_LineEndPosition(this.h, (C.int)(pos))) +} + +func (this *ScintillaDocument) Length() int { + return (int)(C.ScintillaDocument_Length(this.h)) +} + +func (this *ScintillaDocument) LinesTotal() int { + return (int)(C.ScintillaDocument_LinesTotal(this.h)) +} + +func (this *ScintillaDocument) StartStyling(position int) { + C.ScintillaDocument_StartStyling(this.h, (C.int)(position)) +} + +func (this *ScintillaDocument) SetStyleFor(length int, style int8) bool { + return (bool)(C.ScintillaDocument_SetStyleFor(this.h, (C.int)(length), (C.char)(style))) +} + +func (this *ScintillaDocument) GetEndStyled() int { + return (int)(C.ScintillaDocument_GetEndStyled(this.h)) +} + +func (this *ScintillaDocument) EnsureStyledTo(position int) { + C.ScintillaDocument_EnsureStyledTo(this.h, (C.int)(position)) +} + +func (this *ScintillaDocument) SetCurrentIndicator(indic int) { + C.ScintillaDocument_SetCurrentIndicator(this.h, (C.int)(indic)) +} + +func (this *ScintillaDocument) DecorationFillRange(position int, value int, fillLength int) { + C.ScintillaDocument_DecorationFillRange(this.h, (C.int)(position), (C.int)(value), (C.int)(fillLength)) +} + +func (this *ScintillaDocument) DecorationsValueAt(indic int, position int) int { + return (int)(C.ScintillaDocument_DecorationsValueAt(this.h, (C.int)(indic), (C.int)(position))) +} + +func (this *ScintillaDocument) DecorationsStart(indic int, position int) int { + return (int)(C.ScintillaDocument_DecorationsStart(this.h, (C.int)(indic), (C.int)(position))) +} + +func (this *ScintillaDocument) DecorationsEnd(indic int, position int) int { + return (int)(C.ScintillaDocument_DecorationsEnd(this.h, (C.int)(indic), (C.int)(position))) +} + +func (this *ScintillaDocument) GetCodePage() int { + return (int)(C.ScintillaDocument_GetCodePage(this.h)) +} + +func (this *ScintillaDocument) SetCodePage(code_page int) { + C.ScintillaDocument_SetCodePage(this.h, (C.int)(code_page)) +} + +func (this *ScintillaDocument) GetEolMode() int { + return (int)(C.ScintillaDocument_GetEolMode(this.h)) +} + +func (this *ScintillaDocument) SetEolMode(eol_mode int) { + C.ScintillaDocument_SetEolMode(this.h, (C.int)(eol_mode)) +} + +func (this *ScintillaDocument) MovePositionOutsideChar(pos int, move_dir int, check_line_end bool) int { + return (int)(C.ScintillaDocument_MovePositionOutsideChar(this.h, (C.int)(pos), (C.int)(move_dir), (C.bool)(check_line_end))) +} + +func (this *ScintillaDocument) GetCharacter(pos int) int { + return (int)(C.ScintillaDocument_GetCharacter(this.h, (C.int)(pos))) +} + +func (this *ScintillaDocument) ModifyAttempt() { + C.ScintillaDocument_ModifyAttempt(this.h) +} +func (this *ScintillaDocument) OnModifyAttempt(slot func()) { + C.ScintillaDocument_connect_ModifyAttempt(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaDocument_ModifyAttempt +func miqt_exec_callback_ScintillaDocument_ModifyAttempt(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *ScintillaDocument) SavePoint(atSavePoint bool) { + C.ScintillaDocument_SavePoint(this.h, (C.bool)(atSavePoint)) +} +func (this *ScintillaDocument) OnSavePoint(slot func(atSavePoint bool)) { + C.ScintillaDocument_connect_SavePoint(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaDocument_SavePoint +func miqt_exec_callback_ScintillaDocument_SavePoint(cb C.intptr_t, atSavePoint C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(atSavePoint bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(atSavePoint) + + gofunc(slotval1) +} + +func (this *ScintillaDocument) Modified(position int, modification_type int, text []byte, length int, linesAdded int, line int, foldLevelNow int, foldLevelPrev int) { + text_alias := C.struct_miqt_string{} + text_alias.data = (*C.char)(unsafe.Pointer(&text[0])) + text_alias.len = C.size_t(len(text)) + C.ScintillaDocument_Modified(this.h, (C.int)(position), (C.int)(modification_type), text_alias, (C.int)(length), (C.int)(linesAdded), (C.int)(line), (C.int)(foldLevelNow), (C.int)(foldLevelPrev)) +} +func (this *ScintillaDocument) OnModified(slot func(position int, modification_type int, text []byte, length int, linesAdded int, line int, foldLevelNow int, foldLevelPrev int)) { + C.ScintillaDocument_connect_Modified(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaDocument_Modified +func miqt_exec_callback_ScintillaDocument_Modified(cb C.intptr_t, position C.int, modification_type C.int, text C.struct_miqt_string, length C.int, linesAdded C.int, line C.int, foldLevelNow C.int, foldLevelPrev C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(position int, modification_type int, text []byte, length int, linesAdded int, line int, foldLevelNow int, foldLevelPrev int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(position) + + slotval2 := (int)(modification_type) + + var text_bytearray C.struct_miqt_string = text + text_ret := C.GoBytes(unsafe.Pointer(text_bytearray.data), C.int(int64(text_bytearray.len))) + C.free(unsafe.Pointer(text_bytearray.data)) + slotval3 := text_ret + slotval4 := (int)(length) + + slotval5 := (int)(linesAdded) + + slotval6 := (int)(line) + + slotval7 := (int)(foldLevelNow) + + slotval8 := (int)(foldLevelPrev) + + gofunc(slotval1, slotval2, slotval3, slotval4, slotval5, slotval6, slotval7, slotval8) +} + +func (this *ScintillaDocument) StyleNeeded(pos int) { + C.ScintillaDocument_StyleNeeded(this.h, (C.int)(pos)) +} +func (this *ScintillaDocument) OnStyleNeeded(slot func(pos int)) { + C.ScintillaDocument_connect_StyleNeeded(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaDocument_StyleNeeded +func miqt_exec_callback_ScintillaDocument_StyleNeeded(cb C.intptr_t, pos C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(pos int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(pos) + + gofunc(slotval1) +} + +func (this *ScintillaDocument) ErrorOccurred(status int) { + C.ScintillaDocument_ErrorOccurred(this.h, (C.int)(status)) +} +func (this *ScintillaDocument) OnErrorOccurred(slot func(status int)) { + C.ScintillaDocument_connect_ErrorOccurred(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_ScintillaDocument_ErrorOccurred +func miqt_exec_callback_ScintillaDocument_ErrorOccurred(cb C.intptr_t, status C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(status int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(status) + + gofunc(slotval1) +} + +func ScintillaDocument_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaDocument_Tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaDocument_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaDocument_Tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaDocument_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaDocument_TrUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaDocument_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaDocument_TrUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *ScintillaDocument) BeginUndoAction1(coalesceWithPrior bool) { + C.ScintillaDocument_BeginUndoAction1(this.h, (C.bool)(coalesceWithPrior)) +} + +// Delete this object from C++ memory. +func (this *ScintillaDocument) Delete() { + C.ScintillaDocument_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *ScintillaDocument) GoGC() { + runtime.SetFinalizer(this, func(this *ScintillaDocument) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type ScintillaEdit struct { + h *C.ScintillaEdit + *ScintillaEditBase +} + +func (this *ScintillaEdit) cPointer() *C.ScintillaEdit { + if this == nil { + return nil + } + return this.h +} + +func (this *ScintillaEdit) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +func newScintillaEdit(h *C.ScintillaEdit) *ScintillaEdit { + if h == nil { + return nil + } + return &ScintillaEdit{h: h, ScintillaEditBase: UnsafeNewScintillaEditBase(unsafe.Pointer(h))} +} + +func UnsafeNewScintillaEdit(h unsafe.Pointer) *ScintillaEdit { + return newScintillaEdit((*C.ScintillaEdit)(h)) +} + +// NewScintillaEdit constructs a new ScintillaEdit object. +func NewScintillaEdit() *ScintillaEdit { + ret := C.ScintillaEdit_new() + return newScintillaEdit(ret) +} + +// NewScintillaEdit2 constructs a new ScintillaEdit object. +func NewScintillaEdit2(parent *qt.QWidget) *ScintillaEdit { + ret := C.ScintillaEdit_new2((*C.QWidget)(parent.UnsafePointer())) + return newScintillaEdit(ret) +} + +func (this *ScintillaEdit) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.ScintillaEdit_MetaObject(this.h))) +} + +func (this *ScintillaEdit) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.ScintillaEdit_Metacast(this.h, param1_Cstring)) +} + +func ScintillaEdit_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEdit_Tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaEdit_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEdit_TrUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *ScintillaEdit) TextReturner(message int, wParam uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_TextReturner(this.h, (C.int)(message), (C.uintptr_t)(wParam)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) GetTextRange(start int, end int) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_GetTextRange(this.h, (C.int)(start), (C.int)(end)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) GetDoc() *ScintillaDocument { + return UnsafeNewScintillaDocument(unsafe.Pointer(C.ScintillaEdit_GetDoc(this.h))) +} + +func (this *ScintillaEdit) SetDoc(pdoc_ *ScintillaDocument) { + C.ScintillaEdit_SetDoc(this.h, pdoc_.cPointer()) +} + +func (this *ScintillaEdit) TextRange(start int, end int) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_TextRange(this.h, (C.int)(start), (C.int)(end)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) FormatRange(draw bool, target *qt.QPaintDevice, measure *qt.QPaintDevice, print_rect *qt.QRect, page_rect *qt.QRect, range_start int64, range_end int64) int64 { + return (int64)(C.ScintillaEdit_FormatRange(this.h, (C.bool)(draw), (*C.QPaintDevice)(target.UnsafePointer()), (*C.QPaintDevice)(measure.UnsafePointer()), (*C.QRect)(print_rect.UnsafePointer()), (*C.QRect)(page_rect.UnsafePointer()), (C.long)(range_start), (C.long)(range_end))) +} + +func (this *ScintillaEdit) FormatRange2(draw bool, target *qt.QPaintDevice, measure *qt.QPaintDevice, print_rect *qt.QRect, page_rect *qt.QRect, range_start int64, range_end int64) int64 { + return (int64)(C.ScintillaEdit_FormatRange2(this.h, (C.bool)(draw), (*C.QPaintDevice)(target.UnsafePointer()), (*C.QPaintDevice)(measure.UnsafePointer()), (*C.QRect)(print_rect.UnsafePointer()), (*C.QRect)(page_rect.UnsafePointer()), (C.long)(range_start), (C.long)(range_end))) +} + +func (this *ScintillaEdit) AddText(length uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_AddText(this.h, (C.intptr_t)(length), text_Cstring) +} + +func (this *ScintillaEdit) AddStyledText(length uintptr, c string) { + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + C.ScintillaEdit_AddStyledText(this.h, (C.intptr_t)(length), c_Cstring) +} + +func (this *ScintillaEdit) InsertText(pos uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_InsertText(this.h, (C.intptr_t)(pos), text_Cstring) +} + +func (this *ScintillaEdit) ChangeInsertion(length uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_ChangeInsertion(this.h, (C.intptr_t)(length), text_Cstring) +} + +func (this *ScintillaEdit) ClearAll() { + C.ScintillaEdit_ClearAll(this.h) +} + +func (this *ScintillaEdit) DeleteRange(start uintptr, lengthDelete uintptr) { + C.ScintillaEdit_DeleteRange(this.h, (C.intptr_t)(start), (C.intptr_t)(lengthDelete)) +} + +func (this *ScintillaEdit) ClearDocumentStyle() { + C.ScintillaEdit_ClearDocumentStyle(this.h) +} + +func (this *ScintillaEdit) Length() uintptr { + return (uintptr)(C.ScintillaEdit_Length(this.h)) +} + +func (this *ScintillaEdit) CharAt(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_CharAt(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) CurrentPos() uintptr { + return (uintptr)(C.ScintillaEdit_CurrentPos(this.h)) +} + +func (this *ScintillaEdit) Anchor() uintptr { + return (uintptr)(C.ScintillaEdit_Anchor(this.h)) +} + +func (this *ScintillaEdit) StyleAt(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleAt(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) StyleIndexAt(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleIndexAt(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) Redo() { + C.ScintillaEdit_Redo(this.h) +} + +func (this *ScintillaEdit) SetUndoCollection(collectUndo bool) { + C.ScintillaEdit_SetUndoCollection(this.h, (C.bool)(collectUndo)) +} + +func (this *ScintillaEdit) SelectAll() { + C.ScintillaEdit_SelectAll(this.h) +} + +func (this *ScintillaEdit) SetSavePoint() { + C.ScintillaEdit_SetSavePoint(this.h) +} + +func (this *ScintillaEdit) CanRedo() bool { + return (bool)(C.ScintillaEdit_CanRedo(this.h)) +} + +func (this *ScintillaEdit) MarkerLineFromHandle(markerHandle uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarkerLineFromHandle(this.h, (C.intptr_t)(markerHandle))) +} + +func (this *ScintillaEdit) MarkerDeleteHandle(markerHandle uintptr) { + C.ScintillaEdit_MarkerDeleteHandle(this.h, (C.intptr_t)(markerHandle)) +} + +func (this *ScintillaEdit) MarkerHandleFromLine(line uintptr, which uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarkerHandleFromLine(this.h, (C.intptr_t)(line), (C.intptr_t)(which))) +} + +func (this *ScintillaEdit) MarkerNumberFromLine(line uintptr, which uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarkerNumberFromLine(this.h, (C.intptr_t)(line), (C.intptr_t)(which))) +} + +func (this *ScintillaEdit) UndoCollection() bool { + return (bool)(C.ScintillaEdit_UndoCollection(this.h)) +} + +func (this *ScintillaEdit) ViewWS() uintptr { + return (uintptr)(C.ScintillaEdit_ViewWS(this.h)) +} + +func (this *ScintillaEdit) SetViewWS(viewWS uintptr) { + C.ScintillaEdit_SetViewWS(this.h, (C.intptr_t)(viewWS)) +} + +func (this *ScintillaEdit) TabDrawMode() uintptr { + return (uintptr)(C.ScintillaEdit_TabDrawMode(this.h)) +} + +func (this *ScintillaEdit) SetTabDrawMode(tabDrawMode uintptr) { + C.ScintillaEdit_SetTabDrawMode(this.h, (C.intptr_t)(tabDrawMode)) +} + +func (this *ScintillaEdit) PositionFromPoint(x uintptr, y uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PositionFromPoint(this.h, (C.intptr_t)(x), (C.intptr_t)(y))) +} + +func (this *ScintillaEdit) PositionFromPointClose(x uintptr, y uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PositionFromPointClose(this.h, (C.intptr_t)(x), (C.intptr_t)(y))) +} + +func (this *ScintillaEdit) GotoLine(line uintptr) { + C.ScintillaEdit_GotoLine(this.h, (C.intptr_t)(line)) +} + +func (this *ScintillaEdit) GotoPos(caret uintptr) { + C.ScintillaEdit_GotoPos(this.h, (C.intptr_t)(caret)) +} + +func (this *ScintillaEdit) SetAnchor(anchor uintptr) { + C.ScintillaEdit_SetAnchor(this.h, (C.intptr_t)(anchor)) +} + +func (this *ScintillaEdit) GetCurLine(length uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_GetCurLine(this.h, (C.intptr_t)(length)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) EndStyled() uintptr { + return (uintptr)(C.ScintillaEdit_EndStyled(this.h)) +} + +func (this *ScintillaEdit) ConvertEOLs(eolMode uintptr) { + C.ScintillaEdit_ConvertEOLs(this.h, (C.intptr_t)(eolMode)) +} + +func (this *ScintillaEdit) EOLMode() uintptr { + return (uintptr)(C.ScintillaEdit_EOLMode(this.h)) +} + +func (this *ScintillaEdit) SetEOLMode(eolMode uintptr) { + C.ScintillaEdit_SetEOLMode(this.h, (C.intptr_t)(eolMode)) +} + +func (this *ScintillaEdit) StartStyling(start uintptr, unused uintptr) { + C.ScintillaEdit_StartStyling(this.h, (C.intptr_t)(start), (C.intptr_t)(unused)) +} + +func (this *ScintillaEdit) SetStyling(length uintptr, style uintptr) { + C.ScintillaEdit_SetStyling(this.h, (C.intptr_t)(length), (C.intptr_t)(style)) +} + +func (this *ScintillaEdit) BufferedDraw() bool { + return (bool)(C.ScintillaEdit_BufferedDraw(this.h)) +} + +func (this *ScintillaEdit) SetBufferedDraw(buffered bool) { + C.ScintillaEdit_SetBufferedDraw(this.h, (C.bool)(buffered)) +} + +func (this *ScintillaEdit) SetTabWidth(tabWidth uintptr) { + C.ScintillaEdit_SetTabWidth(this.h, (C.intptr_t)(tabWidth)) +} + +func (this *ScintillaEdit) TabWidth() uintptr { + return (uintptr)(C.ScintillaEdit_TabWidth(this.h)) +} + +func (this *ScintillaEdit) SetTabMinimumWidth(pixels uintptr) { + C.ScintillaEdit_SetTabMinimumWidth(this.h, (C.intptr_t)(pixels)) +} + +func (this *ScintillaEdit) TabMinimumWidth() uintptr { + return (uintptr)(C.ScintillaEdit_TabMinimumWidth(this.h)) +} + +func (this *ScintillaEdit) ClearTabStops(line uintptr) { + C.ScintillaEdit_ClearTabStops(this.h, (C.intptr_t)(line)) +} + +func (this *ScintillaEdit) AddTabStop(line uintptr, x uintptr) { + C.ScintillaEdit_AddTabStop(this.h, (C.intptr_t)(line), (C.intptr_t)(x)) +} + +func (this *ScintillaEdit) GetNextTabStop(line uintptr, x uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_GetNextTabStop(this.h, (C.intptr_t)(line), (C.intptr_t)(x))) +} + +func (this *ScintillaEdit) SetCodePage(codePage uintptr) { + C.ScintillaEdit_SetCodePage(this.h, (C.intptr_t)(codePage)) +} + +func (this *ScintillaEdit) SetFontLocale(localeName string) { + localeName_Cstring := C.CString(localeName) + defer C.free(unsafe.Pointer(localeName_Cstring)) + C.ScintillaEdit_SetFontLocale(this.h, localeName_Cstring) +} + +func (this *ScintillaEdit) FontLocale() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_FontLocale(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) IMEInteraction() uintptr { + return (uintptr)(C.ScintillaEdit_IMEInteraction(this.h)) +} + +func (this *ScintillaEdit) SetIMEInteraction(imeInteraction uintptr) { + C.ScintillaEdit_SetIMEInteraction(this.h, (C.intptr_t)(imeInteraction)) +} + +func (this *ScintillaEdit) MarkerDefine(markerNumber uintptr, markerSymbol uintptr) { + C.ScintillaEdit_MarkerDefine(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(markerSymbol)) +} + +func (this *ScintillaEdit) MarkerSetFore(markerNumber uintptr, fore uintptr) { + C.ScintillaEdit_MarkerSetFore(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) MarkerSetBack(markerNumber uintptr, back uintptr) { + C.ScintillaEdit_MarkerSetBack(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) MarkerSetBackSelected(markerNumber uintptr, back uintptr) { + C.ScintillaEdit_MarkerSetBackSelected(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) MarkerSetForeTranslucent(markerNumber uintptr, fore uintptr) { + C.ScintillaEdit_MarkerSetForeTranslucent(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) MarkerSetBackTranslucent(markerNumber uintptr, back uintptr) { + C.ScintillaEdit_MarkerSetBackTranslucent(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) MarkerSetBackSelectedTranslucent(markerNumber uintptr, back uintptr) { + C.ScintillaEdit_MarkerSetBackSelectedTranslucent(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) MarkerSetStrokeWidth(markerNumber uintptr, hundredths uintptr) { + C.ScintillaEdit_MarkerSetStrokeWidth(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(hundredths)) +} + +func (this *ScintillaEdit) MarkerEnableHighlight(enabled bool) { + C.ScintillaEdit_MarkerEnableHighlight(this.h, (C.bool)(enabled)) +} + +func (this *ScintillaEdit) MarkerAdd(line uintptr, markerNumber uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarkerAdd(this.h, (C.intptr_t)(line), (C.intptr_t)(markerNumber))) +} + +func (this *ScintillaEdit) MarkerDelete(line uintptr, markerNumber uintptr) { + C.ScintillaEdit_MarkerDelete(this.h, (C.intptr_t)(line), (C.intptr_t)(markerNumber)) +} + +func (this *ScintillaEdit) MarkerDeleteAll(markerNumber uintptr) { + C.ScintillaEdit_MarkerDeleteAll(this.h, (C.intptr_t)(markerNumber)) +} + +func (this *ScintillaEdit) MarkerGet(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarkerGet(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) MarkerNext(lineStart uintptr, markerMask uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarkerNext(this.h, (C.intptr_t)(lineStart), (C.intptr_t)(markerMask))) +} + +func (this *ScintillaEdit) MarkerPrevious(lineStart uintptr, markerMask uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarkerPrevious(this.h, (C.intptr_t)(lineStart), (C.intptr_t)(markerMask))) +} + +func (this *ScintillaEdit) MarkerDefinePixmap(markerNumber uintptr, pixmap string) { + pixmap_Cstring := C.CString(pixmap) + defer C.free(unsafe.Pointer(pixmap_Cstring)) + C.ScintillaEdit_MarkerDefinePixmap(this.h, (C.intptr_t)(markerNumber), pixmap_Cstring) +} + +func (this *ScintillaEdit) MarkerAddSet(line uintptr, markerSet uintptr) { + C.ScintillaEdit_MarkerAddSet(this.h, (C.intptr_t)(line), (C.intptr_t)(markerSet)) +} + +func (this *ScintillaEdit) MarkerSetAlpha(markerNumber uintptr, alpha uintptr) { + C.ScintillaEdit_MarkerSetAlpha(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(alpha)) +} + +func (this *ScintillaEdit) MarkerLayer(markerNumber uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarkerLayer(this.h, (C.intptr_t)(markerNumber))) +} + +func (this *ScintillaEdit) MarkerSetLayer(markerNumber uintptr, layer uintptr) { + C.ScintillaEdit_MarkerSetLayer(this.h, (C.intptr_t)(markerNumber), (C.intptr_t)(layer)) +} + +func (this *ScintillaEdit) SetMarginTypeN(margin uintptr, marginType uintptr) { + C.ScintillaEdit_SetMarginTypeN(this.h, (C.intptr_t)(margin), (C.intptr_t)(marginType)) +} + +func (this *ScintillaEdit) MarginTypeN(margin uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarginTypeN(this.h, (C.intptr_t)(margin))) +} + +func (this *ScintillaEdit) SetMarginWidthN(margin uintptr, pixelWidth uintptr) { + C.ScintillaEdit_SetMarginWidthN(this.h, (C.intptr_t)(margin), (C.intptr_t)(pixelWidth)) +} + +func (this *ScintillaEdit) MarginWidthN(margin uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarginWidthN(this.h, (C.intptr_t)(margin))) +} + +func (this *ScintillaEdit) SetMarginMaskN(margin uintptr, mask uintptr) { + C.ScintillaEdit_SetMarginMaskN(this.h, (C.intptr_t)(margin), (C.intptr_t)(mask)) +} + +func (this *ScintillaEdit) MarginMaskN(margin uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarginMaskN(this.h, (C.intptr_t)(margin))) +} + +func (this *ScintillaEdit) SetMarginSensitiveN(margin uintptr, sensitive bool) { + C.ScintillaEdit_SetMarginSensitiveN(this.h, (C.intptr_t)(margin), (C.bool)(sensitive)) +} + +func (this *ScintillaEdit) MarginSensitiveN(margin uintptr) bool { + return (bool)(C.ScintillaEdit_MarginSensitiveN(this.h, (C.intptr_t)(margin))) +} + +func (this *ScintillaEdit) SetMarginCursorN(margin uintptr, cursor uintptr) { + C.ScintillaEdit_SetMarginCursorN(this.h, (C.intptr_t)(margin), (C.intptr_t)(cursor)) +} + +func (this *ScintillaEdit) MarginCursorN(margin uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarginCursorN(this.h, (C.intptr_t)(margin))) +} + +func (this *ScintillaEdit) SetMarginBackN(margin uintptr, back uintptr) { + C.ScintillaEdit_SetMarginBackN(this.h, (C.intptr_t)(margin), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) MarginBackN(margin uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarginBackN(this.h, (C.intptr_t)(margin))) +} + +func (this *ScintillaEdit) SetMargins(margins uintptr) { + C.ScintillaEdit_SetMargins(this.h, (C.intptr_t)(margins)) +} + +func (this *ScintillaEdit) Margins() uintptr { + return (uintptr)(C.ScintillaEdit_Margins(this.h)) +} + +func (this *ScintillaEdit) StyleClearAll() { + C.ScintillaEdit_StyleClearAll(this.h) +} + +func (this *ScintillaEdit) StyleSetFore(style uintptr, fore uintptr) { + C.ScintillaEdit_StyleSetFore(this.h, (C.intptr_t)(style), (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) StyleSetBack(style uintptr, back uintptr) { + C.ScintillaEdit_StyleSetBack(this.h, (C.intptr_t)(style), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) StyleSetBold(style uintptr, bold bool) { + C.ScintillaEdit_StyleSetBold(this.h, (C.intptr_t)(style), (C.bool)(bold)) +} + +func (this *ScintillaEdit) StyleSetItalic(style uintptr, italic bool) { + C.ScintillaEdit_StyleSetItalic(this.h, (C.intptr_t)(style), (C.bool)(italic)) +} + +func (this *ScintillaEdit) StyleSetSize(style uintptr, sizePoints uintptr) { + C.ScintillaEdit_StyleSetSize(this.h, (C.intptr_t)(style), (C.intptr_t)(sizePoints)) +} + +func (this *ScintillaEdit) StyleSetFont(style uintptr, fontName string) { + fontName_Cstring := C.CString(fontName) + defer C.free(unsafe.Pointer(fontName_Cstring)) + C.ScintillaEdit_StyleSetFont(this.h, (C.intptr_t)(style), fontName_Cstring) +} + +func (this *ScintillaEdit) StyleSetEOLFilled(style uintptr, eolFilled bool) { + C.ScintillaEdit_StyleSetEOLFilled(this.h, (C.intptr_t)(style), (C.bool)(eolFilled)) +} + +func (this *ScintillaEdit) StyleResetDefault() { + C.ScintillaEdit_StyleResetDefault(this.h) +} + +func (this *ScintillaEdit) StyleSetUnderline(style uintptr, underline bool) { + C.ScintillaEdit_StyleSetUnderline(this.h, (C.intptr_t)(style), (C.bool)(underline)) +} + +func (this *ScintillaEdit) StyleFore(style uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleFore(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleBack(style uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleBack(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleBold(style uintptr) bool { + return (bool)(C.ScintillaEdit_StyleBold(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleItalic(style uintptr) bool { + return (bool)(C.ScintillaEdit_StyleItalic(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleSize(style uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleSize(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleFont(style uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_StyleFont(this.h, (C.intptr_t)(style)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) StyleEOLFilled(style uintptr) bool { + return (bool)(C.ScintillaEdit_StyleEOLFilled(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleUnderline(style uintptr) bool { + return (bool)(C.ScintillaEdit_StyleUnderline(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleCase(style uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleCase(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleCharacterSet(style uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleCharacterSet(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleVisible(style uintptr) bool { + return (bool)(C.ScintillaEdit_StyleVisible(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleChangeable(style uintptr) bool { + return (bool)(C.ScintillaEdit_StyleChangeable(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleHotSpot(style uintptr) bool { + return (bool)(C.ScintillaEdit_StyleHotSpot(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleSetCase(style uintptr, caseVisible uintptr) { + C.ScintillaEdit_StyleSetCase(this.h, (C.intptr_t)(style), (C.intptr_t)(caseVisible)) +} + +func (this *ScintillaEdit) StyleSetSizeFractional(style uintptr, sizeHundredthPoints uintptr) { + C.ScintillaEdit_StyleSetSizeFractional(this.h, (C.intptr_t)(style), (C.intptr_t)(sizeHundredthPoints)) +} + +func (this *ScintillaEdit) StyleSizeFractional(style uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleSizeFractional(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleSetWeight(style uintptr, weight uintptr) { + C.ScintillaEdit_StyleSetWeight(this.h, (C.intptr_t)(style), (C.intptr_t)(weight)) +} + +func (this *ScintillaEdit) StyleWeight(style uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleWeight(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleSetCharacterSet(style uintptr, characterSet uintptr) { + C.ScintillaEdit_StyleSetCharacterSet(this.h, (C.intptr_t)(style), (C.intptr_t)(characterSet)) +} + +func (this *ScintillaEdit) StyleSetHotSpot(style uintptr, hotspot bool) { + C.ScintillaEdit_StyleSetHotSpot(this.h, (C.intptr_t)(style), (C.bool)(hotspot)) +} + +func (this *ScintillaEdit) StyleSetCheckMonospaced(style uintptr, checkMonospaced bool) { + C.ScintillaEdit_StyleSetCheckMonospaced(this.h, (C.intptr_t)(style), (C.bool)(checkMonospaced)) +} + +func (this *ScintillaEdit) StyleCheckMonospaced(style uintptr) bool { + return (bool)(C.ScintillaEdit_StyleCheckMonospaced(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleSetStretch(style uintptr, stretch uintptr) { + C.ScintillaEdit_StyleSetStretch(this.h, (C.intptr_t)(style), (C.intptr_t)(stretch)) +} + +func (this *ScintillaEdit) StyleStretch(style uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleStretch(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) StyleSetInvisibleRepresentation(style uintptr, representation string) { + representation_Cstring := C.CString(representation) + defer C.free(unsafe.Pointer(representation_Cstring)) + C.ScintillaEdit_StyleSetInvisibleRepresentation(this.h, (C.intptr_t)(style), representation_Cstring) +} + +func (this *ScintillaEdit) StyleInvisibleRepresentation(style uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_StyleInvisibleRepresentation(this.h, (C.intptr_t)(style)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) SetElementColour(element uintptr, colourElement uintptr) { + C.ScintillaEdit_SetElementColour(this.h, (C.intptr_t)(element), (C.intptr_t)(colourElement)) +} + +func (this *ScintillaEdit) ElementColour(element uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_ElementColour(this.h, (C.intptr_t)(element))) +} + +func (this *ScintillaEdit) ResetElementColour(element uintptr) { + C.ScintillaEdit_ResetElementColour(this.h, (C.intptr_t)(element)) +} + +func (this *ScintillaEdit) ElementIsSet(element uintptr) bool { + return (bool)(C.ScintillaEdit_ElementIsSet(this.h, (C.intptr_t)(element))) +} + +func (this *ScintillaEdit) ElementAllowsTranslucent(element uintptr) bool { + return (bool)(C.ScintillaEdit_ElementAllowsTranslucent(this.h, (C.intptr_t)(element))) +} + +func (this *ScintillaEdit) ElementBaseColour(element uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_ElementBaseColour(this.h, (C.intptr_t)(element))) +} + +func (this *ScintillaEdit) SetSelFore(useSetting bool, fore uintptr) { + C.ScintillaEdit_SetSelFore(this.h, (C.bool)(useSetting), (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) SetSelBack(useSetting bool, back uintptr) { + C.ScintillaEdit_SetSelBack(this.h, (C.bool)(useSetting), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) SelAlpha() uintptr { + return (uintptr)(C.ScintillaEdit_SelAlpha(this.h)) +} + +func (this *ScintillaEdit) SetSelAlpha(alpha uintptr) { + C.ScintillaEdit_SetSelAlpha(this.h, (C.intptr_t)(alpha)) +} + +func (this *ScintillaEdit) SelEOLFilled() bool { + return (bool)(C.ScintillaEdit_SelEOLFilled(this.h)) +} + +func (this *ScintillaEdit) SetSelEOLFilled(filled bool) { + C.ScintillaEdit_SetSelEOLFilled(this.h, (C.bool)(filled)) +} + +func (this *ScintillaEdit) SelectionLayer() uintptr { + return (uintptr)(C.ScintillaEdit_SelectionLayer(this.h)) +} + +func (this *ScintillaEdit) SetSelectionLayer(layer uintptr) { + C.ScintillaEdit_SetSelectionLayer(this.h, (C.intptr_t)(layer)) +} + +func (this *ScintillaEdit) CaretLineLayer() uintptr { + return (uintptr)(C.ScintillaEdit_CaretLineLayer(this.h)) +} + +func (this *ScintillaEdit) SetCaretLineLayer(layer uintptr) { + C.ScintillaEdit_SetCaretLineLayer(this.h, (C.intptr_t)(layer)) +} + +func (this *ScintillaEdit) CaretLineHighlightSubLine() bool { + return (bool)(C.ScintillaEdit_CaretLineHighlightSubLine(this.h)) +} + +func (this *ScintillaEdit) SetCaretLineHighlightSubLine(subLine bool) { + C.ScintillaEdit_SetCaretLineHighlightSubLine(this.h, (C.bool)(subLine)) +} + +func (this *ScintillaEdit) SetCaretFore(fore uintptr) { + C.ScintillaEdit_SetCaretFore(this.h, (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) AssignCmdKey(keyDefinition uintptr, sciCommand uintptr) { + C.ScintillaEdit_AssignCmdKey(this.h, (C.intptr_t)(keyDefinition), (C.intptr_t)(sciCommand)) +} + +func (this *ScintillaEdit) ClearCmdKey(keyDefinition uintptr) { + C.ScintillaEdit_ClearCmdKey(this.h, (C.intptr_t)(keyDefinition)) +} + +func (this *ScintillaEdit) ClearAllCmdKeys() { + C.ScintillaEdit_ClearAllCmdKeys(this.h) +} + +func (this *ScintillaEdit) SetStylingEx(length uintptr, styles string) { + styles_Cstring := C.CString(styles) + defer C.free(unsafe.Pointer(styles_Cstring)) + C.ScintillaEdit_SetStylingEx(this.h, (C.intptr_t)(length), styles_Cstring) +} + +func (this *ScintillaEdit) StyleSetVisible(style uintptr, visible bool) { + C.ScintillaEdit_StyleSetVisible(this.h, (C.intptr_t)(style), (C.bool)(visible)) +} + +func (this *ScintillaEdit) CaretPeriod() uintptr { + return (uintptr)(C.ScintillaEdit_CaretPeriod(this.h)) +} + +func (this *ScintillaEdit) SetCaretPeriod(periodMilliseconds uintptr) { + C.ScintillaEdit_SetCaretPeriod(this.h, (C.intptr_t)(periodMilliseconds)) +} + +func (this *ScintillaEdit) SetWordChars(characters string) { + characters_Cstring := C.CString(characters) + defer C.free(unsafe.Pointer(characters_Cstring)) + C.ScintillaEdit_SetWordChars(this.h, characters_Cstring) +} + +func (this *ScintillaEdit) WordChars() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_WordChars(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) SetCharacterCategoryOptimization(countCharacters uintptr) { + C.ScintillaEdit_SetCharacterCategoryOptimization(this.h, (C.intptr_t)(countCharacters)) +} + +func (this *ScintillaEdit) CharacterCategoryOptimization() uintptr { + return (uintptr)(C.ScintillaEdit_CharacterCategoryOptimization(this.h)) +} + +func (this *ScintillaEdit) BeginUndoAction() { + C.ScintillaEdit_BeginUndoAction(this.h) +} + +func (this *ScintillaEdit) EndUndoAction() { + C.ScintillaEdit_EndUndoAction(this.h) +} + +func (this *ScintillaEdit) UndoSequence() uintptr { + return (uintptr)(C.ScintillaEdit_UndoSequence(this.h)) +} + +func (this *ScintillaEdit) UndoActions() uintptr { + return (uintptr)(C.ScintillaEdit_UndoActions(this.h)) +} + +func (this *ScintillaEdit) SetUndoSavePoint(action uintptr) { + C.ScintillaEdit_SetUndoSavePoint(this.h, (C.intptr_t)(action)) +} + +func (this *ScintillaEdit) UndoSavePoint() uintptr { + return (uintptr)(C.ScintillaEdit_UndoSavePoint(this.h)) +} + +func (this *ScintillaEdit) SetUndoDetach(action uintptr) { + C.ScintillaEdit_SetUndoDetach(this.h, (C.intptr_t)(action)) +} + +func (this *ScintillaEdit) UndoDetach() uintptr { + return (uintptr)(C.ScintillaEdit_UndoDetach(this.h)) +} + +func (this *ScintillaEdit) SetUndoTentative(action uintptr) { + C.ScintillaEdit_SetUndoTentative(this.h, (C.intptr_t)(action)) +} + +func (this *ScintillaEdit) UndoTentative() uintptr { + return (uintptr)(C.ScintillaEdit_UndoTentative(this.h)) +} + +func (this *ScintillaEdit) SetUndoCurrent(action uintptr) { + C.ScintillaEdit_SetUndoCurrent(this.h, (C.intptr_t)(action)) +} + +func (this *ScintillaEdit) UndoCurrent() uintptr { + return (uintptr)(C.ScintillaEdit_UndoCurrent(this.h)) +} + +func (this *ScintillaEdit) PushUndoActionType(typeVal uintptr, pos uintptr) { + C.ScintillaEdit_PushUndoActionType(this.h, (C.intptr_t)(typeVal), (C.intptr_t)(pos)) +} + +func (this *ScintillaEdit) ChangeLastUndoActionText(length uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_ChangeLastUndoActionText(this.h, (C.intptr_t)(length), text_Cstring) +} + +func (this *ScintillaEdit) UndoActionType(action uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_UndoActionType(this.h, (C.intptr_t)(action))) +} + +func (this *ScintillaEdit) UndoActionPosition(action uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_UndoActionPosition(this.h, (C.intptr_t)(action))) +} + +func (this *ScintillaEdit) UndoActionText(action uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_UndoActionText(this.h, (C.intptr_t)(action)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) IndicSetStyle(indicator uintptr, indicatorStyle uintptr) { + C.ScintillaEdit_IndicSetStyle(this.h, (C.intptr_t)(indicator), (C.intptr_t)(indicatorStyle)) +} + +func (this *ScintillaEdit) IndicStyle(indicator uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicStyle(this.h, (C.intptr_t)(indicator))) +} + +func (this *ScintillaEdit) IndicSetFore(indicator uintptr, fore uintptr) { + C.ScintillaEdit_IndicSetFore(this.h, (C.intptr_t)(indicator), (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) IndicFore(indicator uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicFore(this.h, (C.intptr_t)(indicator))) +} + +func (this *ScintillaEdit) IndicSetUnder(indicator uintptr, under bool) { + C.ScintillaEdit_IndicSetUnder(this.h, (C.intptr_t)(indicator), (C.bool)(under)) +} + +func (this *ScintillaEdit) IndicUnder(indicator uintptr) bool { + return (bool)(C.ScintillaEdit_IndicUnder(this.h, (C.intptr_t)(indicator))) +} + +func (this *ScintillaEdit) IndicSetHoverStyle(indicator uintptr, indicatorStyle uintptr) { + C.ScintillaEdit_IndicSetHoverStyle(this.h, (C.intptr_t)(indicator), (C.intptr_t)(indicatorStyle)) +} + +func (this *ScintillaEdit) IndicHoverStyle(indicator uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicHoverStyle(this.h, (C.intptr_t)(indicator))) +} + +func (this *ScintillaEdit) IndicSetHoverFore(indicator uintptr, fore uintptr) { + C.ScintillaEdit_IndicSetHoverFore(this.h, (C.intptr_t)(indicator), (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) IndicHoverFore(indicator uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicHoverFore(this.h, (C.intptr_t)(indicator))) +} + +func (this *ScintillaEdit) IndicSetFlags(indicator uintptr, flags uintptr) { + C.ScintillaEdit_IndicSetFlags(this.h, (C.intptr_t)(indicator), (C.intptr_t)(flags)) +} + +func (this *ScintillaEdit) IndicFlags(indicator uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicFlags(this.h, (C.intptr_t)(indicator))) +} + +func (this *ScintillaEdit) IndicSetStrokeWidth(indicator uintptr, hundredths uintptr) { + C.ScintillaEdit_IndicSetStrokeWidth(this.h, (C.intptr_t)(indicator), (C.intptr_t)(hundredths)) +} + +func (this *ScintillaEdit) IndicStrokeWidth(indicator uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicStrokeWidth(this.h, (C.intptr_t)(indicator))) +} + +func (this *ScintillaEdit) SetWhitespaceFore(useSetting bool, fore uintptr) { + C.ScintillaEdit_SetWhitespaceFore(this.h, (C.bool)(useSetting), (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) SetWhitespaceBack(useSetting bool, back uintptr) { + C.ScintillaEdit_SetWhitespaceBack(this.h, (C.bool)(useSetting), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) SetWhitespaceSize(size uintptr) { + C.ScintillaEdit_SetWhitespaceSize(this.h, (C.intptr_t)(size)) +} + +func (this *ScintillaEdit) WhitespaceSize() uintptr { + return (uintptr)(C.ScintillaEdit_WhitespaceSize(this.h)) +} + +func (this *ScintillaEdit) SetLineState(line uintptr, state uintptr) { + C.ScintillaEdit_SetLineState(this.h, (C.intptr_t)(line), (C.intptr_t)(state)) +} + +func (this *ScintillaEdit) LineState(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_LineState(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) MaxLineState() uintptr { + return (uintptr)(C.ScintillaEdit_MaxLineState(this.h)) +} + +func (this *ScintillaEdit) CaretLineVisible() bool { + return (bool)(C.ScintillaEdit_CaretLineVisible(this.h)) +} + +func (this *ScintillaEdit) SetCaretLineVisible(show bool) { + C.ScintillaEdit_SetCaretLineVisible(this.h, (C.bool)(show)) +} + +func (this *ScintillaEdit) CaretLineBack() uintptr { + return (uintptr)(C.ScintillaEdit_CaretLineBack(this.h)) +} + +func (this *ScintillaEdit) SetCaretLineBack(back uintptr) { + C.ScintillaEdit_SetCaretLineBack(this.h, (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) CaretLineFrame() uintptr { + return (uintptr)(C.ScintillaEdit_CaretLineFrame(this.h)) +} + +func (this *ScintillaEdit) SetCaretLineFrame(width uintptr) { + C.ScintillaEdit_SetCaretLineFrame(this.h, (C.intptr_t)(width)) +} + +func (this *ScintillaEdit) StyleSetChangeable(style uintptr, changeable bool) { + C.ScintillaEdit_StyleSetChangeable(this.h, (C.intptr_t)(style), (C.bool)(changeable)) +} + +func (this *ScintillaEdit) AutoCShow(lengthEntered uintptr, itemList string) { + itemList_Cstring := C.CString(itemList) + defer C.free(unsafe.Pointer(itemList_Cstring)) + C.ScintillaEdit_AutoCShow(this.h, (C.intptr_t)(lengthEntered), itemList_Cstring) +} + +func (this *ScintillaEdit) AutoCCancel() { + C.ScintillaEdit_AutoCCancel(this.h) +} + +func (this *ScintillaEdit) AutoCActive() bool { + return (bool)(C.ScintillaEdit_AutoCActive(this.h)) +} + +func (this *ScintillaEdit) AutoCPosStart() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCPosStart(this.h)) +} + +func (this *ScintillaEdit) AutoCComplete() { + C.ScintillaEdit_AutoCComplete(this.h) +} + +func (this *ScintillaEdit) AutoCStops(characterSet string) { + characterSet_Cstring := C.CString(characterSet) + defer C.free(unsafe.Pointer(characterSet_Cstring)) + C.ScintillaEdit_AutoCStops(this.h, characterSet_Cstring) +} + +func (this *ScintillaEdit) AutoCSetSeparator(separatorCharacter uintptr) { + C.ScintillaEdit_AutoCSetSeparator(this.h, (C.intptr_t)(separatorCharacter)) +} + +func (this *ScintillaEdit) AutoCSeparator() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCSeparator(this.h)) +} + +func (this *ScintillaEdit) AutoCSelect(selectVal string) { + selectVal_Cstring := C.CString(selectVal) + defer C.free(unsafe.Pointer(selectVal_Cstring)) + C.ScintillaEdit_AutoCSelect(this.h, selectVal_Cstring) +} + +func (this *ScintillaEdit) AutoCSetCancelAtStart(cancel bool) { + C.ScintillaEdit_AutoCSetCancelAtStart(this.h, (C.bool)(cancel)) +} + +func (this *ScintillaEdit) AutoCCancelAtStart() bool { + return (bool)(C.ScintillaEdit_AutoCCancelAtStart(this.h)) +} + +func (this *ScintillaEdit) AutoCSetFillUps(characterSet string) { + characterSet_Cstring := C.CString(characterSet) + defer C.free(unsafe.Pointer(characterSet_Cstring)) + C.ScintillaEdit_AutoCSetFillUps(this.h, characterSet_Cstring) +} + +func (this *ScintillaEdit) AutoCSetChooseSingle(chooseSingle bool) { + C.ScintillaEdit_AutoCSetChooseSingle(this.h, (C.bool)(chooseSingle)) +} + +func (this *ScintillaEdit) AutoCChooseSingle() bool { + return (bool)(C.ScintillaEdit_AutoCChooseSingle(this.h)) +} + +func (this *ScintillaEdit) AutoCSetIgnoreCase(ignoreCase bool) { + C.ScintillaEdit_AutoCSetIgnoreCase(this.h, (C.bool)(ignoreCase)) +} + +func (this *ScintillaEdit) AutoCIgnoreCase() bool { + return (bool)(C.ScintillaEdit_AutoCIgnoreCase(this.h)) +} + +func (this *ScintillaEdit) UserListShow(listType uintptr, itemList string) { + itemList_Cstring := C.CString(itemList) + defer C.free(unsafe.Pointer(itemList_Cstring)) + C.ScintillaEdit_UserListShow(this.h, (C.intptr_t)(listType), itemList_Cstring) +} + +func (this *ScintillaEdit) AutoCSetAutoHide(autoHide bool) { + C.ScintillaEdit_AutoCSetAutoHide(this.h, (C.bool)(autoHide)) +} + +func (this *ScintillaEdit) AutoCAutoHide() bool { + return (bool)(C.ScintillaEdit_AutoCAutoHide(this.h)) +} + +func (this *ScintillaEdit) AutoCSetOptions(options uintptr) { + C.ScintillaEdit_AutoCSetOptions(this.h, (C.intptr_t)(options)) +} + +func (this *ScintillaEdit) AutoCOptions() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCOptions(this.h)) +} + +func (this *ScintillaEdit) AutoCSetDropRestOfWord(dropRestOfWord bool) { + C.ScintillaEdit_AutoCSetDropRestOfWord(this.h, (C.bool)(dropRestOfWord)) +} + +func (this *ScintillaEdit) AutoCDropRestOfWord() bool { + return (bool)(C.ScintillaEdit_AutoCDropRestOfWord(this.h)) +} + +func (this *ScintillaEdit) RegisterImage(typeVal uintptr, xpmData string) { + xpmData_Cstring := C.CString(xpmData) + defer C.free(unsafe.Pointer(xpmData_Cstring)) + C.ScintillaEdit_RegisterImage(this.h, (C.intptr_t)(typeVal), xpmData_Cstring) +} + +func (this *ScintillaEdit) ClearRegisteredImages() { + C.ScintillaEdit_ClearRegisteredImages(this.h) +} + +func (this *ScintillaEdit) AutoCTypeSeparator() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCTypeSeparator(this.h)) +} + +func (this *ScintillaEdit) AutoCSetTypeSeparator(separatorCharacter uintptr) { + C.ScintillaEdit_AutoCSetTypeSeparator(this.h, (C.intptr_t)(separatorCharacter)) +} + +func (this *ScintillaEdit) AutoCSetMaxWidth(characterCount uintptr) { + C.ScintillaEdit_AutoCSetMaxWidth(this.h, (C.intptr_t)(characterCount)) +} + +func (this *ScintillaEdit) AutoCMaxWidth() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCMaxWidth(this.h)) +} + +func (this *ScintillaEdit) AutoCSetMaxHeight(rowCount uintptr) { + C.ScintillaEdit_AutoCSetMaxHeight(this.h, (C.intptr_t)(rowCount)) +} + +func (this *ScintillaEdit) AutoCMaxHeight() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCMaxHeight(this.h)) +} + +func (this *ScintillaEdit) AutoCSetStyle(style uintptr) { + C.ScintillaEdit_AutoCSetStyle(this.h, (C.intptr_t)(style)) +} + +func (this *ScintillaEdit) AutoCStyle() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCStyle(this.h)) +} + +func (this *ScintillaEdit) SetIndent(indentSize uintptr) { + C.ScintillaEdit_SetIndent(this.h, (C.intptr_t)(indentSize)) +} + +func (this *ScintillaEdit) Indent() uintptr { + return (uintptr)(C.ScintillaEdit_Indent(this.h)) +} + +func (this *ScintillaEdit) SetUseTabs(useTabs bool) { + C.ScintillaEdit_SetUseTabs(this.h, (C.bool)(useTabs)) +} + +func (this *ScintillaEdit) UseTabs() bool { + return (bool)(C.ScintillaEdit_UseTabs(this.h)) +} + +func (this *ScintillaEdit) SetLineIndentation(line uintptr, indentation uintptr) { + C.ScintillaEdit_SetLineIndentation(this.h, (C.intptr_t)(line), (C.intptr_t)(indentation)) +} + +func (this *ScintillaEdit) LineIndentation(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_LineIndentation(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) LineIndentPosition(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_LineIndentPosition(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) Column(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_Column(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) CountCharacters(start uintptr, end uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_CountCharacters(this.h, (C.intptr_t)(start), (C.intptr_t)(end))) +} + +func (this *ScintillaEdit) CountCodeUnits(start uintptr, end uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_CountCodeUnits(this.h, (C.intptr_t)(start), (C.intptr_t)(end))) +} + +func (this *ScintillaEdit) SetHScrollBar(visible bool) { + C.ScintillaEdit_SetHScrollBar(this.h, (C.bool)(visible)) +} + +func (this *ScintillaEdit) HScrollBar() bool { + return (bool)(C.ScintillaEdit_HScrollBar(this.h)) +} + +func (this *ScintillaEdit) SetIndentationGuides(indentView uintptr) { + C.ScintillaEdit_SetIndentationGuides(this.h, (C.intptr_t)(indentView)) +} + +func (this *ScintillaEdit) IndentationGuides() uintptr { + return (uintptr)(C.ScintillaEdit_IndentationGuides(this.h)) +} + +func (this *ScintillaEdit) SetHighlightGuide(column uintptr) { + C.ScintillaEdit_SetHighlightGuide(this.h, (C.intptr_t)(column)) +} + +func (this *ScintillaEdit) HighlightGuide() uintptr { + return (uintptr)(C.ScintillaEdit_HighlightGuide(this.h)) +} + +func (this *ScintillaEdit) LineEndPosition(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_LineEndPosition(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) CodePage() uintptr { + return (uintptr)(C.ScintillaEdit_CodePage(this.h)) +} + +func (this *ScintillaEdit) CaretFore() uintptr { + return (uintptr)(C.ScintillaEdit_CaretFore(this.h)) +} + +func (this *ScintillaEdit) ReadOnly() bool { + return (bool)(C.ScintillaEdit_ReadOnly(this.h)) +} + +func (this *ScintillaEdit) SetCurrentPos(caret uintptr) { + C.ScintillaEdit_SetCurrentPos(this.h, (C.intptr_t)(caret)) +} + +func (this *ScintillaEdit) SetSelectionStart(anchor uintptr) { + C.ScintillaEdit_SetSelectionStart(this.h, (C.intptr_t)(anchor)) +} + +func (this *ScintillaEdit) SelectionStart() uintptr { + return (uintptr)(C.ScintillaEdit_SelectionStart(this.h)) +} + +func (this *ScintillaEdit) SetSelectionEnd(caret uintptr) { + C.ScintillaEdit_SetSelectionEnd(this.h, (C.intptr_t)(caret)) +} + +func (this *ScintillaEdit) SelectionEnd() uintptr { + return (uintptr)(C.ScintillaEdit_SelectionEnd(this.h)) +} + +func (this *ScintillaEdit) SetEmptySelection(caret uintptr) { + C.ScintillaEdit_SetEmptySelection(this.h, (C.intptr_t)(caret)) +} + +func (this *ScintillaEdit) SetPrintMagnification(magnification uintptr) { + C.ScintillaEdit_SetPrintMagnification(this.h, (C.intptr_t)(magnification)) +} + +func (this *ScintillaEdit) PrintMagnification() uintptr { + return (uintptr)(C.ScintillaEdit_PrintMagnification(this.h)) +} + +func (this *ScintillaEdit) SetPrintColourMode(mode uintptr) { + C.ScintillaEdit_SetPrintColourMode(this.h, (C.intptr_t)(mode)) +} + +func (this *ScintillaEdit) PrintColourMode() uintptr { + return (uintptr)(C.ScintillaEdit_PrintColourMode(this.h)) +} + +func (this *ScintillaEdit) SetChangeHistory(changeHistory uintptr) { + C.ScintillaEdit_SetChangeHistory(this.h, (C.intptr_t)(changeHistory)) +} + +func (this *ScintillaEdit) ChangeHistory() uintptr { + return (uintptr)(C.ScintillaEdit_ChangeHistory(this.h)) +} + +func (this *ScintillaEdit) FirstVisibleLine() uintptr { + return (uintptr)(C.ScintillaEdit_FirstVisibleLine(this.h)) +} + +func (this *ScintillaEdit) GetLine(line uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_GetLine(this.h, (C.intptr_t)(line)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) LineCount() uintptr { + return (uintptr)(C.ScintillaEdit_LineCount(this.h)) +} + +func (this *ScintillaEdit) AllocateLines(lines uintptr) { + C.ScintillaEdit_AllocateLines(this.h, (C.intptr_t)(lines)) +} + +func (this *ScintillaEdit) SetMarginLeft(pixelWidth uintptr) { + C.ScintillaEdit_SetMarginLeft(this.h, (C.intptr_t)(pixelWidth)) +} + +func (this *ScintillaEdit) MarginLeft() uintptr { + return (uintptr)(C.ScintillaEdit_MarginLeft(this.h)) +} + +func (this *ScintillaEdit) SetMarginRight(pixelWidth uintptr) { + C.ScintillaEdit_SetMarginRight(this.h, (C.intptr_t)(pixelWidth)) +} + +func (this *ScintillaEdit) MarginRight() uintptr { + return (uintptr)(C.ScintillaEdit_MarginRight(this.h)) +} + +func (this *ScintillaEdit) Modify() bool { + return (bool)(C.ScintillaEdit_Modify(this.h)) +} + +func (this *ScintillaEdit) SetSel(anchor uintptr, caret uintptr) { + C.ScintillaEdit_SetSel(this.h, (C.intptr_t)(anchor), (C.intptr_t)(caret)) +} + +func (this *ScintillaEdit) GetSelText() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_GetSelText(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) HideSelection(hide bool) { + C.ScintillaEdit_HideSelection(this.h, (C.bool)(hide)) +} + +func (this *ScintillaEdit) SelectionHidden() bool { + return (bool)(C.ScintillaEdit_SelectionHidden(this.h)) +} + +func (this *ScintillaEdit) PointXFromPosition(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PointXFromPosition(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) PointYFromPosition(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PointYFromPosition(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) LineFromPosition(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_LineFromPosition(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) PositionFromLine(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PositionFromLine(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) LineScroll(columns uintptr, lines uintptr) { + C.ScintillaEdit_LineScroll(this.h, (C.intptr_t)(columns), (C.intptr_t)(lines)) +} + +func (this *ScintillaEdit) ScrollCaret() { + C.ScintillaEdit_ScrollCaret(this.h) +} + +func (this *ScintillaEdit) ScrollRange(secondary uintptr, primary uintptr) { + C.ScintillaEdit_ScrollRange(this.h, (C.intptr_t)(secondary), (C.intptr_t)(primary)) +} + +func (this *ScintillaEdit) ReplaceSel(text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_ReplaceSel(this.h, text_Cstring) +} + +func (this *ScintillaEdit) SetReadOnly(readOnly bool) { + C.ScintillaEdit_SetReadOnly(this.h, (C.bool)(readOnly)) +} + +func (this *ScintillaEdit) Null() { + C.ScintillaEdit_Null(this.h) +} + +func (this *ScintillaEdit) CanPaste() bool { + return (bool)(C.ScintillaEdit_CanPaste(this.h)) +} + +func (this *ScintillaEdit) CanUndo() bool { + return (bool)(C.ScintillaEdit_CanUndo(this.h)) +} + +func (this *ScintillaEdit) EmptyUndoBuffer() { + C.ScintillaEdit_EmptyUndoBuffer(this.h) +} + +func (this *ScintillaEdit) Undo() { + C.ScintillaEdit_Undo(this.h) +} + +func (this *ScintillaEdit) Cut() { + C.ScintillaEdit_Cut(this.h) +} + +func (this *ScintillaEdit) Copy() { + C.ScintillaEdit_Copy(this.h) +} + +func (this *ScintillaEdit) Paste() { + C.ScintillaEdit_Paste(this.h) +} + +func (this *ScintillaEdit) Clear() { + C.ScintillaEdit_Clear(this.h) +} + +func (this *ScintillaEdit) SetText(text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_SetText(this.h, text_Cstring) +} + +func (this *ScintillaEdit) GetText(length uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_GetText(this.h, (C.intptr_t)(length)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) TextLength() uintptr { + return (uintptr)(C.ScintillaEdit_TextLength(this.h)) +} + +func (this *ScintillaEdit) DirectFunction() uintptr { + return (uintptr)(C.ScintillaEdit_DirectFunction(this.h)) +} + +func (this *ScintillaEdit) DirectStatusFunction() uintptr { + return (uintptr)(C.ScintillaEdit_DirectStatusFunction(this.h)) +} + +func (this *ScintillaEdit) DirectPointer() uintptr { + return (uintptr)(C.ScintillaEdit_DirectPointer(this.h)) +} + +func (this *ScintillaEdit) SetOvertype(overType bool) { + C.ScintillaEdit_SetOvertype(this.h, (C.bool)(overType)) +} + +func (this *ScintillaEdit) Overtype() bool { + return (bool)(C.ScintillaEdit_Overtype(this.h)) +} + +func (this *ScintillaEdit) SetCaretWidth(pixelWidth uintptr) { + C.ScintillaEdit_SetCaretWidth(this.h, (C.intptr_t)(pixelWidth)) +} + +func (this *ScintillaEdit) CaretWidth() uintptr { + return (uintptr)(C.ScintillaEdit_CaretWidth(this.h)) +} + +func (this *ScintillaEdit) SetTargetStart(start uintptr) { + C.ScintillaEdit_SetTargetStart(this.h, (C.intptr_t)(start)) +} + +func (this *ScintillaEdit) TargetStart() uintptr { + return (uintptr)(C.ScintillaEdit_TargetStart(this.h)) +} + +func (this *ScintillaEdit) SetTargetStartVirtualSpace(space uintptr) { + C.ScintillaEdit_SetTargetStartVirtualSpace(this.h, (C.intptr_t)(space)) +} + +func (this *ScintillaEdit) TargetStartVirtualSpace() uintptr { + return (uintptr)(C.ScintillaEdit_TargetStartVirtualSpace(this.h)) +} + +func (this *ScintillaEdit) SetTargetEnd(end uintptr) { + C.ScintillaEdit_SetTargetEnd(this.h, (C.intptr_t)(end)) +} + +func (this *ScintillaEdit) TargetEnd() uintptr { + return (uintptr)(C.ScintillaEdit_TargetEnd(this.h)) +} + +func (this *ScintillaEdit) SetTargetEndVirtualSpace(space uintptr) { + C.ScintillaEdit_SetTargetEndVirtualSpace(this.h, (C.intptr_t)(space)) +} + +func (this *ScintillaEdit) TargetEndVirtualSpace() uintptr { + return (uintptr)(C.ScintillaEdit_TargetEndVirtualSpace(this.h)) +} + +func (this *ScintillaEdit) SetTargetRange(start uintptr, end uintptr) { + C.ScintillaEdit_SetTargetRange(this.h, (C.intptr_t)(start), (C.intptr_t)(end)) +} + +func (this *ScintillaEdit) TargetText() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_TargetText(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) TargetFromSelection() { + C.ScintillaEdit_TargetFromSelection(this.h) +} + +func (this *ScintillaEdit) TargetWholeDocument() { + C.ScintillaEdit_TargetWholeDocument(this.h) +} + +func (this *ScintillaEdit) ReplaceTarget(length uintptr, text string) uintptr { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + return (uintptr)(C.ScintillaEdit_ReplaceTarget(this.h, (C.intptr_t)(length), text_Cstring)) +} + +func (this *ScintillaEdit) ReplaceTargetRE(length uintptr, text string) uintptr { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + return (uintptr)(C.ScintillaEdit_ReplaceTargetRE(this.h, (C.intptr_t)(length), text_Cstring)) +} + +func (this *ScintillaEdit) ReplaceTargetMinimal(length uintptr, text string) uintptr { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + return (uintptr)(C.ScintillaEdit_ReplaceTargetMinimal(this.h, (C.intptr_t)(length), text_Cstring)) +} + +func (this *ScintillaEdit) SearchInTarget(length uintptr, text string) uintptr { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + return (uintptr)(C.ScintillaEdit_SearchInTarget(this.h, (C.intptr_t)(length), text_Cstring)) +} + +func (this *ScintillaEdit) SetSearchFlags(searchFlags uintptr) { + C.ScintillaEdit_SetSearchFlags(this.h, (C.intptr_t)(searchFlags)) +} + +func (this *ScintillaEdit) SearchFlags() uintptr { + return (uintptr)(C.ScintillaEdit_SearchFlags(this.h)) +} + +func (this *ScintillaEdit) CallTipShow(pos uintptr, definition string) { + definition_Cstring := C.CString(definition) + defer C.free(unsafe.Pointer(definition_Cstring)) + C.ScintillaEdit_CallTipShow(this.h, (C.intptr_t)(pos), definition_Cstring) +} + +func (this *ScintillaEdit) CallTipCancel() { + C.ScintillaEdit_CallTipCancel(this.h) +} + +func (this *ScintillaEdit) CallTipActive() bool { + return (bool)(C.ScintillaEdit_CallTipActive(this.h)) +} + +func (this *ScintillaEdit) CallTipPosStart() uintptr { + return (uintptr)(C.ScintillaEdit_CallTipPosStart(this.h)) +} + +func (this *ScintillaEdit) CallTipSetPosStart(posStart uintptr) { + C.ScintillaEdit_CallTipSetPosStart(this.h, (C.intptr_t)(posStart)) +} + +func (this *ScintillaEdit) CallTipSetHlt(highlightStart uintptr, highlightEnd uintptr) { + C.ScintillaEdit_CallTipSetHlt(this.h, (C.intptr_t)(highlightStart), (C.intptr_t)(highlightEnd)) +} + +func (this *ScintillaEdit) CallTipSetBack(back uintptr) { + C.ScintillaEdit_CallTipSetBack(this.h, (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) CallTipSetFore(fore uintptr) { + C.ScintillaEdit_CallTipSetFore(this.h, (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) CallTipSetForeHlt(fore uintptr) { + C.ScintillaEdit_CallTipSetForeHlt(this.h, (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) CallTipUseStyle(tabSize uintptr) { + C.ScintillaEdit_CallTipUseStyle(this.h, (C.intptr_t)(tabSize)) +} + +func (this *ScintillaEdit) CallTipSetPosition(above bool) { + C.ScintillaEdit_CallTipSetPosition(this.h, (C.bool)(above)) +} + +func (this *ScintillaEdit) VisibleFromDocLine(docLine uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_VisibleFromDocLine(this.h, (C.intptr_t)(docLine))) +} + +func (this *ScintillaEdit) DocLineFromVisible(displayLine uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_DocLineFromVisible(this.h, (C.intptr_t)(displayLine))) +} + +func (this *ScintillaEdit) WrapCount(docLine uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_WrapCount(this.h, (C.intptr_t)(docLine))) +} + +func (this *ScintillaEdit) SetFoldLevel(line uintptr, level uintptr) { + C.ScintillaEdit_SetFoldLevel(this.h, (C.intptr_t)(line), (C.intptr_t)(level)) +} + +func (this *ScintillaEdit) FoldLevel(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_FoldLevel(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) LastChild(line uintptr, level uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_LastChild(this.h, (C.intptr_t)(line), (C.intptr_t)(level))) +} + +func (this *ScintillaEdit) FoldParent(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_FoldParent(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) ShowLines(lineStart uintptr, lineEnd uintptr) { + C.ScintillaEdit_ShowLines(this.h, (C.intptr_t)(lineStart), (C.intptr_t)(lineEnd)) +} + +func (this *ScintillaEdit) HideLines(lineStart uintptr, lineEnd uintptr) { + C.ScintillaEdit_HideLines(this.h, (C.intptr_t)(lineStart), (C.intptr_t)(lineEnd)) +} + +func (this *ScintillaEdit) LineVisible(line uintptr) bool { + return (bool)(C.ScintillaEdit_LineVisible(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) AllLinesVisible() bool { + return (bool)(C.ScintillaEdit_AllLinesVisible(this.h)) +} + +func (this *ScintillaEdit) SetFoldExpanded(line uintptr, expanded bool) { + C.ScintillaEdit_SetFoldExpanded(this.h, (C.intptr_t)(line), (C.bool)(expanded)) +} + +func (this *ScintillaEdit) FoldExpanded(line uintptr) bool { + return (bool)(C.ScintillaEdit_FoldExpanded(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) ToggleFold(line uintptr) { + C.ScintillaEdit_ToggleFold(this.h, (C.intptr_t)(line)) +} + +func (this *ScintillaEdit) ToggleFoldShowText(line uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_ToggleFoldShowText(this.h, (C.intptr_t)(line), text_Cstring) +} + +func (this *ScintillaEdit) FoldDisplayTextSetStyle(style uintptr) { + C.ScintillaEdit_FoldDisplayTextSetStyle(this.h, (C.intptr_t)(style)) +} + +func (this *ScintillaEdit) FoldDisplayTextStyle() uintptr { + return (uintptr)(C.ScintillaEdit_FoldDisplayTextStyle(this.h)) +} + +func (this *ScintillaEdit) SetDefaultFoldDisplayText(text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_SetDefaultFoldDisplayText(this.h, text_Cstring) +} + +func (this *ScintillaEdit) GetDefaultFoldDisplayText() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_GetDefaultFoldDisplayText(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) FoldLine(line uintptr, action uintptr) { + C.ScintillaEdit_FoldLine(this.h, (C.intptr_t)(line), (C.intptr_t)(action)) +} + +func (this *ScintillaEdit) FoldChildren(line uintptr, action uintptr) { + C.ScintillaEdit_FoldChildren(this.h, (C.intptr_t)(line), (C.intptr_t)(action)) +} + +func (this *ScintillaEdit) ExpandChildren(line uintptr, level uintptr) { + C.ScintillaEdit_ExpandChildren(this.h, (C.intptr_t)(line), (C.intptr_t)(level)) +} + +func (this *ScintillaEdit) FoldAll(action uintptr) { + C.ScintillaEdit_FoldAll(this.h, (C.intptr_t)(action)) +} + +func (this *ScintillaEdit) EnsureVisible(line uintptr) { + C.ScintillaEdit_EnsureVisible(this.h, (C.intptr_t)(line)) +} + +func (this *ScintillaEdit) SetAutomaticFold(automaticFold uintptr) { + C.ScintillaEdit_SetAutomaticFold(this.h, (C.intptr_t)(automaticFold)) +} + +func (this *ScintillaEdit) AutomaticFold() uintptr { + return (uintptr)(C.ScintillaEdit_AutomaticFold(this.h)) +} + +func (this *ScintillaEdit) SetFoldFlags(flags uintptr) { + C.ScintillaEdit_SetFoldFlags(this.h, (C.intptr_t)(flags)) +} + +func (this *ScintillaEdit) EnsureVisibleEnforcePolicy(line uintptr) { + C.ScintillaEdit_EnsureVisibleEnforcePolicy(this.h, (C.intptr_t)(line)) +} + +func (this *ScintillaEdit) SetTabIndents(tabIndents bool) { + C.ScintillaEdit_SetTabIndents(this.h, (C.bool)(tabIndents)) +} + +func (this *ScintillaEdit) TabIndents() bool { + return (bool)(C.ScintillaEdit_TabIndents(this.h)) +} + +func (this *ScintillaEdit) SetBackSpaceUnIndents(bsUnIndents bool) { + C.ScintillaEdit_SetBackSpaceUnIndents(this.h, (C.bool)(bsUnIndents)) +} + +func (this *ScintillaEdit) BackSpaceUnIndents() bool { + return (bool)(C.ScintillaEdit_BackSpaceUnIndents(this.h)) +} + +func (this *ScintillaEdit) SetMouseDwellTime(periodMilliseconds uintptr) { + C.ScintillaEdit_SetMouseDwellTime(this.h, (C.intptr_t)(periodMilliseconds)) +} + +func (this *ScintillaEdit) MouseDwellTime() uintptr { + return (uintptr)(C.ScintillaEdit_MouseDwellTime(this.h)) +} + +func (this *ScintillaEdit) WordStartPosition(pos uintptr, onlyWordCharacters bool) uintptr { + return (uintptr)(C.ScintillaEdit_WordStartPosition(this.h, (C.intptr_t)(pos), (C.bool)(onlyWordCharacters))) +} + +func (this *ScintillaEdit) WordEndPosition(pos uintptr, onlyWordCharacters bool) uintptr { + return (uintptr)(C.ScintillaEdit_WordEndPosition(this.h, (C.intptr_t)(pos), (C.bool)(onlyWordCharacters))) +} + +func (this *ScintillaEdit) IsRangeWord(start uintptr, end uintptr) bool { + return (bool)(C.ScintillaEdit_IsRangeWord(this.h, (C.intptr_t)(start), (C.intptr_t)(end))) +} + +func (this *ScintillaEdit) SetIdleStyling(idleStyling uintptr) { + C.ScintillaEdit_SetIdleStyling(this.h, (C.intptr_t)(idleStyling)) +} + +func (this *ScintillaEdit) IdleStyling() uintptr { + return (uintptr)(C.ScintillaEdit_IdleStyling(this.h)) +} + +func (this *ScintillaEdit) SetWrapMode(wrapMode uintptr) { + C.ScintillaEdit_SetWrapMode(this.h, (C.intptr_t)(wrapMode)) +} + +func (this *ScintillaEdit) WrapMode() uintptr { + return (uintptr)(C.ScintillaEdit_WrapMode(this.h)) +} + +func (this *ScintillaEdit) SetWrapVisualFlags(wrapVisualFlags uintptr) { + C.ScintillaEdit_SetWrapVisualFlags(this.h, (C.intptr_t)(wrapVisualFlags)) +} + +func (this *ScintillaEdit) WrapVisualFlags() uintptr { + return (uintptr)(C.ScintillaEdit_WrapVisualFlags(this.h)) +} + +func (this *ScintillaEdit) SetWrapVisualFlagsLocation(wrapVisualFlagsLocation uintptr) { + C.ScintillaEdit_SetWrapVisualFlagsLocation(this.h, (C.intptr_t)(wrapVisualFlagsLocation)) +} + +func (this *ScintillaEdit) WrapVisualFlagsLocation() uintptr { + return (uintptr)(C.ScintillaEdit_WrapVisualFlagsLocation(this.h)) +} + +func (this *ScintillaEdit) SetWrapStartIndent(indent uintptr) { + C.ScintillaEdit_SetWrapStartIndent(this.h, (C.intptr_t)(indent)) +} + +func (this *ScintillaEdit) WrapStartIndent() uintptr { + return (uintptr)(C.ScintillaEdit_WrapStartIndent(this.h)) +} + +func (this *ScintillaEdit) SetWrapIndentMode(wrapIndentMode uintptr) { + C.ScintillaEdit_SetWrapIndentMode(this.h, (C.intptr_t)(wrapIndentMode)) +} + +func (this *ScintillaEdit) WrapIndentMode() uintptr { + return (uintptr)(C.ScintillaEdit_WrapIndentMode(this.h)) +} + +func (this *ScintillaEdit) SetLayoutCache(cacheMode uintptr) { + C.ScintillaEdit_SetLayoutCache(this.h, (C.intptr_t)(cacheMode)) +} + +func (this *ScintillaEdit) LayoutCache() uintptr { + return (uintptr)(C.ScintillaEdit_LayoutCache(this.h)) +} + +func (this *ScintillaEdit) SetScrollWidth(pixelWidth uintptr) { + C.ScintillaEdit_SetScrollWidth(this.h, (C.intptr_t)(pixelWidth)) +} + +func (this *ScintillaEdit) ScrollWidth() uintptr { + return (uintptr)(C.ScintillaEdit_ScrollWidth(this.h)) +} + +func (this *ScintillaEdit) SetScrollWidthTracking(tracking bool) { + C.ScintillaEdit_SetScrollWidthTracking(this.h, (C.bool)(tracking)) +} + +func (this *ScintillaEdit) ScrollWidthTracking() bool { + return (bool)(C.ScintillaEdit_ScrollWidthTracking(this.h)) +} + +func (this *ScintillaEdit) TextWidth(style uintptr, text string) uintptr { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + return (uintptr)(C.ScintillaEdit_TextWidth(this.h, (C.intptr_t)(style), text_Cstring)) +} + +func (this *ScintillaEdit) SetEndAtLastLine(endAtLastLine bool) { + C.ScintillaEdit_SetEndAtLastLine(this.h, (C.bool)(endAtLastLine)) +} + +func (this *ScintillaEdit) EndAtLastLine() bool { + return (bool)(C.ScintillaEdit_EndAtLastLine(this.h)) +} + +func (this *ScintillaEdit) TextHeight(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_TextHeight(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) SetVScrollBar(visible bool) { + C.ScintillaEdit_SetVScrollBar(this.h, (C.bool)(visible)) +} + +func (this *ScintillaEdit) VScrollBar() bool { + return (bool)(C.ScintillaEdit_VScrollBar(this.h)) +} + +func (this *ScintillaEdit) AppendText(length uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_AppendText(this.h, (C.intptr_t)(length), text_Cstring) +} + +func (this *ScintillaEdit) PhasesDraw() uintptr { + return (uintptr)(C.ScintillaEdit_PhasesDraw(this.h)) +} + +func (this *ScintillaEdit) SetPhasesDraw(phases uintptr) { + C.ScintillaEdit_SetPhasesDraw(this.h, (C.intptr_t)(phases)) +} + +func (this *ScintillaEdit) SetFontQuality(fontQuality uintptr) { + C.ScintillaEdit_SetFontQuality(this.h, (C.intptr_t)(fontQuality)) +} + +func (this *ScintillaEdit) FontQuality() uintptr { + return (uintptr)(C.ScintillaEdit_FontQuality(this.h)) +} + +func (this *ScintillaEdit) SetFirstVisibleLine(displayLine uintptr) { + C.ScintillaEdit_SetFirstVisibleLine(this.h, (C.intptr_t)(displayLine)) +} + +func (this *ScintillaEdit) SetMultiPaste(multiPaste uintptr) { + C.ScintillaEdit_SetMultiPaste(this.h, (C.intptr_t)(multiPaste)) +} + +func (this *ScintillaEdit) MultiPaste() uintptr { + return (uintptr)(C.ScintillaEdit_MultiPaste(this.h)) +} + +func (this *ScintillaEdit) Tag(tagNumber uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_Tag(this.h, (C.intptr_t)(tagNumber)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) LinesJoin() { + C.ScintillaEdit_LinesJoin(this.h) +} + +func (this *ScintillaEdit) LinesSplit(pixelWidth uintptr) { + C.ScintillaEdit_LinesSplit(this.h, (C.intptr_t)(pixelWidth)) +} + +func (this *ScintillaEdit) SetFoldMarginColour(useSetting bool, back uintptr) { + C.ScintillaEdit_SetFoldMarginColour(this.h, (C.bool)(useSetting), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) SetFoldMarginHiColour(useSetting bool, fore uintptr) { + C.ScintillaEdit_SetFoldMarginHiColour(this.h, (C.bool)(useSetting), (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) SetAccessibility(accessibility uintptr) { + C.ScintillaEdit_SetAccessibility(this.h, (C.intptr_t)(accessibility)) +} + +func (this *ScintillaEdit) Accessibility() uintptr { + return (uintptr)(C.ScintillaEdit_Accessibility(this.h)) +} + +func (this *ScintillaEdit) LineDown() { + C.ScintillaEdit_LineDown(this.h) +} + +func (this *ScintillaEdit) LineDownExtend() { + C.ScintillaEdit_LineDownExtend(this.h) +} + +func (this *ScintillaEdit) LineUp() { + C.ScintillaEdit_LineUp(this.h) +} + +func (this *ScintillaEdit) LineUpExtend() { + C.ScintillaEdit_LineUpExtend(this.h) +} + +func (this *ScintillaEdit) CharLeft() { + C.ScintillaEdit_CharLeft(this.h) +} + +func (this *ScintillaEdit) CharLeftExtend() { + C.ScintillaEdit_CharLeftExtend(this.h) +} + +func (this *ScintillaEdit) CharRight() { + C.ScintillaEdit_CharRight(this.h) +} + +func (this *ScintillaEdit) CharRightExtend() { + C.ScintillaEdit_CharRightExtend(this.h) +} + +func (this *ScintillaEdit) WordLeft() { + C.ScintillaEdit_WordLeft(this.h) +} + +func (this *ScintillaEdit) WordLeftExtend() { + C.ScintillaEdit_WordLeftExtend(this.h) +} + +func (this *ScintillaEdit) WordRight() { + C.ScintillaEdit_WordRight(this.h) +} + +func (this *ScintillaEdit) WordRightExtend() { + C.ScintillaEdit_WordRightExtend(this.h) +} + +func (this *ScintillaEdit) Home() { + C.ScintillaEdit_Home(this.h) +} + +func (this *ScintillaEdit) HomeExtend() { + C.ScintillaEdit_HomeExtend(this.h) +} + +func (this *ScintillaEdit) LineEnd() { + C.ScintillaEdit_LineEnd(this.h) +} + +func (this *ScintillaEdit) LineEndExtend() { + C.ScintillaEdit_LineEndExtend(this.h) +} + +func (this *ScintillaEdit) DocumentStart() { + C.ScintillaEdit_DocumentStart(this.h) +} + +func (this *ScintillaEdit) DocumentStartExtend() { + C.ScintillaEdit_DocumentStartExtend(this.h) +} + +func (this *ScintillaEdit) DocumentEnd() { + C.ScintillaEdit_DocumentEnd(this.h) +} + +func (this *ScintillaEdit) DocumentEndExtend() { + C.ScintillaEdit_DocumentEndExtend(this.h) +} + +func (this *ScintillaEdit) PageUp() { + C.ScintillaEdit_PageUp(this.h) +} + +func (this *ScintillaEdit) PageUpExtend() { + C.ScintillaEdit_PageUpExtend(this.h) +} + +func (this *ScintillaEdit) PageDown() { + C.ScintillaEdit_PageDown(this.h) +} + +func (this *ScintillaEdit) PageDownExtend() { + C.ScintillaEdit_PageDownExtend(this.h) +} + +func (this *ScintillaEdit) EditToggleOvertype() { + C.ScintillaEdit_EditToggleOvertype(this.h) +} + +func (this *ScintillaEdit) Cancel() { + C.ScintillaEdit_Cancel(this.h) +} + +func (this *ScintillaEdit) DeleteBack() { + C.ScintillaEdit_DeleteBack(this.h) +} + +func (this *ScintillaEdit) Tab() { + C.ScintillaEdit_Tab(this.h) +} + +func (this *ScintillaEdit) LineIndent() { + C.ScintillaEdit_LineIndent(this.h) +} + +func (this *ScintillaEdit) BackTab() { + C.ScintillaEdit_BackTab(this.h) +} + +func (this *ScintillaEdit) LineDedent() { + C.ScintillaEdit_LineDedent(this.h) +} + +func (this *ScintillaEdit) NewLine() { + C.ScintillaEdit_NewLine(this.h) +} + +func (this *ScintillaEdit) FormFeed() { + C.ScintillaEdit_FormFeed(this.h) +} + +func (this *ScintillaEdit) VCHome() { + C.ScintillaEdit_VCHome(this.h) +} + +func (this *ScintillaEdit) VCHomeExtend() { + C.ScintillaEdit_VCHomeExtend(this.h) +} + +func (this *ScintillaEdit) ZoomIn() { + C.ScintillaEdit_ZoomIn(this.h) +} + +func (this *ScintillaEdit) ZoomOut() { + C.ScintillaEdit_ZoomOut(this.h) +} + +func (this *ScintillaEdit) DelWordLeft() { + C.ScintillaEdit_DelWordLeft(this.h) +} + +func (this *ScintillaEdit) DelWordRight() { + C.ScintillaEdit_DelWordRight(this.h) +} + +func (this *ScintillaEdit) DelWordRightEnd() { + C.ScintillaEdit_DelWordRightEnd(this.h) +} + +func (this *ScintillaEdit) LineCut() { + C.ScintillaEdit_LineCut(this.h) +} + +func (this *ScintillaEdit) LineDelete() { + C.ScintillaEdit_LineDelete(this.h) +} + +func (this *ScintillaEdit) LineTranspose() { + C.ScintillaEdit_LineTranspose(this.h) +} + +func (this *ScintillaEdit) LineReverse() { + C.ScintillaEdit_LineReverse(this.h) +} + +func (this *ScintillaEdit) LineDuplicate() { + C.ScintillaEdit_LineDuplicate(this.h) +} + +func (this *ScintillaEdit) LowerCase() { + C.ScintillaEdit_LowerCase(this.h) +} + +func (this *ScintillaEdit) UpperCase() { + C.ScintillaEdit_UpperCase(this.h) +} + +func (this *ScintillaEdit) LineScrollDown() { + C.ScintillaEdit_LineScrollDown(this.h) +} + +func (this *ScintillaEdit) LineScrollUp() { + C.ScintillaEdit_LineScrollUp(this.h) +} + +func (this *ScintillaEdit) DeleteBackNotLine() { + C.ScintillaEdit_DeleteBackNotLine(this.h) +} + +func (this *ScintillaEdit) HomeDisplay() { + C.ScintillaEdit_HomeDisplay(this.h) +} + +func (this *ScintillaEdit) HomeDisplayExtend() { + C.ScintillaEdit_HomeDisplayExtend(this.h) +} + +func (this *ScintillaEdit) LineEndDisplay() { + C.ScintillaEdit_LineEndDisplay(this.h) +} + +func (this *ScintillaEdit) LineEndDisplayExtend() { + C.ScintillaEdit_LineEndDisplayExtend(this.h) +} + +func (this *ScintillaEdit) HomeWrap() { + C.ScintillaEdit_HomeWrap(this.h) +} + +func (this *ScintillaEdit) HomeWrapExtend() { + C.ScintillaEdit_HomeWrapExtend(this.h) +} + +func (this *ScintillaEdit) LineEndWrap() { + C.ScintillaEdit_LineEndWrap(this.h) +} + +func (this *ScintillaEdit) LineEndWrapExtend() { + C.ScintillaEdit_LineEndWrapExtend(this.h) +} + +func (this *ScintillaEdit) VCHomeWrap() { + C.ScintillaEdit_VCHomeWrap(this.h) +} + +func (this *ScintillaEdit) VCHomeWrapExtend() { + C.ScintillaEdit_VCHomeWrapExtend(this.h) +} + +func (this *ScintillaEdit) LineCopy() { + C.ScintillaEdit_LineCopy(this.h) +} + +func (this *ScintillaEdit) MoveCaretInsideView() { + C.ScintillaEdit_MoveCaretInsideView(this.h) +} + +func (this *ScintillaEdit) LineLength(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_LineLength(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) BraceHighlight(posA uintptr, posB uintptr) { + C.ScintillaEdit_BraceHighlight(this.h, (C.intptr_t)(posA), (C.intptr_t)(posB)) +} + +func (this *ScintillaEdit) BraceHighlightIndicator(useSetting bool, indicator uintptr) { + C.ScintillaEdit_BraceHighlightIndicator(this.h, (C.bool)(useSetting), (C.intptr_t)(indicator)) +} + +func (this *ScintillaEdit) BraceBadLight(pos uintptr) { + C.ScintillaEdit_BraceBadLight(this.h, (C.intptr_t)(pos)) +} + +func (this *ScintillaEdit) BraceBadLightIndicator(useSetting bool, indicator uintptr) { + C.ScintillaEdit_BraceBadLightIndicator(this.h, (C.bool)(useSetting), (C.intptr_t)(indicator)) +} + +func (this *ScintillaEdit) BraceMatch(pos uintptr, maxReStyle uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_BraceMatch(this.h, (C.intptr_t)(pos), (C.intptr_t)(maxReStyle))) +} + +func (this *ScintillaEdit) BraceMatchNext(pos uintptr, startPos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_BraceMatchNext(this.h, (C.intptr_t)(pos), (C.intptr_t)(startPos))) +} + +func (this *ScintillaEdit) ViewEOL() bool { + return (bool)(C.ScintillaEdit_ViewEOL(this.h)) +} + +func (this *ScintillaEdit) SetViewEOL(visible bool) { + C.ScintillaEdit_SetViewEOL(this.h, (C.bool)(visible)) +} + +func (this *ScintillaEdit) DocPointer() uintptr { + return (uintptr)(C.ScintillaEdit_DocPointer(this.h)) +} + +func (this *ScintillaEdit) SetDocPointer(doc uintptr) { + C.ScintillaEdit_SetDocPointer(this.h, (C.intptr_t)(doc)) +} + +func (this *ScintillaEdit) SetModEventMask(eventMask uintptr) { + C.ScintillaEdit_SetModEventMask(this.h, (C.intptr_t)(eventMask)) +} + +func (this *ScintillaEdit) EdgeColumn() uintptr { + return (uintptr)(C.ScintillaEdit_EdgeColumn(this.h)) +} + +func (this *ScintillaEdit) SetEdgeColumn(column uintptr) { + C.ScintillaEdit_SetEdgeColumn(this.h, (C.intptr_t)(column)) +} + +func (this *ScintillaEdit) EdgeMode() uintptr { + return (uintptr)(C.ScintillaEdit_EdgeMode(this.h)) +} + +func (this *ScintillaEdit) SetEdgeMode(edgeMode uintptr) { + C.ScintillaEdit_SetEdgeMode(this.h, (C.intptr_t)(edgeMode)) +} + +func (this *ScintillaEdit) EdgeColour() uintptr { + return (uintptr)(C.ScintillaEdit_EdgeColour(this.h)) +} + +func (this *ScintillaEdit) SetEdgeColour(edgeColour uintptr) { + C.ScintillaEdit_SetEdgeColour(this.h, (C.intptr_t)(edgeColour)) +} + +func (this *ScintillaEdit) MultiEdgeAddLine(column uintptr, edgeColour uintptr) { + C.ScintillaEdit_MultiEdgeAddLine(this.h, (C.intptr_t)(column), (C.intptr_t)(edgeColour)) +} + +func (this *ScintillaEdit) MultiEdgeClearAll() { + C.ScintillaEdit_MultiEdgeClearAll(this.h) +} + +func (this *ScintillaEdit) MultiEdgeColumn(which uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MultiEdgeColumn(this.h, (C.intptr_t)(which))) +} + +func (this *ScintillaEdit) SearchAnchor() { + C.ScintillaEdit_SearchAnchor(this.h) +} + +func (this *ScintillaEdit) SearchNext(searchFlags uintptr, text string) uintptr { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + return (uintptr)(C.ScintillaEdit_SearchNext(this.h, (C.intptr_t)(searchFlags), text_Cstring)) +} + +func (this *ScintillaEdit) SearchPrev(searchFlags uintptr, text string) uintptr { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + return (uintptr)(C.ScintillaEdit_SearchPrev(this.h, (C.intptr_t)(searchFlags), text_Cstring)) +} + +func (this *ScintillaEdit) LinesOnScreen() uintptr { + return (uintptr)(C.ScintillaEdit_LinesOnScreen(this.h)) +} + +func (this *ScintillaEdit) UsePopUp(popUpMode uintptr) { + C.ScintillaEdit_UsePopUp(this.h, (C.intptr_t)(popUpMode)) +} + +func (this *ScintillaEdit) SelectionIsRectangle() bool { + return (bool)(C.ScintillaEdit_SelectionIsRectangle(this.h)) +} + +func (this *ScintillaEdit) SetZoom(zoomInPoints uintptr) { + C.ScintillaEdit_SetZoom(this.h, (C.intptr_t)(zoomInPoints)) +} + +func (this *ScintillaEdit) Zoom() uintptr { + return (uintptr)(C.ScintillaEdit_Zoom(this.h)) +} + +func (this *ScintillaEdit) CreateDocument(bytes uintptr, documentOptions uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_CreateDocument(this.h, (C.intptr_t)(bytes), (C.intptr_t)(documentOptions))) +} + +func (this *ScintillaEdit) AddRefDocument(doc uintptr) { + C.ScintillaEdit_AddRefDocument(this.h, (C.intptr_t)(doc)) +} + +func (this *ScintillaEdit) ReleaseDocument(doc uintptr) { + C.ScintillaEdit_ReleaseDocument(this.h, (C.intptr_t)(doc)) +} + +func (this *ScintillaEdit) DocumentOptions() uintptr { + return (uintptr)(C.ScintillaEdit_DocumentOptions(this.h)) +} + +func (this *ScintillaEdit) ModEventMask() uintptr { + return (uintptr)(C.ScintillaEdit_ModEventMask(this.h)) +} + +func (this *ScintillaEdit) SetCommandEvents(commandEvents bool) { + C.ScintillaEdit_SetCommandEvents(this.h, (C.bool)(commandEvents)) +} + +func (this *ScintillaEdit) CommandEvents() bool { + return (bool)(C.ScintillaEdit_CommandEvents(this.h)) +} + +func (this *ScintillaEdit) SetFocus(focus bool) { + C.ScintillaEdit_SetFocus(this.h, (C.bool)(focus)) +} + +func (this *ScintillaEdit) Focus() bool { + return (bool)(C.ScintillaEdit_Focus(this.h)) +} + +func (this *ScintillaEdit) SetStatus(status uintptr) { + C.ScintillaEdit_SetStatus(this.h, (C.intptr_t)(status)) +} + +func (this *ScintillaEdit) Status() uintptr { + return (uintptr)(C.ScintillaEdit_Status(this.h)) +} + +func (this *ScintillaEdit) SetMouseDownCaptures(captures bool) { + C.ScintillaEdit_SetMouseDownCaptures(this.h, (C.bool)(captures)) +} + +func (this *ScintillaEdit) MouseDownCaptures() bool { + return (bool)(C.ScintillaEdit_MouseDownCaptures(this.h)) +} + +func (this *ScintillaEdit) SetMouseWheelCaptures(captures bool) { + C.ScintillaEdit_SetMouseWheelCaptures(this.h, (C.bool)(captures)) +} + +func (this *ScintillaEdit) MouseWheelCaptures() bool { + return (bool)(C.ScintillaEdit_MouseWheelCaptures(this.h)) +} + +func (this *ScintillaEdit) SetCursor(cursorType uintptr) { + C.ScintillaEdit_SetCursor(this.h, (C.intptr_t)(cursorType)) +} + +func (this *ScintillaEdit) Cursor() uintptr { + return (uintptr)(C.ScintillaEdit_Cursor(this.h)) +} + +func (this *ScintillaEdit) SetControlCharSymbol(symbol uintptr) { + C.ScintillaEdit_SetControlCharSymbol(this.h, (C.intptr_t)(symbol)) +} + +func (this *ScintillaEdit) ControlCharSymbol() uintptr { + return (uintptr)(C.ScintillaEdit_ControlCharSymbol(this.h)) +} + +func (this *ScintillaEdit) WordPartLeft() { + C.ScintillaEdit_WordPartLeft(this.h) +} + +func (this *ScintillaEdit) WordPartLeftExtend() { + C.ScintillaEdit_WordPartLeftExtend(this.h) +} + +func (this *ScintillaEdit) WordPartRight() { + C.ScintillaEdit_WordPartRight(this.h) +} + +func (this *ScintillaEdit) WordPartRightExtend() { + C.ScintillaEdit_WordPartRightExtend(this.h) +} + +func (this *ScintillaEdit) SetVisiblePolicy(visiblePolicy uintptr, visibleSlop uintptr) { + C.ScintillaEdit_SetVisiblePolicy(this.h, (C.intptr_t)(visiblePolicy), (C.intptr_t)(visibleSlop)) +} + +func (this *ScintillaEdit) DelLineLeft() { + C.ScintillaEdit_DelLineLeft(this.h) +} + +func (this *ScintillaEdit) DelLineRight() { + C.ScintillaEdit_DelLineRight(this.h) +} + +func (this *ScintillaEdit) SetXOffset(xOffset uintptr) { + C.ScintillaEdit_SetXOffset(this.h, (C.intptr_t)(xOffset)) +} + +func (this *ScintillaEdit) XOffset() uintptr { + return (uintptr)(C.ScintillaEdit_XOffset(this.h)) +} + +func (this *ScintillaEdit) ChooseCaretX() { + C.ScintillaEdit_ChooseCaretX(this.h) +} + +func (this *ScintillaEdit) GrabFocus() { + C.ScintillaEdit_GrabFocus(this.h) +} + +func (this *ScintillaEdit) SetXCaretPolicy(caretPolicy uintptr, caretSlop uintptr) { + C.ScintillaEdit_SetXCaretPolicy(this.h, (C.intptr_t)(caretPolicy), (C.intptr_t)(caretSlop)) +} + +func (this *ScintillaEdit) SetYCaretPolicy(caretPolicy uintptr, caretSlop uintptr) { + C.ScintillaEdit_SetYCaretPolicy(this.h, (C.intptr_t)(caretPolicy), (C.intptr_t)(caretSlop)) +} + +func (this *ScintillaEdit) SetPrintWrapMode(wrapMode uintptr) { + C.ScintillaEdit_SetPrintWrapMode(this.h, (C.intptr_t)(wrapMode)) +} + +func (this *ScintillaEdit) PrintWrapMode() uintptr { + return (uintptr)(C.ScintillaEdit_PrintWrapMode(this.h)) +} + +func (this *ScintillaEdit) SetHotspotActiveFore(useSetting bool, fore uintptr) { + C.ScintillaEdit_SetHotspotActiveFore(this.h, (C.bool)(useSetting), (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) HotspotActiveFore() uintptr { + return (uintptr)(C.ScintillaEdit_HotspotActiveFore(this.h)) +} + +func (this *ScintillaEdit) SetHotspotActiveBack(useSetting bool, back uintptr) { + C.ScintillaEdit_SetHotspotActiveBack(this.h, (C.bool)(useSetting), (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) HotspotActiveBack() uintptr { + return (uintptr)(C.ScintillaEdit_HotspotActiveBack(this.h)) +} + +func (this *ScintillaEdit) SetHotspotActiveUnderline(underline bool) { + C.ScintillaEdit_SetHotspotActiveUnderline(this.h, (C.bool)(underline)) +} + +func (this *ScintillaEdit) HotspotActiveUnderline() bool { + return (bool)(C.ScintillaEdit_HotspotActiveUnderline(this.h)) +} + +func (this *ScintillaEdit) SetHotspotSingleLine(singleLine bool) { + C.ScintillaEdit_SetHotspotSingleLine(this.h, (C.bool)(singleLine)) +} + +func (this *ScintillaEdit) HotspotSingleLine() bool { + return (bool)(C.ScintillaEdit_HotspotSingleLine(this.h)) +} + +func (this *ScintillaEdit) ParaDown() { + C.ScintillaEdit_ParaDown(this.h) +} + +func (this *ScintillaEdit) ParaDownExtend() { + C.ScintillaEdit_ParaDownExtend(this.h) +} + +func (this *ScintillaEdit) ParaUp() { + C.ScintillaEdit_ParaUp(this.h) +} + +func (this *ScintillaEdit) ParaUpExtend() { + C.ScintillaEdit_ParaUpExtend(this.h) +} + +func (this *ScintillaEdit) PositionBefore(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PositionBefore(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) PositionAfter(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PositionAfter(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) PositionRelative(pos uintptr, relative uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PositionRelative(this.h, (C.intptr_t)(pos), (C.intptr_t)(relative))) +} + +func (this *ScintillaEdit) PositionRelativeCodeUnits(pos uintptr, relative uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PositionRelativeCodeUnits(this.h, (C.intptr_t)(pos), (C.intptr_t)(relative))) +} + +func (this *ScintillaEdit) CopyRange(start uintptr, end uintptr) { + C.ScintillaEdit_CopyRange(this.h, (C.intptr_t)(start), (C.intptr_t)(end)) +} + +func (this *ScintillaEdit) CopyText(length uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_CopyText(this.h, (C.intptr_t)(length), text_Cstring) +} + +func (this *ScintillaEdit) SetSelectionMode(selectionMode uintptr) { + C.ScintillaEdit_SetSelectionMode(this.h, (C.intptr_t)(selectionMode)) +} + +func (this *ScintillaEdit) ChangeSelectionMode(selectionMode uintptr) { + C.ScintillaEdit_ChangeSelectionMode(this.h, (C.intptr_t)(selectionMode)) +} + +func (this *ScintillaEdit) SelectionMode() uintptr { + return (uintptr)(C.ScintillaEdit_SelectionMode(this.h)) +} + +func (this *ScintillaEdit) SetMoveExtendsSelection(moveExtendsSelection bool) { + C.ScintillaEdit_SetMoveExtendsSelection(this.h, (C.bool)(moveExtendsSelection)) +} + +func (this *ScintillaEdit) MoveExtendsSelection() bool { + return (bool)(C.ScintillaEdit_MoveExtendsSelection(this.h)) +} + +func (this *ScintillaEdit) GetLineSelStartPosition(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_GetLineSelStartPosition(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) GetLineSelEndPosition(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_GetLineSelEndPosition(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) LineDownRectExtend() { + C.ScintillaEdit_LineDownRectExtend(this.h) +} + +func (this *ScintillaEdit) LineUpRectExtend() { + C.ScintillaEdit_LineUpRectExtend(this.h) +} + +func (this *ScintillaEdit) CharLeftRectExtend() { + C.ScintillaEdit_CharLeftRectExtend(this.h) +} + +func (this *ScintillaEdit) CharRightRectExtend() { + C.ScintillaEdit_CharRightRectExtend(this.h) +} + +func (this *ScintillaEdit) HomeRectExtend() { + C.ScintillaEdit_HomeRectExtend(this.h) +} + +func (this *ScintillaEdit) VCHomeRectExtend() { + C.ScintillaEdit_VCHomeRectExtend(this.h) +} + +func (this *ScintillaEdit) LineEndRectExtend() { + C.ScintillaEdit_LineEndRectExtend(this.h) +} + +func (this *ScintillaEdit) PageUpRectExtend() { + C.ScintillaEdit_PageUpRectExtend(this.h) +} + +func (this *ScintillaEdit) PageDownRectExtend() { + C.ScintillaEdit_PageDownRectExtend(this.h) +} + +func (this *ScintillaEdit) StutteredPageUp() { + C.ScintillaEdit_StutteredPageUp(this.h) +} + +func (this *ScintillaEdit) StutteredPageUpExtend() { + C.ScintillaEdit_StutteredPageUpExtend(this.h) +} + +func (this *ScintillaEdit) StutteredPageDown() { + C.ScintillaEdit_StutteredPageDown(this.h) +} + +func (this *ScintillaEdit) StutteredPageDownExtend() { + C.ScintillaEdit_StutteredPageDownExtend(this.h) +} + +func (this *ScintillaEdit) WordLeftEnd() { + C.ScintillaEdit_WordLeftEnd(this.h) +} + +func (this *ScintillaEdit) WordLeftEndExtend() { + C.ScintillaEdit_WordLeftEndExtend(this.h) +} + +func (this *ScintillaEdit) WordRightEnd() { + C.ScintillaEdit_WordRightEnd(this.h) +} + +func (this *ScintillaEdit) WordRightEndExtend() { + C.ScintillaEdit_WordRightEndExtend(this.h) +} + +func (this *ScintillaEdit) SetWhitespaceChars(characters string) { + characters_Cstring := C.CString(characters) + defer C.free(unsafe.Pointer(characters_Cstring)) + C.ScintillaEdit_SetWhitespaceChars(this.h, characters_Cstring) +} + +func (this *ScintillaEdit) WhitespaceChars() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_WhitespaceChars(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) SetPunctuationChars(characters string) { + characters_Cstring := C.CString(characters) + defer C.free(unsafe.Pointer(characters_Cstring)) + C.ScintillaEdit_SetPunctuationChars(this.h, characters_Cstring) +} + +func (this *ScintillaEdit) PunctuationChars() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_PunctuationChars(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) SetCharsDefault() { + C.ScintillaEdit_SetCharsDefault(this.h) +} + +func (this *ScintillaEdit) AutoCCurrent() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCCurrent(this.h)) +} + +func (this *ScintillaEdit) AutoCCurrentText() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_AutoCCurrentText(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) AutoCSetCaseInsensitiveBehaviour(behaviour uintptr) { + C.ScintillaEdit_AutoCSetCaseInsensitiveBehaviour(this.h, (C.intptr_t)(behaviour)) +} + +func (this *ScintillaEdit) AutoCCaseInsensitiveBehaviour() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCCaseInsensitiveBehaviour(this.h)) +} + +func (this *ScintillaEdit) AutoCSetMulti(multi uintptr) { + C.ScintillaEdit_AutoCSetMulti(this.h, (C.intptr_t)(multi)) +} + +func (this *ScintillaEdit) AutoCMulti() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCMulti(this.h)) +} + +func (this *ScintillaEdit) AutoCSetOrder(order uintptr) { + C.ScintillaEdit_AutoCSetOrder(this.h, (C.intptr_t)(order)) +} + +func (this *ScintillaEdit) AutoCOrder() uintptr { + return (uintptr)(C.ScintillaEdit_AutoCOrder(this.h)) +} + +func (this *ScintillaEdit) Allocate(bytes uintptr) { + C.ScintillaEdit_Allocate(this.h, (C.intptr_t)(bytes)) +} + +func (this *ScintillaEdit) TargetAsUTF8() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_TargetAsUTF8(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) SetLengthForEncode(bytes uintptr) { + C.ScintillaEdit_SetLengthForEncode(this.h, (C.intptr_t)(bytes)) +} + +func (this *ScintillaEdit) EncodedFromUTF8(utf8 string) []byte { + utf8_Cstring := C.CString(utf8) + defer C.free(unsafe.Pointer(utf8_Cstring)) + var _bytearray C.struct_miqt_string = C.ScintillaEdit_EncodedFromUTF8(this.h, utf8_Cstring) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) FindColumn(line uintptr, column uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_FindColumn(this.h, (C.intptr_t)(line), (C.intptr_t)(column))) +} + +func (this *ScintillaEdit) CaretSticky() uintptr { + return (uintptr)(C.ScintillaEdit_CaretSticky(this.h)) +} + +func (this *ScintillaEdit) SetCaretSticky(useCaretStickyBehaviour uintptr) { + C.ScintillaEdit_SetCaretSticky(this.h, (C.intptr_t)(useCaretStickyBehaviour)) +} + +func (this *ScintillaEdit) ToggleCaretSticky() { + C.ScintillaEdit_ToggleCaretSticky(this.h) +} + +func (this *ScintillaEdit) SetPasteConvertEndings(convert bool) { + C.ScintillaEdit_SetPasteConvertEndings(this.h, (C.bool)(convert)) +} + +func (this *ScintillaEdit) PasteConvertEndings() bool { + return (bool)(C.ScintillaEdit_PasteConvertEndings(this.h)) +} + +func (this *ScintillaEdit) ReplaceRectangular(length uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_ReplaceRectangular(this.h, (C.intptr_t)(length), text_Cstring) +} + +func (this *ScintillaEdit) SelectionDuplicate() { + C.ScintillaEdit_SelectionDuplicate(this.h) +} + +func (this *ScintillaEdit) SetCaretLineBackAlpha(alpha uintptr) { + C.ScintillaEdit_SetCaretLineBackAlpha(this.h, (C.intptr_t)(alpha)) +} + +func (this *ScintillaEdit) CaretLineBackAlpha() uintptr { + return (uintptr)(C.ScintillaEdit_CaretLineBackAlpha(this.h)) +} + +func (this *ScintillaEdit) SetCaretStyle(caretStyle uintptr) { + C.ScintillaEdit_SetCaretStyle(this.h, (C.intptr_t)(caretStyle)) +} + +func (this *ScintillaEdit) CaretStyle() uintptr { + return (uintptr)(C.ScintillaEdit_CaretStyle(this.h)) +} + +func (this *ScintillaEdit) SetIndicatorCurrent(indicator uintptr) { + C.ScintillaEdit_SetIndicatorCurrent(this.h, (C.intptr_t)(indicator)) +} + +func (this *ScintillaEdit) IndicatorCurrent() uintptr { + return (uintptr)(C.ScintillaEdit_IndicatorCurrent(this.h)) +} + +func (this *ScintillaEdit) SetIndicatorValue(value uintptr) { + C.ScintillaEdit_SetIndicatorValue(this.h, (C.intptr_t)(value)) +} + +func (this *ScintillaEdit) IndicatorValue() uintptr { + return (uintptr)(C.ScintillaEdit_IndicatorValue(this.h)) +} + +func (this *ScintillaEdit) IndicatorFillRange(start uintptr, lengthFill uintptr) { + C.ScintillaEdit_IndicatorFillRange(this.h, (C.intptr_t)(start), (C.intptr_t)(lengthFill)) +} + +func (this *ScintillaEdit) IndicatorClearRange(start uintptr, lengthClear uintptr) { + C.ScintillaEdit_IndicatorClearRange(this.h, (C.intptr_t)(start), (C.intptr_t)(lengthClear)) +} + +func (this *ScintillaEdit) IndicatorAllOnFor(pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicatorAllOnFor(this.h, (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) IndicatorValueAt(indicator uintptr, pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicatorValueAt(this.h, (C.intptr_t)(indicator), (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) IndicatorStart(indicator uintptr, pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicatorStart(this.h, (C.intptr_t)(indicator), (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) IndicatorEnd(indicator uintptr, pos uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicatorEnd(this.h, (C.intptr_t)(indicator), (C.intptr_t)(pos))) +} + +func (this *ScintillaEdit) SetPositionCache(size uintptr) { + C.ScintillaEdit_SetPositionCache(this.h, (C.intptr_t)(size)) +} + +func (this *ScintillaEdit) PositionCache() uintptr { + return (uintptr)(C.ScintillaEdit_PositionCache(this.h)) +} + +func (this *ScintillaEdit) SetLayoutThreads(threads uintptr) { + C.ScintillaEdit_SetLayoutThreads(this.h, (C.intptr_t)(threads)) +} + +func (this *ScintillaEdit) LayoutThreads() uintptr { + return (uintptr)(C.ScintillaEdit_LayoutThreads(this.h)) +} + +func (this *ScintillaEdit) CopyAllowLine() { + C.ScintillaEdit_CopyAllowLine(this.h) +} + +func (this *ScintillaEdit) CutAllowLine() { + C.ScintillaEdit_CutAllowLine(this.h) +} + +func (this *ScintillaEdit) SetCopySeparator(separator string) { + separator_Cstring := C.CString(separator) + defer C.free(unsafe.Pointer(separator_Cstring)) + C.ScintillaEdit_SetCopySeparator(this.h, separator_Cstring) +} + +func (this *ScintillaEdit) CopySeparator() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_CopySeparator(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) CharacterPointer() uintptr { + return (uintptr)(C.ScintillaEdit_CharacterPointer(this.h)) +} + +func (this *ScintillaEdit) RangePointer(start uintptr, lengthRange uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_RangePointer(this.h, (C.intptr_t)(start), (C.intptr_t)(lengthRange))) +} + +func (this *ScintillaEdit) GapPosition() uintptr { + return (uintptr)(C.ScintillaEdit_GapPosition(this.h)) +} + +func (this *ScintillaEdit) IndicSetAlpha(indicator uintptr, alpha uintptr) { + C.ScintillaEdit_IndicSetAlpha(this.h, (C.intptr_t)(indicator), (C.intptr_t)(alpha)) +} + +func (this *ScintillaEdit) IndicAlpha(indicator uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicAlpha(this.h, (C.intptr_t)(indicator))) +} + +func (this *ScintillaEdit) IndicSetOutlineAlpha(indicator uintptr, alpha uintptr) { + C.ScintillaEdit_IndicSetOutlineAlpha(this.h, (C.intptr_t)(indicator), (C.intptr_t)(alpha)) +} + +func (this *ScintillaEdit) IndicOutlineAlpha(indicator uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndicOutlineAlpha(this.h, (C.intptr_t)(indicator))) +} + +func (this *ScintillaEdit) SetExtraAscent(extraAscent uintptr) { + C.ScintillaEdit_SetExtraAscent(this.h, (C.intptr_t)(extraAscent)) +} + +func (this *ScintillaEdit) ExtraAscent() uintptr { + return (uintptr)(C.ScintillaEdit_ExtraAscent(this.h)) +} + +func (this *ScintillaEdit) SetExtraDescent(extraDescent uintptr) { + C.ScintillaEdit_SetExtraDescent(this.h, (C.intptr_t)(extraDescent)) +} + +func (this *ScintillaEdit) ExtraDescent() uintptr { + return (uintptr)(C.ScintillaEdit_ExtraDescent(this.h)) +} + +func (this *ScintillaEdit) MarkerSymbolDefined(markerNumber uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarkerSymbolDefined(this.h, (C.intptr_t)(markerNumber))) +} + +func (this *ScintillaEdit) MarginSetText(line uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_MarginSetText(this.h, (C.intptr_t)(line), text_Cstring) +} + +func (this *ScintillaEdit) MarginText(line uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_MarginText(this.h, (C.intptr_t)(line)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) MarginSetStyle(line uintptr, style uintptr) { + C.ScintillaEdit_MarginSetStyle(this.h, (C.intptr_t)(line), (C.intptr_t)(style)) +} + +func (this *ScintillaEdit) MarginStyle(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_MarginStyle(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) MarginSetStyles(line uintptr, styles string) { + styles_Cstring := C.CString(styles) + defer C.free(unsafe.Pointer(styles_Cstring)) + C.ScintillaEdit_MarginSetStyles(this.h, (C.intptr_t)(line), styles_Cstring) +} + +func (this *ScintillaEdit) MarginStyles(line uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_MarginStyles(this.h, (C.intptr_t)(line)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) MarginTextClearAll() { + C.ScintillaEdit_MarginTextClearAll(this.h) +} + +func (this *ScintillaEdit) MarginSetStyleOffset(style uintptr) { + C.ScintillaEdit_MarginSetStyleOffset(this.h, (C.intptr_t)(style)) +} + +func (this *ScintillaEdit) MarginStyleOffset() uintptr { + return (uintptr)(C.ScintillaEdit_MarginStyleOffset(this.h)) +} + +func (this *ScintillaEdit) SetMarginOptions(marginOptions uintptr) { + C.ScintillaEdit_SetMarginOptions(this.h, (C.intptr_t)(marginOptions)) +} + +func (this *ScintillaEdit) MarginOptions() uintptr { + return (uintptr)(C.ScintillaEdit_MarginOptions(this.h)) +} + +func (this *ScintillaEdit) AnnotationSetText(line uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_AnnotationSetText(this.h, (C.intptr_t)(line), text_Cstring) +} + +func (this *ScintillaEdit) AnnotationText(line uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_AnnotationText(this.h, (C.intptr_t)(line)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) AnnotationSetStyle(line uintptr, style uintptr) { + C.ScintillaEdit_AnnotationSetStyle(this.h, (C.intptr_t)(line), (C.intptr_t)(style)) +} + +func (this *ScintillaEdit) AnnotationStyle(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_AnnotationStyle(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) AnnotationSetStyles(line uintptr, styles string) { + styles_Cstring := C.CString(styles) + defer C.free(unsafe.Pointer(styles_Cstring)) + C.ScintillaEdit_AnnotationSetStyles(this.h, (C.intptr_t)(line), styles_Cstring) +} + +func (this *ScintillaEdit) AnnotationStyles(line uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_AnnotationStyles(this.h, (C.intptr_t)(line)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) AnnotationLines(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_AnnotationLines(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) AnnotationClearAll() { + C.ScintillaEdit_AnnotationClearAll(this.h) +} + +func (this *ScintillaEdit) AnnotationSetVisible(visible uintptr) { + C.ScintillaEdit_AnnotationSetVisible(this.h, (C.intptr_t)(visible)) +} + +func (this *ScintillaEdit) AnnotationVisible() uintptr { + return (uintptr)(C.ScintillaEdit_AnnotationVisible(this.h)) +} + +func (this *ScintillaEdit) AnnotationSetStyleOffset(style uintptr) { + C.ScintillaEdit_AnnotationSetStyleOffset(this.h, (C.intptr_t)(style)) +} + +func (this *ScintillaEdit) AnnotationStyleOffset() uintptr { + return (uintptr)(C.ScintillaEdit_AnnotationStyleOffset(this.h)) +} + +func (this *ScintillaEdit) ReleaseAllExtendedStyles() { + C.ScintillaEdit_ReleaseAllExtendedStyles(this.h) +} + +func (this *ScintillaEdit) AllocateExtendedStyles(numberStyles uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_AllocateExtendedStyles(this.h, (C.intptr_t)(numberStyles))) +} + +func (this *ScintillaEdit) AddUndoAction(token uintptr, flags uintptr) { + C.ScintillaEdit_AddUndoAction(this.h, (C.intptr_t)(token), (C.intptr_t)(flags)) +} + +func (this *ScintillaEdit) CharPositionFromPoint(x uintptr, y uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_CharPositionFromPoint(this.h, (C.intptr_t)(x), (C.intptr_t)(y))) +} + +func (this *ScintillaEdit) CharPositionFromPointClose(x uintptr, y uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_CharPositionFromPointClose(this.h, (C.intptr_t)(x), (C.intptr_t)(y))) +} + +func (this *ScintillaEdit) SetMouseSelectionRectangularSwitch(mouseSelectionRectangularSwitch bool) { + C.ScintillaEdit_SetMouseSelectionRectangularSwitch(this.h, (C.bool)(mouseSelectionRectangularSwitch)) +} + +func (this *ScintillaEdit) MouseSelectionRectangularSwitch() bool { + return (bool)(C.ScintillaEdit_MouseSelectionRectangularSwitch(this.h)) +} + +func (this *ScintillaEdit) SetMultipleSelection(multipleSelection bool) { + C.ScintillaEdit_SetMultipleSelection(this.h, (C.bool)(multipleSelection)) +} + +func (this *ScintillaEdit) MultipleSelection() bool { + return (bool)(C.ScintillaEdit_MultipleSelection(this.h)) +} + +func (this *ScintillaEdit) SetAdditionalSelectionTyping(additionalSelectionTyping bool) { + C.ScintillaEdit_SetAdditionalSelectionTyping(this.h, (C.bool)(additionalSelectionTyping)) +} + +func (this *ScintillaEdit) AdditionalSelectionTyping() bool { + return (bool)(C.ScintillaEdit_AdditionalSelectionTyping(this.h)) +} + +func (this *ScintillaEdit) SetAdditionalCaretsBlink(additionalCaretsBlink bool) { + C.ScintillaEdit_SetAdditionalCaretsBlink(this.h, (C.bool)(additionalCaretsBlink)) +} + +func (this *ScintillaEdit) AdditionalCaretsBlink() bool { + return (bool)(C.ScintillaEdit_AdditionalCaretsBlink(this.h)) +} + +func (this *ScintillaEdit) SetAdditionalCaretsVisible(additionalCaretsVisible bool) { + C.ScintillaEdit_SetAdditionalCaretsVisible(this.h, (C.bool)(additionalCaretsVisible)) +} + +func (this *ScintillaEdit) AdditionalCaretsVisible() bool { + return (bool)(C.ScintillaEdit_AdditionalCaretsVisible(this.h)) +} + +func (this *ScintillaEdit) Selections() uintptr { + return (uintptr)(C.ScintillaEdit_Selections(this.h)) +} + +func (this *ScintillaEdit) SelectionEmpty() bool { + return (bool)(C.ScintillaEdit_SelectionEmpty(this.h)) +} + +func (this *ScintillaEdit) ClearSelections() { + C.ScintillaEdit_ClearSelections(this.h) +} + +func (this *ScintillaEdit) SetSelection(caret uintptr, anchor uintptr) { + C.ScintillaEdit_SetSelection(this.h, (C.intptr_t)(caret), (C.intptr_t)(anchor)) +} + +func (this *ScintillaEdit) AddSelection(caret uintptr, anchor uintptr) { + C.ScintillaEdit_AddSelection(this.h, (C.intptr_t)(caret), (C.intptr_t)(anchor)) +} + +func (this *ScintillaEdit) SelectionFromPoint(x uintptr, y uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SelectionFromPoint(this.h, (C.intptr_t)(x), (C.intptr_t)(y))) +} + +func (this *ScintillaEdit) DropSelectionN(selection uintptr) { + C.ScintillaEdit_DropSelectionN(this.h, (C.intptr_t)(selection)) +} + +func (this *ScintillaEdit) SetMainSelection(selection uintptr) { + C.ScintillaEdit_SetMainSelection(this.h, (C.intptr_t)(selection)) +} + +func (this *ScintillaEdit) MainSelection() uintptr { + return (uintptr)(C.ScintillaEdit_MainSelection(this.h)) +} + +func (this *ScintillaEdit) SetSelectionNCaret(selection uintptr, caret uintptr) { + C.ScintillaEdit_SetSelectionNCaret(this.h, (C.intptr_t)(selection), (C.intptr_t)(caret)) +} + +func (this *ScintillaEdit) SelectionNCaret(selection uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SelectionNCaret(this.h, (C.intptr_t)(selection))) +} + +func (this *ScintillaEdit) SetSelectionNAnchor(selection uintptr, anchor uintptr) { + C.ScintillaEdit_SetSelectionNAnchor(this.h, (C.intptr_t)(selection), (C.intptr_t)(anchor)) +} + +func (this *ScintillaEdit) SelectionNAnchor(selection uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SelectionNAnchor(this.h, (C.intptr_t)(selection))) +} + +func (this *ScintillaEdit) SetSelectionNCaretVirtualSpace(selection uintptr, space uintptr) { + C.ScintillaEdit_SetSelectionNCaretVirtualSpace(this.h, (C.intptr_t)(selection), (C.intptr_t)(space)) +} + +func (this *ScintillaEdit) SelectionNCaretVirtualSpace(selection uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SelectionNCaretVirtualSpace(this.h, (C.intptr_t)(selection))) +} + +func (this *ScintillaEdit) SetSelectionNAnchorVirtualSpace(selection uintptr, space uintptr) { + C.ScintillaEdit_SetSelectionNAnchorVirtualSpace(this.h, (C.intptr_t)(selection), (C.intptr_t)(space)) +} + +func (this *ScintillaEdit) SelectionNAnchorVirtualSpace(selection uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SelectionNAnchorVirtualSpace(this.h, (C.intptr_t)(selection))) +} + +func (this *ScintillaEdit) SetSelectionNStart(selection uintptr, anchor uintptr) { + C.ScintillaEdit_SetSelectionNStart(this.h, (C.intptr_t)(selection), (C.intptr_t)(anchor)) +} + +func (this *ScintillaEdit) SelectionNStart(selection uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SelectionNStart(this.h, (C.intptr_t)(selection))) +} + +func (this *ScintillaEdit) SelectionNStartVirtualSpace(selection uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SelectionNStartVirtualSpace(this.h, (C.intptr_t)(selection))) +} + +func (this *ScintillaEdit) SetSelectionNEnd(selection uintptr, caret uintptr) { + C.ScintillaEdit_SetSelectionNEnd(this.h, (C.intptr_t)(selection), (C.intptr_t)(caret)) +} + +func (this *ScintillaEdit) SelectionNEndVirtualSpace(selection uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SelectionNEndVirtualSpace(this.h, (C.intptr_t)(selection))) +} + +func (this *ScintillaEdit) SelectionNEnd(selection uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SelectionNEnd(this.h, (C.intptr_t)(selection))) +} + +func (this *ScintillaEdit) SetRectangularSelectionCaret(caret uintptr) { + C.ScintillaEdit_SetRectangularSelectionCaret(this.h, (C.intptr_t)(caret)) +} + +func (this *ScintillaEdit) RectangularSelectionCaret() uintptr { + return (uintptr)(C.ScintillaEdit_RectangularSelectionCaret(this.h)) +} + +func (this *ScintillaEdit) SetRectangularSelectionAnchor(anchor uintptr) { + C.ScintillaEdit_SetRectangularSelectionAnchor(this.h, (C.intptr_t)(anchor)) +} + +func (this *ScintillaEdit) RectangularSelectionAnchor() uintptr { + return (uintptr)(C.ScintillaEdit_RectangularSelectionAnchor(this.h)) +} + +func (this *ScintillaEdit) SetRectangularSelectionCaretVirtualSpace(space uintptr) { + C.ScintillaEdit_SetRectangularSelectionCaretVirtualSpace(this.h, (C.intptr_t)(space)) +} + +func (this *ScintillaEdit) RectangularSelectionCaretVirtualSpace() uintptr { + return (uintptr)(C.ScintillaEdit_RectangularSelectionCaretVirtualSpace(this.h)) +} + +func (this *ScintillaEdit) SetRectangularSelectionAnchorVirtualSpace(space uintptr) { + C.ScintillaEdit_SetRectangularSelectionAnchorVirtualSpace(this.h, (C.intptr_t)(space)) +} + +func (this *ScintillaEdit) RectangularSelectionAnchorVirtualSpace() uintptr { + return (uintptr)(C.ScintillaEdit_RectangularSelectionAnchorVirtualSpace(this.h)) +} + +func (this *ScintillaEdit) SetVirtualSpaceOptions(virtualSpaceOptions uintptr) { + C.ScintillaEdit_SetVirtualSpaceOptions(this.h, (C.intptr_t)(virtualSpaceOptions)) +} + +func (this *ScintillaEdit) VirtualSpaceOptions() uintptr { + return (uintptr)(C.ScintillaEdit_VirtualSpaceOptions(this.h)) +} + +func (this *ScintillaEdit) SetRectangularSelectionModifier(modifier uintptr) { + C.ScintillaEdit_SetRectangularSelectionModifier(this.h, (C.intptr_t)(modifier)) +} + +func (this *ScintillaEdit) RectangularSelectionModifier() uintptr { + return (uintptr)(C.ScintillaEdit_RectangularSelectionModifier(this.h)) +} + +func (this *ScintillaEdit) SetAdditionalSelFore(fore uintptr) { + C.ScintillaEdit_SetAdditionalSelFore(this.h, (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) SetAdditionalSelBack(back uintptr) { + C.ScintillaEdit_SetAdditionalSelBack(this.h, (C.intptr_t)(back)) +} + +func (this *ScintillaEdit) SetAdditionalSelAlpha(alpha uintptr) { + C.ScintillaEdit_SetAdditionalSelAlpha(this.h, (C.intptr_t)(alpha)) +} + +func (this *ScintillaEdit) AdditionalSelAlpha() uintptr { + return (uintptr)(C.ScintillaEdit_AdditionalSelAlpha(this.h)) +} + +func (this *ScintillaEdit) SetAdditionalCaretFore(fore uintptr) { + C.ScintillaEdit_SetAdditionalCaretFore(this.h, (C.intptr_t)(fore)) +} + +func (this *ScintillaEdit) AdditionalCaretFore() uintptr { + return (uintptr)(C.ScintillaEdit_AdditionalCaretFore(this.h)) +} + +func (this *ScintillaEdit) RotateSelection() { + C.ScintillaEdit_RotateSelection(this.h) +} + +func (this *ScintillaEdit) SwapMainAnchorCaret() { + C.ScintillaEdit_SwapMainAnchorCaret(this.h) +} + +func (this *ScintillaEdit) MultipleSelectAddNext() { + C.ScintillaEdit_MultipleSelectAddNext(this.h) +} + +func (this *ScintillaEdit) MultipleSelectAddEach() { + C.ScintillaEdit_MultipleSelectAddEach(this.h) +} + +func (this *ScintillaEdit) ChangeLexerState(start uintptr, end uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_ChangeLexerState(this.h, (C.intptr_t)(start), (C.intptr_t)(end))) +} + +func (this *ScintillaEdit) ContractedFoldNext(lineStart uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_ContractedFoldNext(this.h, (C.intptr_t)(lineStart))) +} + +func (this *ScintillaEdit) VerticalCentreCaret() { + C.ScintillaEdit_VerticalCentreCaret(this.h) +} + +func (this *ScintillaEdit) MoveSelectedLinesUp() { + C.ScintillaEdit_MoveSelectedLinesUp(this.h) +} + +func (this *ScintillaEdit) MoveSelectedLinesDown() { + C.ScintillaEdit_MoveSelectedLinesDown(this.h) +} + +func (this *ScintillaEdit) SetIdentifier(identifier uintptr) { + C.ScintillaEdit_SetIdentifier(this.h, (C.intptr_t)(identifier)) +} + +func (this *ScintillaEdit) Identifier() uintptr { + return (uintptr)(C.ScintillaEdit_Identifier(this.h)) +} + +func (this *ScintillaEdit) RGBAImageSetWidth(width uintptr) { + C.ScintillaEdit_RGBAImageSetWidth(this.h, (C.intptr_t)(width)) +} + +func (this *ScintillaEdit) RGBAImageSetHeight(height uintptr) { + C.ScintillaEdit_RGBAImageSetHeight(this.h, (C.intptr_t)(height)) +} + +func (this *ScintillaEdit) RGBAImageSetScale(scalePercent uintptr) { + C.ScintillaEdit_RGBAImageSetScale(this.h, (C.intptr_t)(scalePercent)) +} + +func (this *ScintillaEdit) MarkerDefineRGBAImage(markerNumber uintptr, pixels string) { + pixels_Cstring := C.CString(pixels) + defer C.free(unsafe.Pointer(pixels_Cstring)) + C.ScintillaEdit_MarkerDefineRGBAImage(this.h, (C.intptr_t)(markerNumber), pixels_Cstring) +} + +func (this *ScintillaEdit) RegisterRGBAImage(typeVal uintptr, pixels string) { + pixels_Cstring := C.CString(pixels) + defer C.free(unsafe.Pointer(pixels_Cstring)) + C.ScintillaEdit_RegisterRGBAImage(this.h, (C.intptr_t)(typeVal), pixels_Cstring) +} + +func (this *ScintillaEdit) ScrollToStart() { + C.ScintillaEdit_ScrollToStart(this.h) +} + +func (this *ScintillaEdit) ScrollToEnd() { + C.ScintillaEdit_ScrollToEnd(this.h) +} + +func (this *ScintillaEdit) SetTechnology(technology uintptr) { + C.ScintillaEdit_SetTechnology(this.h, (C.intptr_t)(technology)) +} + +func (this *ScintillaEdit) Technology() uintptr { + return (uintptr)(C.ScintillaEdit_Technology(this.h)) +} + +func (this *ScintillaEdit) CreateLoader(bytes uintptr, documentOptions uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_CreateLoader(this.h, (C.intptr_t)(bytes), (C.intptr_t)(documentOptions))) +} + +func (this *ScintillaEdit) FindIndicatorShow(start uintptr, end uintptr) { + C.ScintillaEdit_FindIndicatorShow(this.h, (C.intptr_t)(start), (C.intptr_t)(end)) +} + +func (this *ScintillaEdit) FindIndicatorFlash(start uintptr, end uintptr) { + C.ScintillaEdit_FindIndicatorFlash(this.h, (C.intptr_t)(start), (C.intptr_t)(end)) +} + +func (this *ScintillaEdit) FindIndicatorHide() { + C.ScintillaEdit_FindIndicatorHide(this.h) +} + +func (this *ScintillaEdit) VCHomeDisplay() { + C.ScintillaEdit_VCHomeDisplay(this.h) +} + +func (this *ScintillaEdit) VCHomeDisplayExtend() { + C.ScintillaEdit_VCHomeDisplayExtend(this.h) +} + +func (this *ScintillaEdit) CaretLineVisibleAlways() bool { + return (bool)(C.ScintillaEdit_CaretLineVisibleAlways(this.h)) +} + +func (this *ScintillaEdit) SetCaretLineVisibleAlways(alwaysVisible bool) { + C.ScintillaEdit_SetCaretLineVisibleAlways(this.h, (C.bool)(alwaysVisible)) +} + +func (this *ScintillaEdit) SetLineEndTypesAllowed(lineEndBitSet uintptr) { + C.ScintillaEdit_SetLineEndTypesAllowed(this.h, (C.intptr_t)(lineEndBitSet)) +} + +func (this *ScintillaEdit) LineEndTypesAllowed() uintptr { + return (uintptr)(C.ScintillaEdit_LineEndTypesAllowed(this.h)) +} + +func (this *ScintillaEdit) LineEndTypesActive() uintptr { + return (uintptr)(C.ScintillaEdit_LineEndTypesActive(this.h)) +} + +func (this *ScintillaEdit) SetRepresentation(encodedCharacter string, representation string) { + encodedCharacter_Cstring := C.CString(encodedCharacter) + defer C.free(unsafe.Pointer(encodedCharacter_Cstring)) + representation_Cstring := C.CString(representation) + defer C.free(unsafe.Pointer(representation_Cstring)) + C.ScintillaEdit_SetRepresentation(this.h, encodedCharacter_Cstring, representation_Cstring) +} + +func (this *ScintillaEdit) Representation(encodedCharacter string) []byte { + encodedCharacter_Cstring := C.CString(encodedCharacter) + defer C.free(unsafe.Pointer(encodedCharacter_Cstring)) + var _bytearray C.struct_miqt_string = C.ScintillaEdit_Representation(this.h, encodedCharacter_Cstring) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) ClearRepresentation(encodedCharacter string) { + encodedCharacter_Cstring := C.CString(encodedCharacter) + defer C.free(unsafe.Pointer(encodedCharacter_Cstring)) + C.ScintillaEdit_ClearRepresentation(this.h, encodedCharacter_Cstring) +} + +func (this *ScintillaEdit) ClearAllRepresentations() { + C.ScintillaEdit_ClearAllRepresentations(this.h) +} + +func (this *ScintillaEdit) SetRepresentationAppearance(encodedCharacter string, appearance uintptr) { + encodedCharacter_Cstring := C.CString(encodedCharacter) + defer C.free(unsafe.Pointer(encodedCharacter_Cstring)) + C.ScintillaEdit_SetRepresentationAppearance(this.h, encodedCharacter_Cstring, (C.intptr_t)(appearance)) +} + +func (this *ScintillaEdit) RepresentationAppearance(encodedCharacter string) uintptr { + encodedCharacter_Cstring := C.CString(encodedCharacter) + defer C.free(unsafe.Pointer(encodedCharacter_Cstring)) + return (uintptr)(C.ScintillaEdit_RepresentationAppearance(this.h, encodedCharacter_Cstring)) +} + +func (this *ScintillaEdit) SetRepresentationColour(encodedCharacter string, colour uintptr) { + encodedCharacter_Cstring := C.CString(encodedCharacter) + defer C.free(unsafe.Pointer(encodedCharacter_Cstring)) + C.ScintillaEdit_SetRepresentationColour(this.h, encodedCharacter_Cstring, (C.intptr_t)(colour)) +} + +func (this *ScintillaEdit) RepresentationColour(encodedCharacter string) uintptr { + encodedCharacter_Cstring := C.CString(encodedCharacter) + defer C.free(unsafe.Pointer(encodedCharacter_Cstring)) + return (uintptr)(C.ScintillaEdit_RepresentationColour(this.h, encodedCharacter_Cstring)) +} + +func (this *ScintillaEdit) EOLAnnotationSetText(line uintptr, text string) { + text_Cstring := C.CString(text) + defer C.free(unsafe.Pointer(text_Cstring)) + C.ScintillaEdit_EOLAnnotationSetText(this.h, (C.intptr_t)(line), text_Cstring) +} + +func (this *ScintillaEdit) EOLAnnotationText(line uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_EOLAnnotationText(this.h, (C.intptr_t)(line)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) EOLAnnotationSetStyle(line uintptr, style uintptr) { + C.ScintillaEdit_EOLAnnotationSetStyle(this.h, (C.intptr_t)(line), (C.intptr_t)(style)) +} + +func (this *ScintillaEdit) EOLAnnotationStyle(line uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_EOLAnnotationStyle(this.h, (C.intptr_t)(line))) +} + +func (this *ScintillaEdit) EOLAnnotationClearAll() { + C.ScintillaEdit_EOLAnnotationClearAll(this.h) +} + +func (this *ScintillaEdit) EOLAnnotationSetVisible(visible uintptr) { + C.ScintillaEdit_EOLAnnotationSetVisible(this.h, (C.intptr_t)(visible)) +} + +func (this *ScintillaEdit) EOLAnnotationVisible() uintptr { + return (uintptr)(C.ScintillaEdit_EOLAnnotationVisible(this.h)) +} + +func (this *ScintillaEdit) EOLAnnotationSetStyleOffset(style uintptr) { + C.ScintillaEdit_EOLAnnotationSetStyleOffset(this.h, (C.intptr_t)(style)) +} + +func (this *ScintillaEdit) EOLAnnotationStyleOffset() uintptr { + return (uintptr)(C.ScintillaEdit_EOLAnnotationStyleOffset(this.h)) +} + +func (this *ScintillaEdit) SupportsFeature(feature uintptr) bool { + return (bool)(C.ScintillaEdit_SupportsFeature(this.h, (C.intptr_t)(feature))) +} + +func (this *ScintillaEdit) LineCharacterIndex() uintptr { + return (uintptr)(C.ScintillaEdit_LineCharacterIndex(this.h)) +} + +func (this *ScintillaEdit) AllocateLineCharacterIndex(lineCharacterIndex uintptr) { + C.ScintillaEdit_AllocateLineCharacterIndex(this.h, (C.intptr_t)(lineCharacterIndex)) +} + +func (this *ScintillaEdit) ReleaseLineCharacterIndex(lineCharacterIndex uintptr) { + C.ScintillaEdit_ReleaseLineCharacterIndex(this.h, (C.intptr_t)(lineCharacterIndex)) +} + +func (this *ScintillaEdit) LineFromIndexPosition(pos uintptr, lineCharacterIndex uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_LineFromIndexPosition(this.h, (C.intptr_t)(pos), (C.intptr_t)(lineCharacterIndex))) +} + +func (this *ScintillaEdit) IndexPositionFromLine(line uintptr, lineCharacterIndex uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_IndexPositionFromLine(this.h, (C.intptr_t)(line), (C.intptr_t)(lineCharacterIndex))) +} + +func (this *ScintillaEdit) StartRecord() { + C.ScintillaEdit_StartRecord(this.h) +} + +func (this *ScintillaEdit) StopRecord() { + C.ScintillaEdit_StopRecord(this.h) +} + +func (this *ScintillaEdit) Lexer() uintptr { + return (uintptr)(C.ScintillaEdit_Lexer(this.h)) +} + +func (this *ScintillaEdit) Colourise(start uintptr, end uintptr) { + C.ScintillaEdit_Colourise(this.h, (C.intptr_t)(start), (C.intptr_t)(end)) +} + +func (this *ScintillaEdit) SetProperty(key string, value string) { + key_Cstring := C.CString(key) + defer C.free(unsafe.Pointer(key_Cstring)) + value_Cstring := C.CString(value) + defer C.free(unsafe.Pointer(value_Cstring)) + C.ScintillaEdit_SetProperty(this.h, key_Cstring, value_Cstring) +} + +func (this *ScintillaEdit) SetKeyWords(keyWordSet uintptr, keyWords string) { + keyWords_Cstring := C.CString(keyWords) + defer C.free(unsafe.Pointer(keyWords_Cstring)) + C.ScintillaEdit_SetKeyWords(this.h, (C.intptr_t)(keyWordSet), keyWords_Cstring) +} + +func (this *ScintillaEdit) Property(key string) []byte { + key_Cstring := C.CString(key) + defer C.free(unsafe.Pointer(key_Cstring)) + var _bytearray C.struct_miqt_string = C.ScintillaEdit_Property(this.h, key_Cstring) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) PropertyExpanded(key string) []byte { + key_Cstring := C.CString(key) + defer C.free(unsafe.Pointer(key_Cstring)) + var _bytearray C.struct_miqt_string = C.ScintillaEdit_PropertyExpanded(this.h, key_Cstring) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) PropertyInt(key string, defaultValue uintptr) uintptr { + key_Cstring := C.CString(key) + defer C.free(unsafe.Pointer(key_Cstring)) + return (uintptr)(C.ScintillaEdit_PropertyInt(this.h, key_Cstring, (C.intptr_t)(defaultValue))) +} + +func (this *ScintillaEdit) LexerLanguage() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_LexerLanguage(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) PrivateLexerCall(operation uintptr, pointer uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PrivateLexerCall(this.h, (C.intptr_t)(operation), (C.intptr_t)(pointer))) +} + +func (this *ScintillaEdit) PropertyNames() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_PropertyNames(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) PropertyType(name string) uintptr { + name_Cstring := C.CString(name) + defer C.free(unsafe.Pointer(name_Cstring)) + return (uintptr)(C.ScintillaEdit_PropertyType(this.h, name_Cstring)) +} + +func (this *ScintillaEdit) DescribeProperty(name string) []byte { + name_Cstring := C.CString(name) + defer C.free(unsafe.Pointer(name_Cstring)) + var _bytearray C.struct_miqt_string = C.ScintillaEdit_DescribeProperty(this.h, name_Cstring) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) DescribeKeyWordSets() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_DescribeKeyWordSets(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) LineEndTypesSupported() uintptr { + return (uintptr)(C.ScintillaEdit_LineEndTypesSupported(this.h)) +} + +func (this *ScintillaEdit) AllocateSubStyles(styleBase uintptr, numberStyles uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_AllocateSubStyles(this.h, (C.intptr_t)(styleBase), (C.intptr_t)(numberStyles))) +} + +func (this *ScintillaEdit) SubStylesStart(styleBase uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SubStylesStart(this.h, (C.intptr_t)(styleBase))) +} + +func (this *ScintillaEdit) SubStylesLength(styleBase uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_SubStylesLength(this.h, (C.intptr_t)(styleBase))) +} + +func (this *ScintillaEdit) StyleFromSubStyle(subStyle uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_StyleFromSubStyle(this.h, (C.intptr_t)(subStyle))) +} + +func (this *ScintillaEdit) PrimaryStyleFromStyle(style uintptr) uintptr { + return (uintptr)(C.ScintillaEdit_PrimaryStyleFromStyle(this.h, (C.intptr_t)(style))) +} + +func (this *ScintillaEdit) FreeSubStyles() { + C.ScintillaEdit_FreeSubStyles(this.h) +} + +func (this *ScintillaEdit) SetIdentifiers(style uintptr, identifiers string) { + identifiers_Cstring := C.CString(identifiers) + defer C.free(unsafe.Pointer(identifiers_Cstring)) + C.ScintillaEdit_SetIdentifiers(this.h, (C.intptr_t)(style), identifiers_Cstring) +} + +func (this *ScintillaEdit) DistanceToSecondaryStyles() uintptr { + return (uintptr)(C.ScintillaEdit_DistanceToSecondaryStyles(this.h)) +} + +func (this *ScintillaEdit) SubStyleBases() []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_SubStyleBases(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) NamedStyles() uintptr { + return (uintptr)(C.ScintillaEdit_NamedStyles(this.h)) +} + +func (this *ScintillaEdit) NameOfStyle(style uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_NameOfStyle(this.h, (C.intptr_t)(style)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) TagsOfStyle(style uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_TagsOfStyle(this.h, (C.intptr_t)(style)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) DescriptionOfStyle(style uintptr) []byte { + var _bytearray C.struct_miqt_string = C.ScintillaEdit_DescriptionOfStyle(this.h, (C.intptr_t)(style)) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *ScintillaEdit) SetILexer(ilexer uintptr) { + C.ScintillaEdit_SetILexer(this.h, (C.intptr_t)(ilexer)) +} + +func (this *ScintillaEdit) Bidirectional() uintptr { + return (uintptr)(C.ScintillaEdit_Bidirectional(this.h)) +} + +func (this *ScintillaEdit) SetBidirectional(bidirectional uintptr) { + C.ScintillaEdit_SetBidirectional(this.h, (C.intptr_t)(bidirectional)) +} + +func ScintillaEdit_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEdit_Tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaEdit_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEdit_Tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaEdit_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEdit_TrUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func ScintillaEdit_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.ScintillaEdit_TrUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +// Delete this object from C++ memory. +func (this *ScintillaEdit) Delete() { + C.ScintillaEdit_Delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *ScintillaEdit) GoGC() { + runtime.SetFinalizer(this, func(this *ScintillaEdit) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt-extras/scintillaedit/gen_ScintillaEdit.h b/qt-extras/scintillaedit/gen_ScintillaEdit.h new file mode 100644 index 00000000..8ffbfc68 --- /dev/null +++ b/qt-extras/scintillaedit/gen_ScintillaEdit.h @@ -0,0 +1,1492 @@ +#ifndef GEN_SCINTILLAEDIT_H +#define GEN_SCINTILLAEDIT_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QByteArray; +class QKeyEvent; +class QMetaObject; +class QMimeData; +class QMouseEvent; +class QObject; +class QPaintDevice; +class QRect; +class QWidget; +class SCNotification; +class Sci_CharacterRange; +class Sci_CharacterRangeFull; +class Sci_NotifyHeader; +class Sci_RangeToFormat; +class Sci_RangeToFormatFull; +class Sci_Rectangle; +class Sci_TextRange; +class Sci_TextRangeFull; +class Sci_TextToFind; +class Sci_TextToFindFull; +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__CharacterRange) +typedef Scintilla::CharacterRange Scintilla__CharacterRange; +#else +class Scintilla__CharacterRange; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__CharacterRangeFull) +typedef Scintilla::CharacterRangeFull Scintilla__CharacterRangeFull; +#else +class Scintilla__CharacterRangeFull; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ColourRGBA) +typedef Scintilla::Internal::ColourRGBA Scintilla__Internal__ColourRGBA; +#else +class Scintilla__Internal__ColourRGBA; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ColourStop) +typedef Scintilla::Internal::ColourStop Scintilla__Internal__ColourStop; +#else +class Scintilla__Internal__ColourStop; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Fill) +typedef Scintilla::Internal::Fill Scintilla__Internal__Fill; +#else +class Scintilla__Internal__Fill; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__FillStroke) +typedef Scintilla::Internal::FillStroke Scintilla__Internal__FillStroke; +#else +class Scintilla__Internal__FillStroke; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Font) +typedef Scintilla::Internal::Font Scintilla__Internal__Font; +#else +class Scintilla__Internal__Font; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__FontParameters) +typedef Scintilla::Internal::FontParameters Scintilla__Internal__FontParameters; +#else +class Scintilla__Internal__FontParameters; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__IListBoxDelegate) +typedef Scintilla::Internal::IListBoxDelegate Scintilla__Internal__IListBoxDelegate; +#else +class Scintilla__Internal__IListBoxDelegate; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__IScreenLine) +typedef Scintilla::Internal::IScreenLine Scintilla__Internal__IScreenLine; +#else +class Scintilla__Internal__IScreenLine; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__IScreenLineLayout) +typedef Scintilla::Internal::IScreenLineLayout Scintilla__Internal__IScreenLineLayout; +#else +class Scintilla__Internal__IScreenLineLayout; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Interval) +typedef Scintilla::Internal::Interval Scintilla__Internal__Interval; +#else +class Scintilla__Internal__Interval; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ListBox) +typedef Scintilla::Internal::ListBox Scintilla__Internal__ListBox; +#else +class Scintilla__Internal__ListBox; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ListBoxEvent) +typedef Scintilla::Internal::ListBoxEvent Scintilla__Internal__ListBoxEvent; +#else +class Scintilla__Internal__ListBoxEvent; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__ListOptions) +typedef Scintilla::Internal::ListOptions Scintilla__Internal__ListOptions; +#else +class Scintilla__Internal__ListOptions; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Menu) +typedef Scintilla::Internal::Menu Scintilla__Internal__Menu; +#else +class Scintilla__Internal__Menu; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__PRectangle) +typedef Scintilla::Internal::PRectangle Scintilla__Internal__PRectangle; +#else +class Scintilla__Internal__PRectangle; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Point) +typedef Scintilla::Internal::Point Scintilla__Internal__Point; +#else +class Scintilla__Internal__Point; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Stroke) +typedef Scintilla::Internal::Stroke Scintilla__Internal__Stroke; +#else +class Scintilla__Internal__Stroke; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Surface) +typedef Scintilla::Internal::Surface Scintilla__Internal__Surface; +#else +class Scintilla__Internal__Surface; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__SurfaceMode) +typedef Scintilla::Internal::SurfaceMode Scintilla__Internal__SurfaceMode; +#else +class Scintilla__Internal__SurfaceMode; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Internal__Window) +typedef Scintilla::Internal::Window Scintilla__Internal__Window; +#else +class Scintilla__Internal__Window; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__NotificationData) +typedef Scintilla::NotificationData Scintilla__NotificationData; +#else +class Scintilla__NotificationData; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__NotifyHeader) +typedef Scintilla::NotifyHeader Scintilla__NotifyHeader; +#else +class Scintilla__NotifyHeader; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__RangeToFormat) +typedef Scintilla::RangeToFormat Scintilla__RangeToFormat; +#else +class Scintilla__RangeToFormat; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__RangeToFormatFull) +typedef Scintilla::RangeToFormatFull Scintilla__RangeToFormatFull; +#else +class Scintilla__RangeToFormatFull; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__Rectangle) +typedef Scintilla::Rectangle Scintilla__Rectangle; +#else +class Scintilla__Rectangle; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__TextRange) +typedef Scintilla::TextRange Scintilla__TextRange; +#else +class Scintilla__TextRange; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__TextRangeFull) +typedef Scintilla::TextRangeFull Scintilla__TextRangeFull; +#else +class Scintilla__TextRangeFull; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__TextToFind) +typedef Scintilla::TextToFind Scintilla__TextToFind; +#else +class Scintilla__TextToFind; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Scintilla__TextToFindFull) +typedef Scintilla::TextToFindFull Scintilla__TextToFindFull; +#else +class Scintilla__TextToFindFull; +#endif +class ScintillaDocument; +class ScintillaEdit; +class ScintillaEditBase; +#else +typedef struct QByteArray QByteArray; +typedef struct QKeyEvent QKeyEvent; +typedef struct QMetaObject QMetaObject; +typedef struct QMimeData QMimeData; +typedef struct QMouseEvent QMouseEvent; +typedef struct QObject QObject; +typedef struct QPaintDevice QPaintDevice; +typedef struct QRect QRect; +typedef struct QWidget QWidget; +typedef struct SCNotification SCNotification; +typedef struct Sci_CharacterRange Sci_CharacterRange; +typedef struct Sci_CharacterRangeFull Sci_CharacterRangeFull; +typedef struct Sci_NotifyHeader Sci_NotifyHeader; +typedef struct Sci_RangeToFormat Sci_RangeToFormat; +typedef struct Sci_RangeToFormatFull Sci_RangeToFormatFull; +typedef struct Sci_Rectangle Sci_Rectangle; +typedef struct Sci_TextRange Sci_TextRange; +typedef struct Sci_TextRangeFull Sci_TextRangeFull; +typedef struct Sci_TextToFind Sci_TextToFind; +typedef struct Sci_TextToFindFull Sci_TextToFindFull; +typedef struct Scintilla__CharacterRange Scintilla__CharacterRange; +typedef struct Scintilla__CharacterRangeFull Scintilla__CharacterRangeFull; +typedef struct Scintilla__Internal__ColourRGBA Scintilla__Internal__ColourRGBA; +typedef struct Scintilla__Internal__ColourStop Scintilla__Internal__ColourStop; +typedef struct Scintilla__Internal__Fill Scintilla__Internal__Fill; +typedef struct Scintilla__Internal__FillStroke Scintilla__Internal__FillStroke; +typedef struct Scintilla__Internal__Font Scintilla__Internal__Font; +typedef struct Scintilla__Internal__FontParameters Scintilla__Internal__FontParameters; +typedef struct Scintilla__Internal__IListBoxDelegate Scintilla__Internal__IListBoxDelegate; +typedef struct Scintilla__Internal__IScreenLine Scintilla__Internal__IScreenLine; +typedef struct Scintilla__Internal__IScreenLineLayout Scintilla__Internal__IScreenLineLayout; +typedef struct Scintilla__Internal__Interval Scintilla__Internal__Interval; +typedef struct Scintilla__Internal__ListBox Scintilla__Internal__ListBox; +typedef struct Scintilla__Internal__ListBoxEvent Scintilla__Internal__ListBoxEvent; +typedef struct Scintilla__Internal__ListOptions Scintilla__Internal__ListOptions; +typedef struct Scintilla__Internal__Menu Scintilla__Internal__Menu; +typedef struct Scintilla__Internal__PRectangle Scintilla__Internal__PRectangle; +typedef struct Scintilla__Internal__Point Scintilla__Internal__Point; +typedef struct Scintilla__Internal__Stroke Scintilla__Internal__Stroke; +typedef struct Scintilla__Internal__Surface Scintilla__Internal__Surface; +typedef struct Scintilla__Internal__SurfaceMode Scintilla__Internal__SurfaceMode; +typedef struct Scintilla__Internal__Window Scintilla__Internal__Window; +typedef struct Scintilla__NotificationData Scintilla__NotificationData; +typedef struct Scintilla__NotifyHeader Scintilla__NotifyHeader; +typedef struct Scintilla__RangeToFormat Scintilla__RangeToFormat; +typedef struct Scintilla__RangeToFormatFull Scintilla__RangeToFormatFull; +typedef struct Scintilla__Rectangle Scintilla__Rectangle; +typedef struct Scintilla__TextRange Scintilla__TextRange; +typedef struct Scintilla__TextRangeFull Scintilla__TextRangeFull; +typedef struct Scintilla__TextToFind Scintilla__TextToFind; +typedef struct Scintilla__TextToFindFull Scintilla__TextToFindFull; +typedef struct ScintillaDocument ScintillaDocument; +typedef struct ScintillaEdit ScintillaEdit; +typedef struct ScintillaEditBase ScintillaEditBase; +#endif + +Scintilla__Internal__Point* Scintilla__Internal__Point_new(); +Scintilla__Internal__Point* Scintilla__Internal__Point_new2(Scintilla__Internal__Point* param1); +Scintilla__Internal__Point* Scintilla__Internal__Point_new3(double x_); +Scintilla__Internal__Point* Scintilla__Internal__Point_new4(double x_, double y_); +Scintilla__Internal__Point* Scintilla__Internal__Point_FromInts(int x_, int y_); +bool Scintilla__Internal__Point_OperatorEqual(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other); +bool Scintilla__Internal__Point_OperatorNotEqual(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other); +Scintilla__Internal__Point* Scintilla__Internal__Point_OperatorPlus(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other); +Scintilla__Internal__Point* Scintilla__Internal__Point_OperatorMinus(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other); +void Scintilla__Internal__Point_Delete(Scintilla__Internal__Point* self); + +bool Scintilla__Internal__Interval_OperatorEqual(const Scintilla__Internal__Interval* self, Scintilla__Internal__Interval* other); +double Scintilla__Internal__Interval_Width(const Scintilla__Internal__Interval* self); +bool Scintilla__Internal__Interval_Empty(const Scintilla__Internal__Interval* self); +bool Scintilla__Internal__Interval_Intersects(const Scintilla__Internal__Interval* self, Scintilla__Internal__Interval* other); +Scintilla__Internal__Interval* Scintilla__Internal__Interval_Offset(const Scintilla__Internal__Interval* self, double offset); +void Scintilla__Internal__Interval_Delete(Scintilla__Internal__Interval* self); + +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new(); +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new2(Scintilla__Internal__PRectangle* param1); +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new3(double left_); +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new4(double left_, double top_); +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new5(double left_, double top_, double right_); +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new6(double left_, double top_, double right_, double bottom_); +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_FromInts(int left_, int top_, int right_, int bottom_); +bool Scintilla__Internal__PRectangle_OperatorEqual(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__PRectangle* rc); +bool Scintilla__Internal__PRectangle_Contains(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Point* pt); +bool Scintilla__Internal__PRectangle_ContainsWholePixel(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Point* pt); +bool Scintilla__Internal__PRectangle_ContainsWithRc(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__PRectangle* rc); +bool Scintilla__Internal__PRectangle_Intersects(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__PRectangle* other); +bool Scintilla__Internal__PRectangle_IntersectsWithHorizontalBounds(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Interval* horizontalBounds); +void Scintilla__Internal__PRectangle_Move(Scintilla__Internal__PRectangle* self, double xDelta, double yDelta); +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_WithHorizontalBounds(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Interval* horizontal); +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_Inset(const Scintilla__Internal__PRectangle* self, double delta); +Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_InsetWithDelta(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__Point* delta); +Scintilla__Internal__Point* Scintilla__Internal__PRectangle_Centre(const Scintilla__Internal__PRectangle* self); +double Scintilla__Internal__PRectangle_Width(const Scintilla__Internal__PRectangle* self); +double Scintilla__Internal__PRectangle_Height(const Scintilla__Internal__PRectangle* self); +bool Scintilla__Internal__PRectangle_Empty(const Scintilla__Internal__PRectangle* self); +void Scintilla__Internal__PRectangle_Delete(Scintilla__Internal__PRectangle* self); + +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new(); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new2(unsigned int red, unsigned int green, unsigned int blue); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new3(Scintilla__Internal__ColourRGBA* cd, unsigned int alpha); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new4(Scintilla__Internal__ColourRGBA* param1); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new5(int co_); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new6(unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_FromRGB(int co_); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_Grey(unsigned int grey); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_FromIpRGB(intptr_t co_); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_WithoutAlpha(const Scintilla__Internal__ColourRGBA* self); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_Opaque(const Scintilla__Internal__ColourRGBA* self); +int Scintilla__Internal__ColourRGBA_AsInteger(const Scintilla__Internal__ColourRGBA* self); +int Scintilla__Internal__ColourRGBA_OpaqueRGB(const Scintilla__Internal__ColourRGBA* self); +unsigned char Scintilla__Internal__ColourRGBA_GetRed(const Scintilla__Internal__ColourRGBA* self); +unsigned char Scintilla__Internal__ColourRGBA_GetGreen(const Scintilla__Internal__ColourRGBA* self); +unsigned char Scintilla__Internal__ColourRGBA_GetBlue(const Scintilla__Internal__ColourRGBA* self); +unsigned char Scintilla__Internal__ColourRGBA_GetAlpha(const Scintilla__Internal__ColourRGBA* self); +float Scintilla__Internal__ColourRGBA_GetRedComponent(const Scintilla__Internal__ColourRGBA* self); +float Scintilla__Internal__ColourRGBA_GetGreenComponent(const Scintilla__Internal__ColourRGBA* self); +float Scintilla__Internal__ColourRGBA_GetBlueComponent(const Scintilla__Internal__ColourRGBA* self); +float Scintilla__Internal__ColourRGBA_GetAlphaComponent(const Scintilla__Internal__ColourRGBA* self); +bool Scintilla__Internal__ColourRGBA_OperatorEqual(const Scintilla__Internal__ColourRGBA* self, Scintilla__Internal__ColourRGBA* other); +bool Scintilla__Internal__ColourRGBA_IsOpaque(const Scintilla__Internal__ColourRGBA* self); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_MixedWith(const Scintilla__Internal__ColourRGBA* self, Scintilla__Internal__ColourRGBA* other); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_MixedWith2(const Scintilla__Internal__ColourRGBA* self, Scintilla__Internal__ColourRGBA* other, double proportion); +void Scintilla__Internal__ColourRGBA_OperatorAssign(Scintilla__Internal__ColourRGBA* self, Scintilla__Internal__ColourRGBA* param1); +Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_Grey2(unsigned int grey, unsigned int alpha); +void Scintilla__Internal__ColourRGBA_Delete(Scintilla__Internal__ColourRGBA* self); + +Scintilla__Internal__Stroke* Scintilla__Internal__Stroke_new(Scintilla__Internal__ColourRGBA* colour_); +Scintilla__Internal__Stroke* Scintilla__Internal__Stroke_new2(Scintilla__Internal__Stroke* param1); +Scintilla__Internal__Stroke* Scintilla__Internal__Stroke_new3(Scintilla__Internal__ColourRGBA* colour_, double width_); +float Scintilla__Internal__Stroke_WidthF(const Scintilla__Internal__Stroke* self); +void Scintilla__Internal__Stroke_Delete(Scintilla__Internal__Stroke* self); + +Scintilla__Internal__Fill* Scintilla__Internal__Fill_new(Scintilla__Internal__ColourRGBA* colour_); +Scintilla__Internal__Fill* Scintilla__Internal__Fill_new2(Scintilla__Internal__Fill* param1); +void Scintilla__Internal__Fill_Delete(Scintilla__Internal__Fill* self); + +Scintilla__Internal__FillStroke* Scintilla__Internal__FillStroke_new(Scintilla__Internal__ColourRGBA* colourFill_, Scintilla__Internal__ColourRGBA* colourStroke_); +Scintilla__Internal__FillStroke* Scintilla__Internal__FillStroke_new2(Scintilla__Internal__ColourRGBA* colourBoth); +Scintilla__Internal__FillStroke* Scintilla__Internal__FillStroke_new3(Scintilla__Internal__ColourRGBA* colourFill_, Scintilla__Internal__ColourRGBA* colourStroke_, double widthStroke_); +Scintilla__Internal__FillStroke* Scintilla__Internal__FillStroke_new4(Scintilla__Internal__ColourRGBA* colourBoth, double widthStroke_); +void Scintilla__Internal__FillStroke_Delete(Scintilla__Internal__FillStroke* self); + +Scintilla__Internal__ColourStop* Scintilla__Internal__ColourStop_new(double position_, Scintilla__Internal__ColourRGBA* colour_); +void Scintilla__Internal__ColourStop_Delete(Scintilla__Internal__ColourStop* self); + +void Scintilla__CharacterRange_Delete(Scintilla__CharacterRange* self); + +void Scintilla__CharacterRangeFull_Delete(Scintilla__CharacterRangeFull* self); + +void Scintilla__TextRange_Delete(Scintilla__TextRange* self); + +void Scintilla__TextRangeFull_Delete(Scintilla__TextRangeFull* self); + +void Scintilla__TextToFind_Delete(Scintilla__TextToFind* self); + +void Scintilla__TextToFindFull_Delete(Scintilla__TextToFindFull* self); + +void Scintilla__Rectangle_Delete(Scintilla__Rectangle* self); + +void Scintilla__RangeToFormat_Delete(Scintilla__RangeToFormat* self); + +void Scintilla__RangeToFormatFull_Delete(Scintilla__RangeToFormatFull* self); + +void Scintilla__NotifyHeader_Delete(Scintilla__NotifyHeader* self); + +void Scintilla__NotificationData_Delete(Scintilla__NotificationData* self); + +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new(const char* faceName_); +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new2(const char* faceName_, double size_); +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new3(const char* faceName_, double size_, int weight_); +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new4(const char* faceName_, double size_, int weight_, bool italic_); +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new5(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_); +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new6(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_, int technology_); +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new7(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_, int technology_, int characterSet_); +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new8(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_, int technology_, int characterSet_, const char* localeName_); +Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new9(const char* faceName_, double size_, int weight_, bool italic_, int extraFontFlag_, int technology_, int characterSet_, const char* localeName_, int stretch_); +void Scintilla__Internal__FontParameters_Delete(Scintilla__Internal__FontParameters* self); + +Scintilla__Internal__Font* Scintilla__Internal__Font_new(); +void Scintilla__Internal__Font_Delete(Scintilla__Internal__Font* self); + +size_t Scintilla__Internal__IScreenLine_Length(const Scintilla__Internal__IScreenLine* self); +size_t Scintilla__Internal__IScreenLine_RepresentationCount(const Scintilla__Internal__IScreenLine* self); +double Scintilla__Internal__IScreenLine_Width(const Scintilla__Internal__IScreenLine* self); +double Scintilla__Internal__IScreenLine_Height(const Scintilla__Internal__IScreenLine* self); +double Scintilla__Internal__IScreenLine_TabWidth(const Scintilla__Internal__IScreenLine* self); +double Scintilla__Internal__IScreenLine_TabWidthMinimumPixels(const Scintilla__Internal__IScreenLine* self); +Scintilla__Internal__Font* Scintilla__Internal__IScreenLine_FontOfPosition(const Scintilla__Internal__IScreenLine* self, size_t position); +double Scintilla__Internal__IScreenLine_RepresentationWidth(const Scintilla__Internal__IScreenLine* self, size_t position); +double Scintilla__Internal__IScreenLine_TabPositionAfter(const Scintilla__Internal__IScreenLine* self, double xPosition); +void Scintilla__Internal__IScreenLine_OperatorAssign(Scintilla__Internal__IScreenLine* self, Scintilla__Internal__IScreenLine* param1); +void Scintilla__Internal__IScreenLine_Delete(Scintilla__Internal__IScreenLine* self); + +size_t Scintilla__Internal__IScreenLineLayout_PositionFromX(Scintilla__Internal__IScreenLineLayout* self, double xDistance, bool charPosition); +double Scintilla__Internal__IScreenLineLayout_XFromPosition(Scintilla__Internal__IScreenLineLayout* self, size_t caretPosition); +void Scintilla__Internal__IScreenLineLayout_OperatorAssign(Scintilla__Internal__IScreenLineLayout* self, Scintilla__Internal__IScreenLineLayout* param1); +void Scintilla__Internal__IScreenLineLayout_Delete(Scintilla__Internal__IScreenLineLayout* self); + +Scintilla__Internal__SurfaceMode* Scintilla__Internal__SurfaceMode_new(); +Scintilla__Internal__SurfaceMode* Scintilla__Internal__SurfaceMode_new2(int codePage_, bool bidiR2L_); +void Scintilla__Internal__SurfaceMode_Delete(Scintilla__Internal__SurfaceMode* self); + +void Scintilla__Internal__Surface_Init(Scintilla__Internal__Surface* self, void* wid); +void Scintilla__Internal__Surface_Init2(Scintilla__Internal__Surface* self, void* sid, void* wid); +void Scintilla__Internal__Surface_SetMode(Scintilla__Internal__Surface* self, Scintilla__Internal__SurfaceMode* mode); +void Scintilla__Internal__Surface_Release(Scintilla__Internal__Surface* self); +int Scintilla__Internal__Surface_SupportsFeature(Scintilla__Internal__Surface* self, int feature); +bool Scintilla__Internal__Surface_Initialised(Scintilla__Internal__Surface* self); +int Scintilla__Internal__Surface_LogPixelsY(Scintilla__Internal__Surface* self); +int Scintilla__Internal__Surface_PixelDivisions(Scintilla__Internal__Surface* self); +int Scintilla__Internal__Surface_DeviceHeightFont(Scintilla__Internal__Surface* self, int points); +void Scintilla__Internal__Surface_LineDraw(Scintilla__Internal__Surface* self, Scintilla__Internal__Point* start, Scintilla__Internal__Point* end, Scintilla__Internal__Stroke* stroke); +void Scintilla__Internal__Surface_PolyLine(Scintilla__Internal__Surface* self, Scintilla__Internal__Point* pts, size_t npts, Scintilla__Internal__Stroke* stroke); +void Scintilla__Internal__Surface_Polygon(Scintilla__Internal__Surface* self, Scintilla__Internal__Point* pts, size_t npts, Scintilla__Internal__FillStroke* fillStroke); +void Scintilla__Internal__Surface_RectangleDraw(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke); +void Scintilla__Internal__Surface_RectangleFrame(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Stroke* stroke); +void Scintilla__Internal__Surface_FillRectangle(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Fill* fill); +void Scintilla__Internal__Surface_FillRectangleAligned(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Fill* fill); +void Scintilla__Internal__Surface_FillRectangle2(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Surface* surfacePattern); +void Scintilla__Internal__Surface_RoundedRectangle(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke); +void Scintilla__Internal__Surface_AlphaRectangle(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, double cornerSize, Scintilla__Internal__FillStroke* fillStroke); +void Scintilla__Internal__Surface_DrawRGBAImage(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, int width, int height, const unsigned char* pixelsImage); +void Scintilla__Internal__Surface_Ellipse(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke); +void Scintilla__Internal__Surface_Stadium(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke, int ends); +void Scintilla__Internal__Surface_Copy(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Point* from, Scintilla__Internal__Surface* surfaceSource); +double Scintilla__Internal__Surface_Ascent(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_); +double Scintilla__Internal__Surface_Descent(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_); +double Scintilla__Internal__Surface_InternalLeading(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_); +double Scintilla__Internal__Surface_Height(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_); +double Scintilla__Internal__Surface_AverageCharWidth(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_); +void Scintilla__Internal__Surface_SetClip(Scintilla__Internal__Surface* self, Scintilla__Internal__PRectangle* rc); +void Scintilla__Internal__Surface_PopClip(Scintilla__Internal__Surface* self); +void Scintilla__Internal__Surface_FlushCachedState(Scintilla__Internal__Surface* self); +void Scintilla__Internal__Surface_FlushDrawing(Scintilla__Internal__Surface* self); +void Scintilla__Internal__Surface_Delete(Scintilla__Internal__Surface* self); + +Scintilla__Internal__Window* Scintilla__Internal__Window_new(); +void Scintilla__Internal__Window_OperatorAssign(Scintilla__Internal__Window* self, void* wid_); +void* Scintilla__Internal__Window_GetID(const Scintilla__Internal__Window* self); +bool Scintilla__Internal__Window_Created(const Scintilla__Internal__Window* self); +void Scintilla__Internal__Window_Destroy(Scintilla__Internal__Window* self); +Scintilla__Internal__PRectangle* Scintilla__Internal__Window_GetPosition(const Scintilla__Internal__Window* self); +void Scintilla__Internal__Window_SetPosition(Scintilla__Internal__Window* self, Scintilla__Internal__PRectangle* rc); +void Scintilla__Internal__Window_SetPositionRelative(Scintilla__Internal__Window* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Window* relativeTo); +Scintilla__Internal__PRectangle* Scintilla__Internal__Window_GetClientPosition(const Scintilla__Internal__Window* self); +void Scintilla__Internal__Window_Show(Scintilla__Internal__Window* self); +void Scintilla__Internal__Window_InvalidateAll(Scintilla__Internal__Window* self); +void Scintilla__Internal__Window_InvalidateRectangle(Scintilla__Internal__Window* self, Scintilla__Internal__PRectangle* rc); +void Scintilla__Internal__Window_SetCursor(Scintilla__Internal__Window* self, int curs); +Scintilla__Internal__PRectangle* Scintilla__Internal__Window_GetMonitorRect(Scintilla__Internal__Window* self, Scintilla__Internal__Point* pt); +void Scintilla__Internal__Window_Show1(Scintilla__Internal__Window* self, bool show); +void Scintilla__Internal__Window_Delete(Scintilla__Internal__Window* self); + +Scintilla__Internal__ListBoxEvent* Scintilla__Internal__ListBoxEvent_new(int event_); +void Scintilla__Internal__ListBoxEvent_Delete(Scintilla__Internal__ListBoxEvent* self); + +void Scintilla__Internal__IListBoxDelegate_ListNotify(Scintilla__Internal__IListBoxDelegate* self, Scintilla__Internal__ListBoxEvent* plbe); +void Scintilla__Internal__IListBoxDelegate_OperatorAssign(Scintilla__Internal__IListBoxDelegate* self, Scintilla__Internal__IListBoxDelegate* param1); +void Scintilla__Internal__IListBoxDelegate_Delete(Scintilla__Internal__IListBoxDelegate* self); + +void Scintilla__Internal__ListOptions_Delete(Scintilla__Internal__ListOptions* self); + +void Scintilla__Internal__ListBox_SetFont(Scintilla__Internal__ListBox* self, Scintilla__Internal__Font* font); +void Scintilla__Internal__ListBox_Create(Scintilla__Internal__ListBox* self, Scintilla__Internal__Window* parent, int ctrlID, Scintilla__Internal__Point* location, int lineHeight_, bool unicodeMode_, int technology_); +void Scintilla__Internal__ListBox_SetAverageCharWidth(Scintilla__Internal__ListBox* self, int width); +void Scintilla__Internal__ListBox_SetVisibleRows(Scintilla__Internal__ListBox* self, int rows); +int Scintilla__Internal__ListBox_GetVisibleRows(const Scintilla__Internal__ListBox* self); +Scintilla__Internal__PRectangle* Scintilla__Internal__ListBox_GetDesiredRect(Scintilla__Internal__ListBox* self); +int Scintilla__Internal__ListBox_CaretFromEdge(Scintilla__Internal__ListBox* self); +void Scintilla__Internal__ListBox_Clear(Scintilla__Internal__ListBox* self); +void Scintilla__Internal__ListBox_Append(Scintilla__Internal__ListBox* self, char* s); +int Scintilla__Internal__ListBox_Length(Scintilla__Internal__ListBox* self); +void Scintilla__Internal__ListBox_Select(Scintilla__Internal__ListBox* self, int n); +int Scintilla__Internal__ListBox_GetSelection(Scintilla__Internal__ListBox* self); +int Scintilla__Internal__ListBox_Find(Scintilla__Internal__ListBox* self, const char* prefix); +void Scintilla__Internal__ListBox_RegisterImage(Scintilla__Internal__ListBox* self, int typeVal, const char* xpm_data); +void Scintilla__Internal__ListBox_RegisterRGBAImage(Scintilla__Internal__ListBox* self, int typeVal, int width, int height, const unsigned char* pixelsImage); +void Scintilla__Internal__ListBox_ClearRegisteredImages(Scintilla__Internal__ListBox* self); +void Scintilla__Internal__ListBox_SetDelegate(Scintilla__Internal__ListBox* self, Scintilla__Internal__IListBoxDelegate* lbDelegate); +void Scintilla__Internal__ListBox_SetList(Scintilla__Internal__ListBox* self, const char* list, char separator, char typesep); +void Scintilla__Internal__ListBox_SetOptions(Scintilla__Internal__ListBox* self, Scintilla__Internal__ListOptions* options_); +void Scintilla__Internal__ListBox_Append2(Scintilla__Internal__ListBox* self, char* s, int typeVal); +void Scintilla__Internal__ListBox_Delete(Scintilla__Internal__ListBox* self); + +Scintilla__Internal__Menu* Scintilla__Internal__Menu_new(); +void* Scintilla__Internal__Menu_GetID(const Scintilla__Internal__Menu* self); +void Scintilla__Internal__Menu_CreatePopUp(Scintilla__Internal__Menu* self); +void Scintilla__Internal__Menu_Destroy(Scintilla__Internal__Menu* self); +void Scintilla__Internal__Menu_Show(Scintilla__Internal__Menu* self, Scintilla__Internal__Point* pt, Scintilla__Internal__Window* w); +void Scintilla__Internal__Menu_Delete(Scintilla__Internal__Menu* self); + +void Sci_CharacterRange_Delete(Sci_CharacterRange* self); + +void Sci_CharacterRangeFull_Delete(Sci_CharacterRangeFull* self); + +void Sci_TextRange_Delete(Sci_TextRange* self); + +void Sci_TextRangeFull_Delete(Sci_TextRangeFull* self); + +void Sci_TextToFind_Delete(Sci_TextToFind* self); + +void Sci_TextToFindFull_Delete(Sci_TextToFindFull* self); + +void Sci_Rectangle_Delete(Sci_Rectangle* self); + +void Sci_RangeToFormat_Delete(Sci_RangeToFormat* self); + +void Sci_RangeToFormatFull_Delete(Sci_RangeToFormatFull* self); + +void Sci_NotifyHeader_Delete(Sci_NotifyHeader* self); + +void SCNotification_Delete(SCNotification* self); + +ScintillaEditBase* ScintillaEditBase_new(); +ScintillaEditBase* ScintillaEditBase_new2(QWidget* parent); +QMetaObject* ScintillaEditBase_MetaObject(const ScintillaEditBase* self); +void* ScintillaEditBase_Metacast(ScintillaEditBase* self, const char* param1); +struct miqt_string ScintillaEditBase_Tr(const char* s); +struct miqt_string ScintillaEditBase_TrUtf8(const char* s); +intptr_t ScintillaEditBase_Send(const ScintillaEditBase* self, unsigned int iMessage); +intptr_t ScintillaEditBase_Sends(const ScintillaEditBase* self, unsigned int iMessage); +void ScintillaEditBase_ScrollHorizontal(ScintillaEditBase* self, int value); +void ScintillaEditBase_ScrollVertical(ScintillaEditBase* self, int value); +void ScintillaEditBase_NotifyParent(ScintillaEditBase* self, Scintilla__NotificationData* scn); +void ScintillaEditBase_EventCommand(ScintillaEditBase* self, uintptr_t wParam, intptr_t lParam); +void ScintillaEditBase_HorizontalScrolled(ScintillaEditBase* self, int value); +void ScintillaEditBase_connect_HorizontalScrolled(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_VerticalScrolled(ScintillaEditBase* self, int value); +void ScintillaEditBase_connect_VerticalScrolled(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_HorizontalRangeChanged(ScintillaEditBase* self, int max, int page); +void ScintillaEditBase_connect_HorizontalRangeChanged(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_VerticalRangeChanged(ScintillaEditBase* self, int max, int page); +void ScintillaEditBase_connect_VerticalRangeChanged(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_NotifyChange(ScintillaEditBase* self); +void ScintillaEditBase_connect_NotifyChange(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_LinesAdded(ScintillaEditBase* self, intptr_t linesAdded); +void ScintillaEditBase_connect_LinesAdded(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_AboutToCopy(ScintillaEditBase* self, QMimeData* data); +void ScintillaEditBase_connect_AboutToCopy(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_StyleNeeded(ScintillaEditBase* self, intptr_t position); +void ScintillaEditBase_connect_StyleNeeded(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_CharAdded(ScintillaEditBase* self, int ch); +void ScintillaEditBase_connect_CharAdded(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_SavePointChanged(ScintillaEditBase* self, bool dirty); +void ScintillaEditBase_connect_SavePointChanged(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_ModifyAttemptReadOnly(ScintillaEditBase* self); +void ScintillaEditBase_connect_ModifyAttemptReadOnly(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_Key(ScintillaEditBase* self, int key); +void ScintillaEditBase_connect_Key(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_DoubleClick(ScintillaEditBase* self, intptr_t position, intptr_t line); +void ScintillaEditBase_connect_DoubleClick(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_UpdateUi(ScintillaEditBase* self, int updated); +void ScintillaEditBase_connect_UpdateUi(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_Modified(ScintillaEditBase* self, int typeVal, intptr_t position, intptr_t length, intptr_t linesAdded, struct miqt_string text, intptr_t line, int foldNow, int foldPrev); +void ScintillaEditBase_connect_Modified(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_MacroRecord(ScintillaEditBase* self, int message, uintptr_t wParam, intptr_t lParam); +void ScintillaEditBase_connect_MacroRecord(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_MarginClicked(ScintillaEditBase* self, intptr_t position, int modifiers, int margin); +void ScintillaEditBase_connect_MarginClicked(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_TextAreaClicked(ScintillaEditBase* self, intptr_t line, int modifiers); +void ScintillaEditBase_connect_TextAreaClicked(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_NeedShown(ScintillaEditBase* self, intptr_t position, intptr_t length); +void ScintillaEditBase_connect_NeedShown(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_Painted(ScintillaEditBase* self); +void ScintillaEditBase_connect_Painted(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_UserListSelection(ScintillaEditBase* self); +void ScintillaEditBase_connect_UserListSelection(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_UriDropped(ScintillaEditBase* self, struct miqt_string uri); +void ScintillaEditBase_connect_UriDropped(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_DwellStart(ScintillaEditBase* self, int x, int y); +void ScintillaEditBase_connect_DwellStart(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_DwellEnd(ScintillaEditBase* self, int x, int y); +void ScintillaEditBase_connect_DwellEnd(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_Zoom(ScintillaEditBase* self, int zoom); +void ScintillaEditBase_connect_Zoom(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_HotSpotClick(ScintillaEditBase* self, intptr_t position, int modifiers); +void ScintillaEditBase_connect_HotSpotClick(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_HotSpotDoubleClick(ScintillaEditBase* self, intptr_t position, int modifiers); +void ScintillaEditBase_connect_HotSpotDoubleClick(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_CallTipClick(ScintillaEditBase* self); +void ScintillaEditBase_connect_CallTipClick(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_AutoCompleteSelection(ScintillaEditBase* self, intptr_t position, struct miqt_string text); +void ScintillaEditBase_connect_AutoCompleteSelection(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_AutoCompleteCancelled(ScintillaEditBase* self); +void ScintillaEditBase_connect_AutoCompleteCancelled(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_FocusChanged(ScintillaEditBase* self, bool focused); +void ScintillaEditBase_connect_FocusChanged(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_Notify(ScintillaEditBase* self, Scintilla__NotificationData* pscn); +void ScintillaEditBase_connect_Notify(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_Command(ScintillaEditBase* self, uintptr_t wParam, intptr_t lParam); +void ScintillaEditBase_connect_Command(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_ButtonPressed(ScintillaEditBase* self, QMouseEvent* event); +void ScintillaEditBase_connect_ButtonPressed(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_ButtonReleased(ScintillaEditBase* self, QMouseEvent* event); +void ScintillaEditBase_connect_ButtonReleased(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_KeyPressed(ScintillaEditBase* self, QKeyEvent* event); +void ScintillaEditBase_connect_KeyPressed(ScintillaEditBase* self, intptr_t slot); +void ScintillaEditBase_Resized(ScintillaEditBase* self); +void ScintillaEditBase_connect_Resized(ScintillaEditBase* self, intptr_t slot); +struct miqt_string ScintillaEditBase_Tr2(const char* s, const char* c); +struct miqt_string ScintillaEditBase_Tr3(const char* s, const char* c, int n); +struct miqt_string ScintillaEditBase_TrUtf82(const char* s, const char* c); +struct miqt_string ScintillaEditBase_TrUtf83(const char* s, const char* c, int n); +intptr_t ScintillaEditBase_Send2(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam); +intptr_t ScintillaEditBase_Send3(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam, intptr_t lParam); +intptr_t ScintillaEditBase_Sends2(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam); +intptr_t ScintillaEditBase_Sends3(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam, const char* s); +void ScintillaEditBase_Delete(ScintillaEditBase* self); + +ScintillaDocument* ScintillaDocument_new(); +ScintillaDocument* ScintillaDocument_new2(QObject* parent); +ScintillaDocument* ScintillaDocument_new3(QObject* parent, void* pdoc_); +QMetaObject* ScintillaDocument_MetaObject(const ScintillaDocument* self); +void* ScintillaDocument_Metacast(ScintillaDocument* self, const char* param1); +struct miqt_string ScintillaDocument_Tr(const char* s); +struct miqt_string ScintillaDocument_TrUtf8(const char* s); +void* ScintillaDocument_Pointer(ScintillaDocument* self); +int ScintillaDocument_LineFromPosition(ScintillaDocument* self, int pos); +bool ScintillaDocument_IsCrLf(ScintillaDocument* self, int pos); +bool ScintillaDocument_DeleteChars(ScintillaDocument* self, int pos, int lenVal); +int ScintillaDocument_Undo(ScintillaDocument* self); +int ScintillaDocument_Redo(ScintillaDocument* self); +bool ScintillaDocument_CanUndo(ScintillaDocument* self); +bool ScintillaDocument_CanRedo(ScintillaDocument* self); +void ScintillaDocument_DeleteUndoHistory(ScintillaDocument* self); +bool ScintillaDocument_SetUndoCollection(ScintillaDocument* self, bool collect_undo); +bool ScintillaDocument_IsCollectingUndo(ScintillaDocument* self); +void ScintillaDocument_BeginUndoAction(ScintillaDocument* self); +void ScintillaDocument_EndUndoAction(ScintillaDocument* self); +void ScintillaDocument_SetSavePoint(ScintillaDocument* self); +bool ScintillaDocument_IsSavePoint(ScintillaDocument* self); +void ScintillaDocument_SetReadOnly(ScintillaDocument* self, bool read_only); +bool ScintillaDocument_IsReadOnly(ScintillaDocument* self); +void ScintillaDocument_InsertString(ScintillaDocument* self, int position, struct miqt_string str); +struct miqt_string ScintillaDocument_GetCharRange(ScintillaDocument* self, int position, int length); +char ScintillaDocument_StyleAt(ScintillaDocument* self, int position); +int ScintillaDocument_LineStart(ScintillaDocument* self, int lineno); +int ScintillaDocument_LineEnd(ScintillaDocument* self, int lineno); +int ScintillaDocument_LineEndPosition(ScintillaDocument* self, int pos); +int ScintillaDocument_Length(ScintillaDocument* self); +int ScintillaDocument_LinesTotal(ScintillaDocument* self); +void ScintillaDocument_StartStyling(ScintillaDocument* self, int position); +bool ScintillaDocument_SetStyleFor(ScintillaDocument* self, int length, char style); +int ScintillaDocument_GetEndStyled(ScintillaDocument* self); +void ScintillaDocument_EnsureStyledTo(ScintillaDocument* self, int position); +void ScintillaDocument_SetCurrentIndicator(ScintillaDocument* self, int indic); +void ScintillaDocument_DecorationFillRange(ScintillaDocument* self, int position, int value, int fillLength); +int ScintillaDocument_DecorationsValueAt(ScintillaDocument* self, int indic, int position); +int ScintillaDocument_DecorationsStart(ScintillaDocument* self, int indic, int position); +int ScintillaDocument_DecorationsEnd(ScintillaDocument* self, int indic, int position); +int ScintillaDocument_GetCodePage(ScintillaDocument* self); +void ScintillaDocument_SetCodePage(ScintillaDocument* self, int code_page); +int ScintillaDocument_GetEolMode(ScintillaDocument* self); +void ScintillaDocument_SetEolMode(ScintillaDocument* self, int eol_mode); +int ScintillaDocument_MovePositionOutsideChar(ScintillaDocument* self, int pos, int move_dir, bool check_line_end); +int ScintillaDocument_GetCharacter(ScintillaDocument* self, int pos); +void ScintillaDocument_ModifyAttempt(ScintillaDocument* self); +void ScintillaDocument_connect_ModifyAttempt(ScintillaDocument* self, intptr_t slot); +void ScintillaDocument_SavePoint(ScintillaDocument* self, bool atSavePoint); +void ScintillaDocument_connect_SavePoint(ScintillaDocument* self, intptr_t slot); +void ScintillaDocument_Modified(ScintillaDocument* self, int position, int modification_type, struct miqt_string text, int length, int linesAdded, int line, int foldLevelNow, int foldLevelPrev); +void ScintillaDocument_connect_Modified(ScintillaDocument* self, intptr_t slot); +void ScintillaDocument_StyleNeeded(ScintillaDocument* self, int pos); +void ScintillaDocument_connect_StyleNeeded(ScintillaDocument* self, intptr_t slot); +void ScintillaDocument_ErrorOccurred(ScintillaDocument* self, int status); +void ScintillaDocument_connect_ErrorOccurred(ScintillaDocument* self, intptr_t slot); +struct miqt_string ScintillaDocument_Tr2(const char* s, const char* c); +struct miqt_string ScintillaDocument_Tr3(const char* s, const char* c, int n); +struct miqt_string ScintillaDocument_TrUtf82(const char* s, const char* c); +struct miqt_string ScintillaDocument_TrUtf83(const char* s, const char* c, int n); +void ScintillaDocument_BeginUndoAction1(ScintillaDocument* self, bool coalesceWithPrior); +void ScintillaDocument_Delete(ScintillaDocument* self); + +ScintillaEdit* ScintillaEdit_new(); +ScintillaEdit* ScintillaEdit_new2(QWidget* parent); +QMetaObject* ScintillaEdit_MetaObject(const ScintillaEdit* self); +void* ScintillaEdit_Metacast(ScintillaEdit* self, const char* param1); +struct miqt_string ScintillaEdit_Tr(const char* s); +struct miqt_string ScintillaEdit_TrUtf8(const char* s); +struct miqt_string ScintillaEdit_TextReturner(const ScintillaEdit* self, int message, uintptr_t wParam); +struct miqt_string ScintillaEdit_GetTextRange(ScintillaEdit* self, int start, int end); +ScintillaDocument* ScintillaEdit_GetDoc(ScintillaEdit* self); +void ScintillaEdit_SetDoc(ScintillaEdit* self, ScintillaDocument* pdoc_); +struct miqt_string ScintillaEdit_TextRange(ScintillaEdit* self, int start, int end); +long ScintillaEdit_FormatRange(ScintillaEdit* self, bool draw, QPaintDevice* target, QPaintDevice* measure, QRect* print_rect, QRect* page_rect, long range_start, long range_end); +long ScintillaEdit_FormatRange2(ScintillaEdit* self, bool draw, QPaintDevice* target, QPaintDevice* measure, QRect* print_rect, QRect* page_rect, long range_start, long range_end); +void ScintillaEdit_AddText(ScintillaEdit* self, intptr_t length, const char* text); +void ScintillaEdit_AddStyledText(ScintillaEdit* self, intptr_t length, const char* c); +void ScintillaEdit_InsertText(ScintillaEdit* self, intptr_t pos, const char* text); +void ScintillaEdit_ChangeInsertion(ScintillaEdit* self, intptr_t length, const char* text); +void ScintillaEdit_ClearAll(ScintillaEdit* self); +void ScintillaEdit_DeleteRange(ScintillaEdit* self, intptr_t start, intptr_t lengthDelete); +void ScintillaEdit_ClearDocumentStyle(ScintillaEdit* self); +intptr_t ScintillaEdit_Length(const ScintillaEdit* self); +intptr_t ScintillaEdit_CharAt(const ScintillaEdit* self, intptr_t pos); +intptr_t ScintillaEdit_CurrentPos(const ScintillaEdit* self); +intptr_t ScintillaEdit_Anchor(const ScintillaEdit* self); +intptr_t ScintillaEdit_StyleAt(const ScintillaEdit* self, intptr_t pos); +intptr_t ScintillaEdit_StyleIndexAt(const ScintillaEdit* self, intptr_t pos); +void ScintillaEdit_Redo(ScintillaEdit* self); +void ScintillaEdit_SetUndoCollection(ScintillaEdit* self, bool collectUndo); +void ScintillaEdit_SelectAll(ScintillaEdit* self); +void ScintillaEdit_SetSavePoint(ScintillaEdit* self); +bool ScintillaEdit_CanRedo(ScintillaEdit* self); +intptr_t ScintillaEdit_MarkerLineFromHandle(ScintillaEdit* self, intptr_t markerHandle); +void ScintillaEdit_MarkerDeleteHandle(ScintillaEdit* self, intptr_t markerHandle); +intptr_t ScintillaEdit_MarkerHandleFromLine(ScintillaEdit* self, intptr_t line, intptr_t which); +intptr_t ScintillaEdit_MarkerNumberFromLine(ScintillaEdit* self, intptr_t line, intptr_t which); +bool ScintillaEdit_UndoCollection(const ScintillaEdit* self); +intptr_t ScintillaEdit_ViewWS(const ScintillaEdit* self); +void ScintillaEdit_SetViewWS(ScintillaEdit* self, intptr_t viewWS); +intptr_t ScintillaEdit_TabDrawMode(const ScintillaEdit* self); +void ScintillaEdit_SetTabDrawMode(ScintillaEdit* self, intptr_t tabDrawMode); +intptr_t ScintillaEdit_PositionFromPoint(ScintillaEdit* self, intptr_t x, intptr_t y); +intptr_t ScintillaEdit_PositionFromPointClose(ScintillaEdit* self, intptr_t x, intptr_t y); +void ScintillaEdit_GotoLine(ScintillaEdit* self, intptr_t line); +void ScintillaEdit_GotoPos(ScintillaEdit* self, intptr_t caret); +void ScintillaEdit_SetAnchor(ScintillaEdit* self, intptr_t anchor); +struct miqt_string ScintillaEdit_GetCurLine(ScintillaEdit* self, intptr_t length); +intptr_t ScintillaEdit_EndStyled(const ScintillaEdit* self); +void ScintillaEdit_ConvertEOLs(ScintillaEdit* self, intptr_t eolMode); +intptr_t ScintillaEdit_EOLMode(const ScintillaEdit* self); +void ScintillaEdit_SetEOLMode(ScintillaEdit* self, intptr_t eolMode); +void ScintillaEdit_StartStyling(ScintillaEdit* self, intptr_t start, intptr_t unused); +void ScintillaEdit_SetStyling(ScintillaEdit* self, intptr_t length, intptr_t style); +bool ScintillaEdit_BufferedDraw(const ScintillaEdit* self); +void ScintillaEdit_SetBufferedDraw(ScintillaEdit* self, bool buffered); +void ScintillaEdit_SetTabWidth(ScintillaEdit* self, intptr_t tabWidth); +intptr_t ScintillaEdit_TabWidth(const ScintillaEdit* self); +void ScintillaEdit_SetTabMinimumWidth(ScintillaEdit* self, intptr_t pixels); +intptr_t ScintillaEdit_TabMinimumWidth(const ScintillaEdit* self); +void ScintillaEdit_ClearTabStops(ScintillaEdit* self, intptr_t line); +void ScintillaEdit_AddTabStop(ScintillaEdit* self, intptr_t line, intptr_t x); +intptr_t ScintillaEdit_GetNextTabStop(ScintillaEdit* self, intptr_t line, intptr_t x); +void ScintillaEdit_SetCodePage(ScintillaEdit* self, intptr_t codePage); +void ScintillaEdit_SetFontLocale(ScintillaEdit* self, const char* localeName); +struct miqt_string ScintillaEdit_FontLocale(const ScintillaEdit* self); +intptr_t ScintillaEdit_IMEInteraction(const ScintillaEdit* self); +void ScintillaEdit_SetIMEInteraction(ScintillaEdit* self, intptr_t imeInteraction); +void ScintillaEdit_MarkerDefine(ScintillaEdit* self, intptr_t markerNumber, intptr_t markerSymbol); +void ScintillaEdit_MarkerSetFore(ScintillaEdit* self, intptr_t markerNumber, intptr_t fore); +void ScintillaEdit_MarkerSetBack(ScintillaEdit* self, intptr_t markerNumber, intptr_t back); +void ScintillaEdit_MarkerSetBackSelected(ScintillaEdit* self, intptr_t markerNumber, intptr_t back); +void ScintillaEdit_MarkerSetForeTranslucent(ScintillaEdit* self, intptr_t markerNumber, intptr_t fore); +void ScintillaEdit_MarkerSetBackTranslucent(ScintillaEdit* self, intptr_t markerNumber, intptr_t back); +void ScintillaEdit_MarkerSetBackSelectedTranslucent(ScintillaEdit* self, intptr_t markerNumber, intptr_t back); +void ScintillaEdit_MarkerSetStrokeWidth(ScintillaEdit* self, intptr_t markerNumber, intptr_t hundredths); +void ScintillaEdit_MarkerEnableHighlight(ScintillaEdit* self, bool enabled); +intptr_t ScintillaEdit_MarkerAdd(ScintillaEdit* self, intptr_t line, intptr_t markerNumber); +void ScintillaEdit_MarkerDelete(ScintillaEdit* self, intptr_t line, intptr_t markerNumber); +void ScintillaEdit_MarkerDeleteAll(ScintillaEdit* self, intptr_t markerNumber); +intptr_t ScintillaEdit_MarkerGet(ScintillaEdit* self, intptr_t line); +intptr_t ScintillaEdit_MarkerNext(ScintillaEdit* self, intptr_t lineStart, intptr_t markerMask); +intptr_t ScintillaEdit_MarkerPrevious(ScintillaEdit* self, intptr_t lineStart, intptr_t markerMask); +void ScintillaEdit_MarkerDefinePixmap(ScintillaEdit* self, intptr_t markerNumber, const char* pixmap); +void ScintillaEdit_MarkerAddSet(ScintillaEdit* self, intptr_t line, intptr_t markerSet); +void ScintillaEdit_MarkerSetAlpha(ScintillaEdit* self, intptr_t markerNumber, intptr_t alpha); +intptr_t ScintillaEdit_MarkerLayer(const ScintillaEdit* self, intptr_t markerNumber); +void ScintillaEdit_MarkerSetLayer(ScintillaEdit* self, intptr_t markerNumber, intptr_t layer); +void ScintillaEdit_SetMarginTypeN(ScintillaEdit* self, intptr_t margin, intptr_t marginType); +intptr_t ScintillaEdit_MarginTypeN(const ScintillaEdit* self, intptr_t margin); +void ScintillaEdit_SetMarginWidthN(ScintillaEdit* self, intptr_t margin, intptr_t pixelWidth); +intptr_t ScintillaEdit_MarginWidthN(const ScintillaEdit* self, intptr_t margin); +void ScintillaEdit_SetMarginMaskN(ScintillaEdit* self, intptr_t margin, intptr_t mask); +intptr_t ScintillaEdit_MarginMaskN(const ScintillaEdit* self, intptr_t margin); +void ScintillaEdit_SetMarginSensitiveN(ScintillaEdit* self, intptr_t margin, bool sensitive); +bool ScintillaEdit_MarginSensitiveN(const ScintillaEdit* self, intptr_t margin); +void ScintillaEdit_SetMarginCursorN(ScintillaEdit* self, intptr_t margin, intptr_t cursor); +intptr_t ScintillaEdit_MarginCursorN(const ScintillaEdit* self, intptr_t margin); +void ScintillaEdit_SetMarginBackN(ScintillaEdit* self, intptr_t margin, intptr_t back); +intptr_t ScintillaEdit_MarginBackN(const ScintillaEdit* self, intptr_t margin); +void ScintillaEdit_SetMargins(ScintillaEdit* self, intptr_t margins); +intptr_t ScintillaEdit_Margins(const ScintillaEdit* self); +void ScintillaEdit_StyleClearAll(ScintillaEdit* self); +void ScintillaEdit_StyleSetFore(ScintillaEdit* self, intptr_t style, intptr_t fore); +void ScintillaEdit_StyleSetBack(ScintillaEdit* self, intptr_t style, intptr_t back); +void ScintillaEdit_StyleSetBold(ScintillaEdit* self, intptr_t style, bool bold); +void ScintillaEdit_StyleSetItalic(ScintillaEdit* self, intptr_t style, bool italic); +void ScintillaEdit_StyleSetSize(ScintillaEdit* self, intptr_t style, intptr_t sizePoints); +void ScintillaEdit_StyleSetFont(ScintillaEdit* self, intptr_t style, const char* fontName); +void ScintillaEdit_StyleSetEOLFilled(ScintillaEdit* self, intptr_t style, bool eolFilled); +void ScintillaEdit_StyleResetDefault(ScintillaEdit* self); +void ScintillaEdit_StyleSetUnderline(ScintillaEdit* self, intptr_t style, bool underline); +intptr_t ScintillaEdit_StyleFore(const ScintillaEdit* self, intptr_t style); +intptr_t ScintillaEdit_StyleBack(const ScintillaEdit* self, intptr_t style); +bool ScintillaEdit_StyleBold(const ScintillaEdit* self, intptr_t style); +bool ScintillaEdit_StyleItalic(const ScintillaEdit* self, intptr_t style); +intptr_t ScintillaEdit_StyleSize(const ScintillaEdit* self, intptr_t style); +struct miqt_string ScintillaEdit_StyleFont(const ScintillaEdit* self, intptr_t style); +bool ScintillaEdit_StyleEOLFilled(const ScintillaEdit* self, intptr_t style); +bool ScintillaEdit_StyleUnderline(const ScintillaEdit* self, intptr_t style); +intptr_t ScintillaEdit_StyleCase(const ScintillaEdit* self, intptr_t style); +intptr_t ScintillaEdit_StyleCharacterSet(const ScintillaEdit* self, intptr_t style); +bool ScintillaEdit_StyleVisible(const ScintillaEdit* self, intptr_t style); +bool ScintillaEdit_StyleChangeable(const ScintillaEdit* self, intptr_t style); +bool ScintillaEdit_StyleHotSpot(const ScintillaEdit* self, intptr_t style); +void ScintillaEdit_StyleSetCase(ScintillaEdit* self, intptr_t style, intptr_t caseVisible); +void ScintillaEdit_StyleSetSizeFractional(ScintillaEdit* self, intptr_t style, intptr_t sizeHundredthPoints); +intptr_t ScintillaEdit_StyleSizeFractional(const ScintillaEdit* self, intptr_t style); +void ScintillaEdit_StyleSetWeight(ScintillaEdit* self, intptr_t style, intptr_t weight); +intptr_t ScintillaEdit_StyleWeight(const ScintillaEdit* self, intptr_t style); +void ScintillaEdit_StyleSetCharacterSet(ScintillaEdit* self, intptr_t style, intptr_t characterSet); +void ScintillaEdit_StyleSetHotSpot(ScintillaEdit* self, intptr_t style, bool hotspot); +void ScintillaEdit_StyleSetCheckMonospaced(ScintillaEdit* self, intptr_t style, bool checkMonospaced); +bool ScintillaEdit_StyleCheckMonospaced(const ScintillaEdit* self, intptr_t style); +void ScintillaEdit_StyleSetStretch(ScintillaEdit* self, intptr_t style, intptr_t stretch); +intptr_t ScintillaEdit_StyleStretch(const ScintillaEdit* self, intptr_t style); +void ScintillaEdit_StyleSetInvisibleRepresentation(ScintillaEdit* self, intptr_t style, const char* representation); +struct miqt_string ScintillaEdit_StyleInvisibleRepresentation(const ScintillaEdit* self, intptr_t style); +void ScintillaEdit_SetElementColour(ScintillaEdit* self, intptr_t element, intptr_t colourElement); +intptr_t ScintillaEdit_ElementColour(const ScintillaEdit* self, intptr_t element); +void ScintillaEdit_ResetElementColour(ScintillaEdit* self, intptr_t element); +bool ScintillaEdit_ElementIsSet(const ScintillaEdit* self, intptr_t element); +bool ScintillaEdit_ElementAllowsTranslucent(const ScintillaEdit* self, intptr_t element); +intptr_t ScintillaEdit_ElementBaseColour(const ScintillaEdit* self, intptr_t element); +void ScintillaEdit_SetSelFore(ScintillaEdit* self, bool useSetting, intptr_t fore); +void ScintillaEdit_SetSelBack(ScintillaEdit* self, bool useSetting, intptr_t back); +intptr_t ScintillaEdit_SelAlpha(const ScintillaEdit* self); +void ScintillaEdit_SetSelAlpha(ScintillaEdit* self, intptr_t alpha); +bool ScintillaEdit_SelEOLFilled(const ScintillaEdit* self); +void ScintillaEdit_SetSelEOLFilled(ScintillaEdit* self, bool filled); +intptr_t ScintillaEdit_SelectionLayer(const ScintillaEdit* self); +void ScintillaEdit_SetSelectionLayer(ScintillaEdit* self, intptr_t layer); +intptr_t ScintillaEdit_CaretLineLayer(const ScintillaEdit* self); +void ScintillaEdit_SetCaretLineLayer(ScintillaEdit* self, intptr_t layer); +bool ScintillaEdit_CaretLineHighlightSubLine(const ScintillaEdit* self); +void ScintillaEdit_SetCaretLineHighlightSubLine(ScintillaEdit* self, bool subLine); +void ScintillaEdit_SetCaretFore(ScintillaEdit* self, intptr_t fore); +void ScintillaEdit_AssignCmdKey(ScintillaEdit* self, intptr_t keyDefinition, intptr_t sciCommand); +void ScintillaEdit_ClearCmdKey(ScintillaEdit* self, intptr_t keyDefinition); +void ScintillaEdit_ClearAllCmdKeys(ScintillaEdit* self); +void ScintillaEdit_SetStylingEx(ScintillaEdit* self, intptr_t length, const char* styles); +void ScintillaEdit_StyleSetVisible(ScintillaEdit* self, intptr_t style, bool visible); +intptr_t ScintillaEdit_CaretPeriod(const ScintillaEdit* self); +void ScintillaEdit_SetCaretPeriod(ScintillaEdit* self, intptr_t periodMilliseconds); +void ScintillaEdit_SetWordChars(ScintillaEdit* self, const char* characters); +struct miqt_string ScintillaEdit_WordChars(const ScintillaEdit* self); +void ScintillaEdit_SetCharacterCategoryOptimization(ScintillaEdit* self, intptr_t countCharacters); +intptr_t ScintillaEdit_CharacterCategoryOptimization(const ScintillaEdit* self); +void ScintillaEdit_BeginUndoAction(ScintillaEdit* self); +void ScintillaEdit_EndUndoAction(ScintillaEdit* self); +intptr_t ScintillaEdit_UndoSequence(const ScintillaEdit* self); +intptr_t ScintillaEdit_UndoActions(const ScintillaEdit* self); +void ScintillaEdit_SetUndoSavePoint(ScintillaEdit* self, intptr_t action); +intptr_t ScintillaEdit_UndoSavePoint(const ScintillaEdit* self); +void ScintillaEdit_SetUndoDetach(ScintillaEdit* self, intptr_t action); +intptr_t ScintillaEdit_UndoDetach(const ScintillaEdit* self); +void ScintillaEdit_SetUndoTentative(ScintillaEdit* self, intptr_t action); +intptr_t ScintillaEdit_UndoTentative(const ScintillaEdit* self); +void ScintillaEdit_SetUndoCurrent(ScintillaEdit* self, intptr_t action); +intptr_t ScintillaEdit_UndoCurrent(const ScintillaEdit* self); +void ScintillaEdit_PushUndoActionType(ScintillaEdit* self, intptr_t typeVal, intptr_t pos); +void ScintillaEdit_ChangeLastUndoActionText(ScintillaEdit* self, intptr_t length, const char* text); +intptr_t ScintillaEdit_UndoActionType(const ScintillaEdit* self, intptr_t action); +intptr_t ScintillaEdit_UndoActionPosition(const ScintillaEdit* self, intptr_t action); +struct miqt_string ScintillaEdit_UndoActionText(const ScintillaEdit* self, intptr_t action); +void ScintillaEdit_IndicSetStyle(ScintillaEdit* self, intptr_t indicator, intptr_t indicatorStyle); +intptr_t ScintillaEdit_IndicStyle(const ScintillaEdit* self, intptr_t indicator); +void ScintillaEdit_IndicSetFore(ScintillaEdit* self, intptr_t indicator, intptr_t fore); +intptr_t ScintillaEdit_IndicFore(const ScintillaEdit* self, intptr_t indicator); +void ScintillaEdit_IndicSetUnder(ScintillaEdit* self, intptr_t indicator, bool under); +bool ScintillaEdit_IndicUnder(const ScintillaEdit* self, intptr_t indicator); +void ScintillaEdit_IndicSetHoverStyle(ScintillaEdit* self, intptr_t indicator, intptr_t indicatorStyle); +intptr_t ScintillaEdit_IndicHoverStyle(const ScintillaEdit* self, intptr_t indicator); +void ScintillaEdit_IndicSetHoverFore(ScintillaEdit* self, intptr_t indicator, intptr_t fore); +intptr_t ScintillaEdit_IndicHoverFore(const ScintillaEdit* self, intptr_t indicator); +void ScintillaEdit_IndicSetFlags(ScintillaEdit* self, intptr_t indicator, intptr_t flags); +intptr_t ScintillaEdit_IndicFlags(const ScintillaEdit* self, intptr_t indicator); +void ScintillaEdit_IndicSetStrokeWidth(ScintillaEdit* self, intptr_t indicator, intptr_t hundredths); +intptr_t ScintillaEdit_IndicStrokeWidth(const ScintillaEdit* self, intptr_t indicator); +void ScintillaEdit_SetWhitespaceFore(ScintillaEdit* self, bool useSetting, intptr_t fore); +void ScintillaEdit_SetWhitespaceBack(ScintillaEdit* self, bool useSetting, intptr_t back); +void ScintillaEdit_SetWhitespaceSize(ScintillaEdit* self, intptr_t size); +intptr_t ScintillaEdit_WhitespaceSize(const ScintillaEdit* self); +void ScintillaEdit_SetLineState(ScintillaEdit* self, intptr_t line, intptr_t state); +intptr_t ScintillaEdit_LineState(const ScintillaEdit* self, intptr_t line); +intptr_t ScintillaEdit_MaxLineState(const ScintillaEdit* self); +bool ScintillaEdit_CaretLineVisible(const ScintillaEdit* self); +void ScintillaEdit_SetCaretLineVisible(ScintillaEdit* self, bool show); +intptr_t ScintillaEdit_CaretLineBack(const ScintillaEdit* self); +void ScintillaEdit_SetCaretLineBack(ScintillaEdit* self, intptr_t back); +intptr_t ScintillaEdit_CaretLineFrame(const ScintillaEdit* self); +void ScintillaEdit_SetCaretLineFrame(ScintillaEdit* self, intptr_t width); +void ScintillaEdit_StyleSetChangeable(ScintillaEdit* self, intptr_t style, bool changeable); +void ScintillaEdit_AutoCShow(ScintillaEdit* self, intptr_t lengthEntered, const char* itemList); +void ScintillaEdit_AutoCCancel(ScintillaEdit* self); +bool ScintillaEdit_AutoCActive(ScintillaEdit* self); +intptr_t ScintillaEdit_AutoCPosStart(ScintillaEdit* self); +void ScintillaEdit_AutoCComplete(ScintillaEdit* self); +void ScintillaEdit_AutoCStops(ScintillaEdit* self, const char* characterSet); +void ScintillaEdit_AutoCSetSeparator(ScintillaEdit* self, intptr_t separatorCharacter); +intptr_t ScintillaEdit_AutoCSeparator(const ScintillaEdit* self); +void ScintillaEdit_AutoCSelect(ScintillaEdit* self, const char* selectVal); +void ScintillaEdit_AutoCSetCancelAtStart(ScintillaEdit* self, bool cancel); +bool ScintillaEdit_AutoCCancelAtStart(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetFillUps(ScintillaEdit* self, const char* characterSet); +void ScintillaEdit_AutoCSetChooseSingle(ScintillaEdit* self, bool chooseSingle); +bool ScintillaEdit_AutoCChooseSingle(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetIgnoreCase(ScintillaEdit* self, bool ignoreCase); +bool ScintillaEdit_AutoCIgnoreCase(const ScintillaEdit* self); +void ScintillaEdit_UserListShow(ScintillaEdit* self, intptr_t listType, const char* itemList); +void ScintillaEdit_AutoCSetAutoHide(ScintillaEdit* self, bool autoHide); +bool ScintillaEdit_AutoCAutoHide(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetOptions(ScintillaEdit* self, intptr_t options); +intptr_t ScintillaEdit_AutoCOptions(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetDropRestOfWord(ScintillaEdit* self, bool dropRestOfWord); +bool ScintillaEdit_AutoCDropRestOfWord(const ScintillaEdit* self); +void ScintillaEdit_RegisterImage(ScintillaEdit* self, intptr_t typeVal, const char* xpmData); +void ScintillaEdit_ClearRegisteredImages(ScintillaEdit* self); +intptr_t ScintillaEdit_AutoCTypeSeparator(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetTypeSeparator(ScintillaEdit* self, intptr_t separatorCharacter); +void ScintillaEdit_AutoCSetMaxWidth(ScintillaEdit* self, intptr_t characterCount); +intptr_t ScintillaEdit_AutoCMaxWidth(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetMaxHeight(ScintillaEdit* self, intptr_t rowCount); +intptr_t ScintillaEdit_AutoCMaxHeight(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetStyle(ScintillaEdit* self, intptr_t style); +intptr_t ScintillaEdit_AutoCStyle(const ScintillaEdit* self); +void ScintillaEdit_SetIndent(ScintillaEdit* self, intptr_t indentSize); +intptr_t ScintillaEdit_Indent(const ScintillaEdit* self); +void ScintillaEdit_SetUseTabs(ScintillaEdit* self, bool useTabs); +bool ScintillaEdit_UseTabs(const ScintillaEdit* self); +void ScintillaEdit_SetLineIndentation(ScintillaEdit* self, intptr_t line, intptr_t indentation); +intptr_t ScintillaEdit_LineIndentation(const ScintillaEdit* self, intptr_t line); +intptr_t ScintillaEdit_LineIndentPosition(const ScintillaEdit* self, intptr_t line); +intptr_t ScintillaEdit_Column(const ScintillaEdit* self, intptr_t pos); +intptr_t ScintillaEdit_CountCharacters(ScintillaEdit* self, intptr_t start, intptr_t end); +intptr_t ScintillaEdit_CountCodeUnits(ScintillaEdit* self, intptr_t start, intptr_t end); +void ScintillaEdit_SetHScrollBar(ScintillaEdit* self, bool visible); +bool ScintillaEdit_HScrollBar(const ScintillaEdit* self); +void ScintillaEdit_SetIndentationGuides(ScintillaEdit* self, intptr_t indentView); +intptr_t ScintillaEdit_IndentationGuides(const ScintillaEdit* self); +void ScintillaEdit_SetHighlightGuide(ScintillaEdit* self, intptr_t column); +intptr_t ScintillaEdit_HighlightGuide(const ScintillaEdit* self); +intptr_t ScintillaEdit_LineEndPosition(const ScintillaEdit* self, intptr_t line); +intptr_t ScintillaEdit_CodePage(const ScintillaEdit* self); +intptr_t ScintillaEdit_CaretFore(const ScintillaEdit* self); +bool ScintillaEdit_ReadOnly(const ScintillaEdit* self); +void ScintillaEdit_SetCurrentPos(ScintillaEdit* self, intptr_t caret); +void ScintillaEdit_SetSelectionStart(ScintillaEdit* self, intptr_t anchor); +intptr_t ScintillaEdit_SelectionStart(const ScintillaEdit* self); +void ScintillaEdit_SetSelectionEnd(ScintillaEdit* self, intptr_t caret); +intptr_t ScintillaEdit_SelectionEnd(const ScintillaEdit* self); +void ScintillaEdit_SetEmptySelection(ScintillaEdit* self, intptr_t caret); +void ScintillaEdit_SetPrintMagnification(ScintillaEdit* self, intptr_t magnification); +intptr_t ScintillaEdit_PrintMagnification(const ScintillaEdit* self); +void ScintillaEdit_SetPrintColourMode(ScintillaEdit* self, intptr_t mode); +intptr_t ScintillaEdit_PrintColourMode(const ScintillaEdit* self); +void ScintillaEdit_SetChangeHistory(ScintillaEdit* self, intptr_t changeHistory); +intptr_t ScintillaEdit_ChangeHistory(const ScintillaEdit* self); +intptr_t ScintillaEdit_FirstVisibleLine(const ScintillaEdit* self); +struct miqt_string ScintillaEdit_GetLine(ScintillaEdit* self, intptr_t line); +intptr_t ScintillaEdit_LineCount(const ScintillaEdit* self); +void ScintillaEdit_AllocateLines(ScintillaEdit* self, intptr_t lines); +void ScintillaEdit_SetMarginLeft(ScintillaEdit* self, intptr_t pixelWidth); +intptr_t ScintillaEdit_MarginLeft(const ScintillaEdit* self); +void ScintillaEdit_SetMarginRight(ScintillaEdit* self, intptr_t pixelWidth); +intptr_t ScintillaEdit_MarginRight(const ScintillaEdit* self); +bool ScintillaEdit_Modify(const ScintillaEdit* self); +void ScintillaEdit_SetSel(ScintillaEdit* self, intptr_t anchor, intptr_t caret); +struct miqt_string ScintillaEdit_GetSelText(ScintillaEdit* self); +void ScintillaEdit_HideSelection(ScintillaEdit* self, bool hide); +bool ScintillaEdit_SelectionHidden(const ScintillaEdit* self); +intptr_t ScintillaEdit_PointXFromPosition(ScintillaEdit* self, intptr_t pos); +intptr_t ScintillaEdit_PointYFromPosition(ScintillaEdit* self, intptr_t pos); +intptr_t ScintillaEdit_LineFromPosition(ScintillaEdit* self, intptr_t pos); +intptr_t ScintillaEdit_PositionFromLine(ScintillaEdit* self, intptr_t line); +void ScintillaEdit_LineScroll(ScintillaEdit* self, intptr_t columns, intptr_t lines); +void ScintillaEdit_ScrollCaret(ScintillaEdit* self); +void ScintillaEdit_ScrollRange(ScintillaEdit* self, intptr_t secondary, intptr_t primary); +void ScintillaEdit_ReplaceSel(ScintillaEdit* self, const char* text); +void ScintillaEdit_SetReadOnly(ScintillaEdit* self, bool readOnly); +void ScintillaEdit_Null(ScintillaEdit* self); +bool ScintillaEdit_CanPaste(ScintillaEdit* self); +bool ScintillaEdit_CanUndo(ScintillaEdit* self); +void ScintillaEdit_EmptyUndoBuffer(ScintillaEdit* self); +void ScintillaEdit_Undo(ScintillaEdit* self); +void ScintillaEdit_Cut(ScintillaEdit* self); +void ScintillaEdit_Copy(ScintillaEdit* self); +void ScintillaEdit_Paste(ScintillaEdit* self); +void ScintillaEdit_Clear(ScintillaEdit* self); +void ScintillaEdit_SetText(ScintillaEdit* self, const char* text); +struct miqt_string ScintillaEdit_GetText(ScintillaEdit* self, intptr_t length); +intptr_t ScintillaEdit_TextLength(const ScintillaEdit* self); +intptr_t ScintillaEdit_DirectFunction(const ScintillaEdit* self); +intptr_t ScintillaEdit_DirectStatusFunction(const ScintillaEdit* self); +intptr_t ScintillaEdit_DirectPointer(const ScintillaEdit* self); +void ScintillaEdit_SetOvertype(ScintillaEdit* self, bool overType); +bool ScintillaEdit_Overtype(const ScintillaEdit* self); +void ScintillaEdit_SetCaretWidth(ScintillaEdit* self, intptr_t pixelWidth); +intptr_t ScintillaEdit_CaretWidth(const ScintillaEdit* self); +void ScintillaEdit_SetTargetStart(ScintillaEdit* self, intptr_t start); +intptr_t ScintillaEdit_TargetStart(const ScintillaEdit* self); +void ScintillaEdit_SetTargetStartVirtualSpace(ScintillaEdit* self, intptr_t space); +intptr_t ScintillaEdit_TargetStartVirtualSpace(const ScintillaEdit* self); +void ScintillaEdit_SetTargetEnd(ScintillaEdit* self, intptr_t end); +intptr_t ScintillaEdit_TargetEnd(const ScintillaEdit* self); +void ScintillaEdit_SetTargetEndVirtualSpace(ScintillaEdit* self, intptr_t space); +intptr_t ScintillaEdit_TargetEndVirtualSpace(const ScintillaEdit* self); +void ScintillaEdit_SetTargetRange(ScintillaEdit* self, intptr_t start, intptr_t end); +struct miqt_string ScintillaEdit_TargetText(const ScintillaEdit* self); +void ScintillaEdit_TargetFromSelection(ScintillaEdit* self); +void ScintillaEdit_TargetWholeDocument(ScintillaEdit* self); +intptr_t ScintillaEdit_ReplaceTarget(ScintillaEdit* self, intptr_t length, const char* text); +intptr_t ScintillaEdit_ReplaceTargetRE(ScintillaEdit* self, intptr_t length, const char* text); +intptr_t ScintillaEdit_ReplaceTargetMinimal(ScintillaEdit* self, intptr_t length, const char* text); +intptr_t ScintillaEdit_SearchInTarget(ScintillaEdit* self, intptr_t length, const char* text); +void ScintillaEdit_SetSearchFlags(ScintillaEdit* self, intptr_t searchFlags); +intptr_t ScintillaEdit_SearchFlags(const ScintillaEdit* self); +void ScintillaEdit_CallTipShow(ScintillaEdit* self, intptr_t pos, const char* definition); +void ScintillaEdit_CallTipCancel(ScintillaEdit* self); +bool ScintillaEdit_CallTipActive(ScintillaEdit* self); +intptr_t ScintillaEdit_CallTipPosStart(ScintillaEdit* self); +void ScintillaEdit_CallTipSetPosStart(ScintillaEdit* self, intptr_t posStart); +void ScintillaEdit_CallTipSetHlt(ScintillaEdit* self, intptr_t highlightStart, intptr_t highlightEnd); +void ScintillaEdit_CallTipSetBack(ScintillaEdit* self, intptr_t back); +void ScintillaEdit_CallTipSetFore(ScintillaEdit* self, intptr_t fore); +void ScintillaEdit_CallTipSetForeHlt(ScintillaEdit* self, intptr_t fore); +void ScintillaEdit_CallTipUseStyle(ScintillaEdit* self, intptr_t tabSize); +void ScintillaEdit_CallTipSetPosition(ScintillaEdit* self, bool above); +intptr_t ScintillaEdit_VisibleFromDocLine(ScintillaEdit* self, intptr_t docLine); +intptr_t ScintillaEdit_DocLineFromVisible(ScintillaEdit* self, intptr_t displayLine); +intptr_t ScintillaEdit_WrapCount(ScintillaEdit* self, intptr_t docLine); +void ScintillaEdit_SetFoldLevel(ScintillaEdit* self, intptr_t line, intptr_t level); +intptr_t ScintillaEdit_FoldLevel(const ScintillaEdit* self, intptr_t line); +intptr_t ScintillaEdit_LastChild(const ScintillaEdit* self, intptr_t line, intptr_t level); +intptr_t ScintillaEdit_FoldParent(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_ShowLines(ScintillaEdit* self, intptr_t lineStart, intptr_t lineEnd); +void ScintillaEdit_HideLines(ScintillaEdit* self, intptr_t lineStart, intptr_t lineEnd); +bool ScintillaEdit_LineVisible(const ScintillaEdit* self, intptr_t line); +bool ScintillaEdit_AllLinesVisible(const ScintillaEdit* self); +void ScintillaEdit_SetFoldExpanded(ScintillaEdit* self, intptr_t line, bool expanded); +bool ScintillaEdit_FoldExpanded(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_ToggleFold(ScintillaEdit* self, intptr_t line); +void ScintillaEdit_ToggleFoldShowText(ScintillaEdit* self, intptr_t line, const char* text); +void ScintillaEdit_FoldDisplayTextSetStyle(ScintillaEdit* self, intptr_t style); +intptr_t ScintillaEdit_FoldDisplayTextStyle(const ScintillaEdit* self); +void ScintillaEdit_SetDefaultFoldDisplayText(ScintillaEdit* self, const char* text); +struct miqt_string ScintillaEdit_GetDefaultFoldDisplayText(ScintillaEdit* self); +void ScintillaEdit_FoldLine(ScintillaEdit* self, intptr_t line, intptr_t action); +void ScintillaEdit_FoldChildren(ScintillaEdit* self, intptr_t line, intptr_t action); +void ScintillaEdit_ExpandChildren(ScintillaEdit* self, intptr_t line, intptr_t level); +void ScintillaEdit_FoldAll(ScintillaEdit* self, intptr_t action); +void ScintillaEdit_EnsureVisible(ScintillaEdit* self, intptr_t line); +void ScintillaEdit_SetAutomaticFold(ScintillaEdit* self, intptr_t automaticFold); +intptr_t ScintillaEdit_AutomaticFold(const ScintillaEdit* self); +void ScintillaEdit_SetFoldFlags(ScintillaEdit* self, intptr_t flags); +void ScintillaEdit_EnsureVisibleEnforcePolicy(ScintillaEdit* self, intptr_t line); +void ScintillaEdit_SetTabIndents(ScintillaEdit* self, bool tabIndents); +bool ScintillaEdit_TabIndents(const ScintillaEdit* self); +void ScintillaEdit_SetBackSpaceUnIndents(ScintillaEdit* self, bool bsUnIndents); +bool ScintillaEdit_BackSpaceUnIndents(const ScintillaEdit* self); +void ScintillaEdit_SetMouseDwellTime(ScintillaEdit* self, intptr_t periodMilliseconds); +intptr_t ScintillaEdit_MouseDwellTime(const ScintillaEdit* self); +intptr_t ScintillaEdit_WordStartPosition(ScintillaEdit* self, intptr_t pos, bool onlyWordCharacters); +intptr_t ScintillaEdit_WordEndPosition(ScintillaEdit* self, intptr_t pos, bool onlyWordCharacters); +bool ScintillaEdit_IsRangeWord(ScintillaEdit* self, intptr_t start, intptr_t end); +void ScintillaEdit_SetIdleStyling(ScintillaEdit* self, intptr_t idleStyling); +intptr_t ScintillaEdit_IdleStyling(const ScintillaEdit* self); +void ScintillaEdit_SetWrapMode(ScintillaEdit* self, intptr_t wrapMode); +intptr_t ScintillaEdit_WrapMode(const ScintillaEdit* self); +void ScintillaEdit_SetWrapVisualFlags(ScintillaEdit* self, intptr_t wrapVisualFlags); +intptr_t ScintillaEdit_WrapVisualFlags(const ScintillaEdit* self); +void ScintillaEdit_SetWrapVisualFlagsLocation(ScintillaEdit* self, intptr_t wrapVisualFlagsLocation); +intptr_t ScintillaEdit_WrapVisualFlagsLocation(const ScintillaEdit* self); +void ScintillaEdit_SetWrapStartIndent(ScintillaEdit* self, intptr_t indent); +intptr_t ScintillaEdit_WrapStartIndent(const ScintillaEdit* self); +void ScintillaEdit_SetWrapIndentMode(ScintillaEdit* self, intptr_t wrapIndentMode); +intptr_t ScintillaEdit_WrapIndentMode(const ScintillaEdit* self); +void ScintillaEdit_SetLayoutCache(ScintillaEdit* self, intptr_t cacheMode); +intptr_t ScintillaEdit_LayoutCache(const ScintillaEdit* self); +void ScintillaEdit_SetScrollWidth(ScintillaEdit* self, intptr_t pixelWidth); +intptr_t ScintillaEdit_ScrollWidth(const ScintillaEdit* self); +void ScintillaEdit_SetScrollWidthTracking(ScintillaEdit* self, bool tracking); +bool ScintillaEdit_ScrollWidthTracking(const ScintillaEdit* self); +intptr_t ScintillaEdit_TextWidth(ScintillaEdit* self, intptr_t style, const char* text); +void ScintillaEdit_SetEndAtLastLine(ScintillaEdit* self, bool endAtLastLine); +bool ScintillaEdit_EndAtLastLine(const ScintillaEdit* self); +intptr_t ScintillaEdit_TextHeight(ScintillaEdit* self, intptr_t line); +void ScintillaEdit_SetVScrollBar(ScintillaEdit* self, bool visible); +bool ScintillaEdit_VScrollBar(const ScintillaEdit* self); +void ScintillaEdit_AppendText(ScintillaEdit* self, intptr_t length, const char* text); +intptr_t ScintillaEdit_PhasesDraw(const ScintillaEdit* self); +void ScintillaEdit_SetPhasesDraw(ScintillaEdit* self, intptr_t phases); +void ScintillaEdit_SetFontQuality(ScintillaEdit* self, intptr_t fontQuality); +intptr_t ScintillaEdit_FontQuality(const ScintillaEdit* self); +void ScintillaEdit_SetFirstVisibleLine(ScintillaEdit* self, intptr_t displayLine); +void ScintillaEdit_SetMultiPaste(ScintillaEdit* self, intptr_t multiPaste); +intptr_t ScintillaEdit_MultiPaste(const ScintillaEdit* self); +struct miqt_string ScintillaEdit_Tag(const ScintillaEdit* self, intptr_t tagNumber); +void ScintillaEdit_LinesJoin(ScintillaEdit* self); +void ScintillaEdit_LinesSplit(ScintillaEdit* self, intptr_t pixelWidth); +void ScintillaEdit_SetFoldMarginColour(ScintillaEdit* self, bool useSetting, intptr_t back); +void ScintillaEdit_SetFoldMarginHiColour(ScintillaEdit* self, bool useSetting, intptr_t fore); +void ScintillaEdit_SetAccessibility(ScintillaEdit* self, intptr_t accessibility); +intptr_t ScintillaEdit_Accessibility(const ScintillaEdit* self); +void ScintillaEdit_LineDown(ScintillaEdit* self); +void ScintillaEdit_LineDownExtend(ScintillaEdit* self); +void ScintillaEdit_LineUp(ScintillaEdit* self); +void ScintillaEdit_LineUpExtend(ScintillaEdit* self); +void ScintillaEdit_CharLeft(ScintillaEdit* self); +void ScintillaEdit_CharLeftExtend(ScintillaEdit* self); +void ScintillaEdit_CharRight(ScintillaEdit* self); +void ScintillaEdit_CharRightExtend(ScintillaEdit* self); +void ScintillaEdit_WordLeft(ScintillaEdit* self); +void ScintillaEdit_WordLeftExtend(ScintillaEdit* self); +void ScintillaEdit_WordRight(ScintillaEdit* self); +void ScintillaEdit_WordRightExtend(ScintillaEdit* self); +void ScintillaEdit_Home(ScintillaEdit* self); +void ScintillaEdit_HomeExtend(ScintillaEdit* self); +void ScintillaEdit_LineEnd(ScintillaEdit* self); +void ScintillaEdit_LineEndExtend(ScintillaEdit* self); +void ScintillaEdit_DocumentStart(ScintillaEdit* self); +void ScintillaEdit_DocumentStartExtend(ScintillaEdit* self); +void ScintillaEdit_DocumentEnd(ScintillaEdit* self); +void ScintillaEdit_DocumentEndExtend(ScintillaEdit* self); +void ScintillaEdit_PageUp(ScintillaEdit* self); +void ScintillaEdit_PageUpExtend(ScintillaEdit* self); +void ScintillaEdit_PageDown(ScintillaEdit* self); +void ScintillaEdit_PageDownExtend(ScintillaEdit* self); +void ScintillaEdit_EditToggleOvertype(ScintillaEdit* self); +void ScintillaEdit_Cancel(ScintillaEdit* self); +void ScintillaEdit_DeleteBack(ScintillaEdit* self); +void ScintillaEdit_Tab(ScintillaEdit* self); +void ScintillaEdit_LineIndent(ScintillaEdit* self); +void ScintillaEdit_BackTab(ScintillaEdit* self); +void ScintillaEdit_LineDedent(ScintillaEdit* self); +void ScintillaEdit_NewLine(ScintillaEdit* self); +void ScintillaEdit_FormFeed(ScintillaEdit* self); +void ScintillaEdit_VCHome(ScintillaEdit* self); +void ScintillaEdit_VCHomeExtend(ScintillaEdit* self); +void ScintillaEdit_ZoomIn(ScintillaEdit* self); +void ScintillaEdit_ZoomOut(ScintillaEdit* self); +void ScintillaEdit_DelWordLeft(ScintillaEdit* self); +void ScintillaEdit_DelWordRight(ScintillaEdit* self); +void ScintillaEdit_DelWordRightEnd(ScintillaEdit* self); +void ScintillaEdit_LineCut(ScintillaEdit* self); +void ScintillaEdit_LineDelete(ScintillaEdit* self); +void ScintillaEdit_LineTranspose(ScintillaEdit* self); +void ScintillaEdit_LineReverse(ScintillaEdit* self); +void ScintillaEdit_LineDuplicate(ScintillaEdit* self); +void ScintillaEdit_LowerCase(ScintillaEdit* self); +void ScintillaEdit_UpperCase(ScintillaEdit* self); +void ScintillaEdit_LineScrollDown(ScintillaEdit* self); +void ScintillaEdit_LineScrollUp(ScintillaEdit* self); +void ScintillaEdit_DeleteBackNotLine(ScintillaEdit* self); +void ScintillaEdit_HomeDisplay(ScintillaEdit* self); +void ScintillaEdit_HomeDisplayExtend(ScintillaEdit* self); +void ScintillaEdit_LineEndDisplay(ScintillaEdit* self); +void ScintillaEdit_LineEndDisplayExtend(ScintillaEdit* self); +void ScintillaEdit_HomeWrap(ScintillaEdit* self); +void ScintillaEdit_HomeWrapExtend(ScintillaEdit* self); +void ScintillaEdit_LineEndWrap(ScintillaEdit* self); +void ScintillaEdit_LineEndWrapExtend(ScintillaEdit* self); +void ScintillaEdit_VCHomeWrap(ScintillaEdit* self); +void ScintillaEdit_VCHomeWrapExtend(ScintillaEdit* self); +void ScintillaEdit_LineCopy(ScintillaEdit* self); +void ScintillaEdit_MoveCaretInsideView(ScintillaEdit* self); +intptr_t ScintillaEdit_LineLength(ScintillaEdit* self, intptr_t line); +void ScintillaEdit_BraceHighlight(ScintillaEdit* self, intptr_t posA, intptr_t posB); +void ScintillaEdit_BraceHighlightIndicator(ScintillaEdit* self, bool useSetting, intptr_t indicator); +void ScintillaEdit_BraceBadLight(ScintillaEdit* self, intptr_t pos); +void ScintillaEdit_BraceBadLightIndicator(ScintillaEdit* self, bool useSetting, intptr_t indicator); +intptr_t ScintillaEdit_BraceMatch(ScintillaEdit* self, intptr_t pos, intptr_t maxReStyle); +intptr_t ScintillaEdit_BraceMatchNext(ScintillaEdit* self, intptr_t pos, intptr_t startPos); +bool ScintillaEdit_ViewEOL(const ScintillaEdit* self); +void ScintillaEdit_SetViewEOL(ScintillaEdit* self, bool visible); +intptr_t ScintillaEdit_DocPointer(const ScintillaEdit* self); +void ScintillaEdit_SetDocPointer(ScintillaEdit* self, intptr_t doc); +void ScintillaEdit_SetModEventMask(ScintillaEdit* self, intptr_t eventMask); +intptr_t ScintillaEdit_EdgeColumn(const ScintillaEdit* self); +void ScintillaEdit_SetEdgeColumn(ScintillaEdit* self, intptr_t column); +intptr_t ScintillaEdit_EdgeMode(const ScintillaEdit* self); +void ScintillaEdit_SetEdgeMode(ScintillaEdit* self, intptr_t edgeMode); +intptr_t ScintillaEdit_EdgeColour(const ScintillaEdit* self); +void ScintillaEdit_SetEdgeColour(ScintillaEdit* self, intptr_t edgeColour); +void ScintillaEdit_MultiEdgeAddLine(ScintillaEdit* self, intptr_t column, intptr_t edgeColour); +void ScintillaEdit_MultiEdgeClearAll(ScintillaEdit* self); +intptr_t ScintillaEdit_MultiEdgeColumn(const ScintillaEdit* self, intptr_t which); +void ScintillaEdit_SearchAnchor(ScintillaEdit* self); +intptr_t ScintillaEdit_SearchNext(ScintillaEdit* self, intptr_t searchFlags, const char* text); +intptr_t ScintillaEdit_SearchPrev(ScintillaEdit* self, intptr_t searchFlags, const char* text); +intptr_t ScintillaEdit_LinesOnScreen(const ScintillaEdit* self); +void ScintillaEdit_UsePopUp(ScintillaEdit* self, intptr_t popUpMode); +bool ScintillaEdit_SelectionIsRectangle(const ScintillaEdit* self); +void ScintillaEdit_SetZoom(ScintillaEdit* self, intptr_t zoomInPoints); +intptr_t ScintillaEdit_Zoom(const ScintillaEdit* self); +intptr_t ScintillaEdit_CreateDocument(ScintillaEdit* self, intptr_t bytes, intptr_t documentOptions); +void ScintillaEdit_AddRefDocument(ScintillaEdit* self, intptr_t doc); +void ScintillaEdit_ReleaseDocument(ScintillaEdit* self, intptr_t doc); +intptr_t ScintillaEdit_DocumentOptions(const ScintillaEdit* self); +intptr_t ScintillaEdit_ModEventMask(const ScintillaEdit* self); +void ScintillaEdit_SetCommandEvents(ScintillaEdit* self, bool commandEvents); +bool ScintillaEdit_CommandEvents(const ScintillaEdit* self); +void ScintillaEdit_SetFocus(ScintillaEdit* self, bool focus); +bool ScintillaEdit_Focus(const ScintillaEdit* self); +void ScintillaEdit_SetStatus(ScintillaEdit* self, intptr_t status); +intptr_t ScintillaEdit_Status(const ScintillaEdit* self); +void ScintillaEdit_SetMouseDownCaptures(ScintillaEdit* self, bool captures); +bool ScintillaEdit_MouseDownCaptures(const ScintillaEdit* self); +void ScintillaEdit_SetMouseWheelCaptures(ScintillaEdit* self, bool captures); +bool ScintillaEdit_MouseWheelCaptures(const ScintillaEdit* self); +void ScintillaEdit_SetCursor(ScintillaEdit* self, intptr_t cursorType); +intptr_t ScintillaEdit_Cursor(const ScintillaEdit* self); +void ScintillaEdit_SetControlCharSymbol(ScintillaEdit* self, intptr_t symbol); +intptr_t ScintillaEdit_ControlCharSymbol(const ScintillaEdit* self); +void ScintillaEdit_WordPartLeft(ScintillaEdit* self); +void ScintillaEdit_WordPartLeftExtend(ScintillaEdit* self); +void ScintillaEdit_WordPartRight(ScintillaEdit* self); +void ScintillaEdit_WordPartRightExtend(ScintillaEdit* self); +void ScintillaEdit_SetVisiblePolicy(ScintillaEdit* self, intptr_t visiblePolicy, intptr_t visibleSlop); +void ScintillaEdit_DelLineLeft(ScintillaEdit* self); +void ScintillaEdit_DelLineRight(ScintillaEdit* self); +void ScintillaEdit_SetXOffset(ScintillaEdit* self, intptr_t xOffset); +intptr_t ScintillaEdit_XOffset(const ScintillaEdit* self); +void ScintillaEdit_ChooseCaretX(ScintillaEdit* self); +void ScintillaEdit_GrabFocus(ScintillaEdit* self); +void ScintillaEdit_SetXCaretPolicy(ScintillaEdit* self, intptr_t caretPolicy, intptr_t caretSlop); +void ScintillaEdit_SetYCaretPolicy(ScintillaEdit* self, intptr_t caretPolicy, intptr_t caretSlop); +void ScintillaEdit_SetPrintWrapMode(ScintillaEdit* self, intptr_t wrapMode); +intptr_t ScintillaEdit_PrintWrapMode(const ScintillaEdit* self); +void ScintillaEdit_SetHotspotActiveFore(ScintillaEdit* self, bool useSetting, intptr_t fore); +intptr_t ScintillaEdit_HotspotActiveFore(const ScintillaEdit* self); +void ScintillaEdit_SetHotspotActiveBack(ScintillaEdit* self, bool useSetting, intptr_t back); +intptr_t ScintillaEdit_HotspotActiveBack(const ScintillaEdit* self); +void ScintillaEdit_SetHotspotActiveUnderline(ScintillaEdit* self, bool underline); +bool ScintillaEdit_HotspotActiveUnderline(const ScintillaEdit* self); +void ScintillaEdit_SetHotspotSingleLine(ScintillaEdit* self, bool singleLine); +bool ScintillaEdit_HotspotSingleLine(const ScintillaEdit* self); +void ScintillaEdit_ParaDown(ScintillaEdit* self); +void ScintillaEdit_ParaDownExtend(ScintillaEdit* self); +void ScintillaEdit_ParaUp(ScintillaEdit* self); +void ScintillaEdit_ParaUpExtend(ScintillaEdit* self); +intptr_t ScintillaEdit_PositionBefore(ScintillaEdit* self, intptr_t pos); +intptr_t ScintillaEdit_PositionAfter(ScintillaEdit* self, intptr_t pos); +intptr_t ScintillaEdit_PositionRelative(ScintillaEdit* self, intptr_t pos, intptr_t relative); +intptr_t ScintillaEdit_PositionRelativeCodeUnits(ScintillaEdit* self, intptr_t pos, intptr_t relative); +void ScintillaEdit_CopyRange(ScintillaEdit* self, intptr_t start, intptr_t end); +void ScintillaEdit_CopyText(ScintillaEdit* self, intptr_t length, const char* text); +void ScintillaEdit_SetSelectionMode(ScintillaEdit* self, intptr_t selectionMode); +void ScintillaEdit_ChangeSelectionMode(ScintillaEdit* self, intptr_t selectionMode); +intptr_t ScintillaEdit_SelectionMode(const ScintillaEdit* self); +void ScintillaEdit_SetMoveExtendsSelection(ScintillaEdit* self, bool moveExtendsSelection); +bool ScintillaEdit_MoveExtendsSelection(const ScintillaEdit* self); +intptr_t ScintillaEdit_GetLineSelStartPosition(ScintillaEdit* self, intptr_t line); +intptr_t ScintillaEdit_GetLineSelEndPosition(ScintillaEdit* self, intptr_t line); +void ScintillaEdit_LineDownRectExtend(ScintillaEdit* self); +void ScintillaEdit_LineUpRectExtend(ScintillaEdit* self); +void ScintillaEdit_CharLeftRectExtend(ScintillaEdit* self); +void ScintillaEdit_CharRightRectExtend(ScintillaEdit* self); +void ScintillaEdit_HomeRectExtend(ScintillaEdit* self); +void ScintillaEdit_VCHomeRectExtend(ScintillaEdit* self); +void ScintillaEdit_LineEndRectExtend(ScintillaEdit* self); +void ScintillaEdit_PageUpRectExtend(ScintillaEdit* self); +void ScintillaEdit_PageDownRectExtend(ScintillaEdit* self); +void ScintillaEdit_StutteredPageUp(ScintillaEdit* self); +void ScintillaEdit_StutteredPageUpExtend(ScintillaEdit* self); +void ScintillaEdit_StutteredPageDown(ScintillaEdit* self); +void ScintillaEdit_StutteredPageDownExtend(ScintillaEdit* self); +void ScintillaEdit_WordLeftEnd(ScintillaEdit* self); +void ScintillaEdit_WordLeftEndExtend(ScintillaEdit* self); +void ScintillaEdit_WordRightEnd(ScintillaEdit* self); +void ScintillaEdit_WordRightEndExtend(ScintillaEdit* self); +void ScintillaEdit_SetWhitespaceChars(ScintillaEdit* self, const char* characters); +struct miqt_string ScintillaEdit_WhitespaceChars(const ScintillaEdit* self); +void ScintillaEdit_SetPunctuationChars(ScintillaEdit* self, const char* characters); +struct miqt_string ScintillaEdit_PunctuationChars(const ScintillaEdit* self); +void ScintillaEdit_SetCharsDefault(ScintillaEdit* self); +intptr_t ScintillaEdit_AutoCCurrent(const ScintillaEdit* self); +struct miqt_string ScintillaEdit_AutoCCurrentText(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetCaseInsensitiveBehaviour(ScintillaEdit* self, intptr_t behaviour); +intptr_t ScintillaEdit_AutoCCaseInsensitiveBehaviour(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetMulti(ScintillaEdit* self, intptr_t multi); +intptr_t ScintillaEdit_AutoCMulti(const ScintillaEdit* self); +void ScintillaEdit_AutoCSetOrder(ScintillaEdit* self, intptr_t order); +intptr_t ScintillaEdit_AutoCOrder(const ScintillaEdit* self); +void ScintillaEdit_Allocate(ScintillaEdit* self, intptr_t bytes); +struct miqt_string ScintillaEdit_TargetAsUTF8(ScintillaEdit* self); +void ScintillaEdit_SetLengthForEncode(ScintillaEdit* self, intptr_t bytes); +struct miqt_string ScintillaEdit_EncodedFromUTF8(ScintillaEdit* self, const char* utf8); +intptr_t ScintillaEdit_FindColumn(ScintillaEdit* self, intptr_t line, intptr_t column); +intptr_t ScintillaEdit_CaretSticky(const ScintillaEdit* self); +void ScintillaEdit_SetCaretSticky(ScintillaEdit* self, intptr_t useCaretStickyBehaviour); +void ScintillaEdit_ToggleCaretSticky(ScintillaEdit* self); +void ScintillaEdit_SetPasteConvertEndings(ScintillaEdit* self, bool convert); +bool ScintillaEdit_PasteConvertEndings(const ScintillaEdit* self); +void ScintillaEdit_ReplaceRectangular(ScintillaEdit* self, intptr_t length, const char* text); +void ScintillaEdit_SelectionDuplicate(ScintillaEdit* self); +void ScintillaEdit_SetCaretLineBackAlpha(ScintillaEdit* self, intptr_t alpha); +intptr_t ScintillaEdit_CaretLineBackAlpha(const ScintillaEdit* self); +void ScintillaEdit_SetCaretStyle(ScintillaEdit* self, intptr_t caretStyle); +intptr_t ScintillaEdit_CaretStyle(const ScintillaEdit* self); +void ScintillaEdit_SetIndicatorCurrent(ScintillaEdit* self, intptr_t indicator); +intptr_t ScintillaEdit_IndicatorCurrent(const ScintillaEdit* self); +void ScintillaEdit_SetIndicatorValue(ScintillaEdit* self, intptr_t value); +intptr_t ScintillaEdit_IndicatorValue(const ScintillaEdit* self); +void ScintillaEdit_IndicatorFillRange(ScintillaEdit* self, intptr_t start, intptr_t lengthFill); +void ScintillaEdit_IndicatorClearRange(ScintillaEdit* self, intptr_t start, intptr_t lengthClear); +intptr_t ScintillaEdit_IndicatorAllOnFor(ScintillaEdit* self, intptr_t pos); +intptr_t ScintillaEdit_IndicatorValueAt(ScintillaEdit* self, intptr_t indicator, intptr_t pos); +intptr_t ScintillaEdit_IndicatorStart(ScintillaEdit* self, intptr_t indicator, intptr_t pos); +intptr_t ScintillaEdit_IndicatorEnd(ScintillaEdit* self, intptr_t indicator, intptr_t pos); +void ScintillaEdit_SetPositionCache(ScintillaEdit* self, intptr_t size); +intptr_t ScintillaEdit_PositionCache(const ScintillaEdit* self); +void ScintillaEdit_SetLayoutThreads(ScintillaEdit* self, intptr_t threads); +intptr_t ScintillaEdit_LayoutThreads(const ScintillaEdit* self); +void ScintillaEdit_CopyAllowLine(ScintillaEdit* self); +void ScintillaEdit_CutAllowLine(ScintillaEdit* self); +void ScintillaEdit_SetCopySeparator(ScintillaEdit* self, const char* separator); +struct miqt_string ScintillaEdit_CopySeparator(const ScintillaEdit* self); +intptr_t ScintillaEdit_CharacterPointer(const ScintillaEdit* self); +intptr_t ScintillaEdit_RangePointer(const ScintillaEdit* self, intptr_t start, intptr_t lengthRange); +intptr_t ScintillaEdit_GapPosition(const ScintillaEdit* self); +void ScintillaEdit_IndicSetAlpha(ScintillaEdit* self, intptr_t indicator, intptr_t alpha); +intptr_t ScintillaEdit_IndicAlpha(const ScintillaEdit* self, intptr_t indicator); +void ScintillaEdit_IndicSetOutlineAlpha(ScintillaEdit* self, intptr_t indicator, intptr_t alpha); +intptr_t ScintillaEdit_IndicOutlineAlpha(const ScintillaEdit* self, intptr_t indicator); +void ScintillaEdit_SetExtraAscent(ScintillaEdit* self, intptr_t extraAscent); +intptr_t ScintillaEdit_ExtraAscent(const ScintillaEdit* self); +void ScintillaEdit_SetExtraDescent(ScintillaEdit* self, intptr_t extraDescent); +intptr_t ScintillaEdit_ExtraDescent(const ScintillaEdit* self); +intptr_t ScintillaEdit_MarkerSymbolDefined(ScintillaEdit* self, intptr_t markerNumber); +void ScintillaEdit_MarginSetText(ScintillaEdit* self, intptr_t line, const char* text); +struct miqt_string ScintillaEdit_MarginText(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_MarginSetStyle(ScintillaEdit* self, intptr_t line, intptr_t style); +intptr_t ScintillaEdit_MarginStyle(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_MarginSetStyles(ScintillaEdit* self, intptr_t line, const char* styles); +struct miqt_string ScintillaEdit_MarginStyles(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_MarginTextClearAll(ScintillaEdit* self); +void ScintillaEdit_MarginSetStyleOffset(ScintillaEdit* self, intptr_t style); +intptr_t ScintillaEdit_MarginStyleOffset(const ScintillaEdit* self); +void ScintillaEdit_SetMarginOptions(ScintillaEdit* self, intptr_t marginOptions); +intptr_t ScintillaEdit_MarginOptions(const ScintillaEdit* self); +void ScintillaEdit_AnnotationSetText(ScintillaEdit* self, intptr_t line, const char* text); +struct miqt_string ScintillaEdit_AnnotationText(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_AnnotationSetStyle(ScintillaEdit* self, intptr_t line, intptr_t style); +intptr_t ScintillaEdit_AnnotationStyle(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_AnnotationSetStyles(ScintillaEdit* self, intptr_t line, const char* styles); +struct miqt_string ScintillaEdit_AnnotationStyles(const ScintillaEdit* self, intptr_t line); +intptr_t ScintillaEdit_AnnotationLines(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_AnnotationClearAll(ScintillaEdit* self); +void ScintillaEdit_AnnotationSetVisible(ScintillaEdit* self, intptr_t visible); +intptr_t ScintillaEdit_AnnotationVisible(const ScintillaEdit* self); +void ScintillaEdit_AnnotationSetStyleOffset(ScintillaEdit* self, intptr_t style); +intptr_t ScintillaEdit_AnnotationStyleOffset(const ScintillaEdit* self); +void ScintillaEdit_ReleaseAllExtendedStyles(ScintillaEdit* self); +intptr_t ScintillaEdit_AllocateExtendedStyles(ScintillaEdit* self, intptr_t numberStyles); +void ScintillaEdit_AddUndoAction(ScintillaEdit* self, intptr_t token, intptr_t flags); +intptr_t ScintillaEdit_CharPositionFromPoint(ScintillaEdit* self, intptr_t x, intptr_t y); +intptr_t ScintillaEdit_CharPositionFromPointClose(ScintillaEdit* self, intptr_t x, intptr_t y); +void ScintillaEdit_SetMouseSelectionRectangularSwitch(ScintillaEdit* self, bool mouseSelectionRectangularSwitch); +bool ScintillaEdit_MouseSelectionRectangularSwitch(const ScintillaEdit* self); +void ScintillaEdit_SetMultipleSelection(ScintillaEdit* self, bool multipleSelection); +bool ScintillaEdit_MultipleSelection(const ScintillaEdit* self); +void ScintillaEdit_SetAdditionalSelectionTyping(ScintillaEdit* self, bool additionalSelectionTyping); +bool ScintillaEdit_AdditionalSelectionTyping(const ScintillaEdit* self); +void ScintillaEdit_SetAdditionalCaretsBlink(ScintillaEdit* self, bool additionalCaretsBlink); +bool ScintillaEdit_AdditionalCaretsBlink(const ScintillaEdit* self); +void ScintillaEdit_SetAdditionalCaretsVisible(ScintillaEdit* self, bool additionalCaretsVisible); +bool ScintillaEdit_AdditionalCaretsVisible(const ScintillaEdit* self); +intptr_t ScintillaEdit_Selections(const ScintillaEdit* self); +bool ScintillaEdit_SelectionEmpty(const ScintillaEdit* self); +void ScintillaEdit_ClearSelections(ScintillaEdit* self); +void ScintillaEdit_SetSelection(ScintillaEdit* self, intptr_t caret, intptr_t anchor); +void ScintillaEdit_AddSelection(ScintillaEdit* self, intptr_t caret, intptr_t anchor); +intptr_t ScintillaEdit_SelectionFromPoint(ScintillaEdit* self, intptr_t x, intptr_t y); +void ScintillaEdit_DropSelectionN(ScintillaEdit* self, intptr_t selection); +void ScintillaEdit_SetMainSelection(ScintillaEdit* self, intptr_t selection); +intptr_t ScintillaEdit_MainSelection(const ScintillaEdit* self); +void ScintillaEdit_SetSelectionNCaret(ScintillaEdit* self, intptr_t selection, intptr_t caret); +intptr_t ScintillaEdit_SelectionNCaret(const ScintillaEdit* self, intptr_t selection); +void ScintillaEdit_SetSelectionNAnchor(ScintillaEdit* self, intptr_t selection, intptr_t anchor); +intptr_t ScintillaEdit_SelectionNAnchor(const ScintillaEdit* self, intptr_t selection); +void ScintillaEdit_SetSelectionNCaretVirtualSpace(ScintillaEdit* self, intptr_t selection, intptr_t space); +intptr_t ScintillaEdit_SelectionNCaretVirtualSpace(const ScintillaEdit* self, intptr_t selection); +void ScintillaEdit_SetSelectionNAnchorVirtualSpace(ScintillaEdit* self, intptr_t selection, intptr_t space); +intptr_t ScintillaEdit_SelectionNAnchorVirtualSpace(const ScintillaEdit* self, intptr_t selection); +void ScintillaEdit_SetSelectionNStart(ScintillaEdit* self, intptr_t selection, intptr_t anchor); +intptr_t ScintillaEdit_SelectionNStart(const ScintillaEdit* self, intptr_t selection); +intptr_t ScintillaEdit_SelectionNStartVirtualSpace(const ScintillaEdit* self, intptr_t selection); +void ScintillaEdit_SetSelectionNEnd(ScintillaEdit* self, intptr_t selection, intptr_t caret); +intptr_t ScintillaEdit_SelectionNEndVirtualSpace(const ScintillaEdit* self, intptr_t selection); +intptr_t ScintillaEdit_SelectionNEnd(const ScintillaEdit* self, intptr_t selection); +void ScintillaEdit_SetRectangularSelectionCaret(ScintillaEdit* self, intptr_t caret); +intptr_t ScintillaEdit_RectangularSelectionCaret(const ScintillaEdit* self); +void ScintillaEdit_SetRectangularSelectionAnchor(ScintillaEdit* self, intptr_t anchor); +intptr_t ScintillaEdit_RectangularSelectionAnchor(const ScintillaEdit* self); +void ScintillaEdit_SetRectangularSelectionCaretVirtualSpace(ScintillaEdit* self, intptr_t space); +intptr_t ScintillaEdit_RectangularSelectionCaretVirtualSpace(const ScintillaEdit* self); +void ScintillaEdit_SetRectangularSelectionAnchorVirtualSpace(ScintillaEdit* self, intptr_t space); +intptr_t ScintillaEdit_RectangularSelectionAnchorVirtualSpace(const ScintillaEdit* self); +void ScintillaEdit_SetVirtualSpaceOptions(ScintillaEdit* self, intptr_t virtualSpaceOptions); +intptr_t ScintillaEdit_VirtualSpaceOptions(const ScintillaEdit* self); +void ScintillaEdit_SetRectangularSelectionModifier(ScintillaEdit* self, intptr_t modifier); +intptr_t ScintillaEdit_RectangularSelectionModifier(const ScintillaEdit* self); +void ScintillaEdit_SetAdditionalSelFore(ScintillaEdit* self, intptr_t fore); +void ScintillaEdit_SetAdditionalSelBack(ScintillaEdit* self, intptr_t back); +void ScintillaEdit_SetAdditionalSelAlpha(ScintillaEdit* self, intptr_t alpha); +intptr_t ScintillaEdit_AdditionalSelAlpha(const ScintillaEdit* self); +void ScintillaEdit_SetAdditionalCaretFore(ScintillaEdit* self, intptr_t fore); +intptr_t ScintillaEdit_AdditionalCaretFore(const ScintillaEdit* self); +void ScintillaEdit_RotateSelection(ScintillaEdit* self); +void ScintillaEdit_SwapMainAnchorCaret(ScintillaEdit* self); +void ScintillaEdit_MultipleSelectAddNext(ScintillaEdit* self); +void ScintillaEdit_MultipleSelectAddEach(ScintillaEdit* self); +intptr_t ScintillaEdit_ChangeLexerState(ScintillaEdit* self, intptr_t start, intptr_t end); +intptr_t ScintillaEdit_ContractedFoldNext(ScintillaEdit* self, intptr_t lineStart); +void ScintillaEdit_VerticalCentreCaret(ScintillaEdit* self); +void ScintillaEdit_MoveSelectedLinesUp(ScintillaEdit* self); +void ScintillaEdit_MoveSelectedLinesDown(ScintillaEdit* self); +void ScintillaEdit_SetIdentifier(ScintillaEdit* self, intptr_t identifier); +intptr_t ScintillaEdit_Identifier(const ScintillaEdit* self); +void ScintillaEdit_RGBAImageSetWidth(ScintillaEdit* self, intptr_t width); +void ScintillaEdit_RGBAImageSetHeight(ScintillaEdit* self, intptr_t height); +void ScintillaEdit_RGBAImageSetScale(ScintillaEdit* self, intptr_t scalePercent); +void ScintillaEdit_MarkerDefineRGBAImage(ScintillaEdit* self, intptr_t markerNumber, const char* pixels); +void ScintillaEdit_RegisterRGBAImage(ScintillaEdit* self, intptr_t typeVal, const char* pixels); +void ScintillaEdit_ScrollToStart(ScintillaEdit* self); +void ScintillaEdit_ScrollToEnd(ScintillaEdit* self); +void ScintillaEdit_SetTechnology(ScintillaEdit* self, intptr_t technology); +intptr_t ScintillaEdit_Technology(const ScintillaEdit* self); +intptr_t ScintillaEdit_CreateLoader(ScintillaEdit* self, intptr_t bytes, intptr_t documentOptions); +void ScintillaEdit_FindIndicatorShow(ScintillaEdit* self, intptr_t start, intptr_t end); +void ScintillaEdit_FindIndicatorFlash(ScintillaEdit* self, intptr_t start, intptr_t end); +void ScintillaEdit_FindIndicatorHide(ScintillaEdit* self); +void ScintillaEdit_VCHomeDisplay(ScintillaEdit* self); +void ScintillaEdit_VCHomeDisplayExtend(ScintillaEdit* self); +bool ScintillaEdit_CaretLineVisibleAlways(const ScintillaEdit* self); +void ScintillaEdit_SetCaretLineVisibleAlways(ScintillaEdit* self, bool alwaysVisible); +void ScintillaEdit_SetLineEndTypesAllowed(ScintillaEdit* self, intptr_t lineEndBitSet); +intptr_t ScintillaEdit_LineEndTypesAllowed(const ScintillaEdit* self); +intptr_t ScintillaEdit_LineEndTypesActive(const ScintillaEdit* self); +void ScintillaEdit_SetRepresentation(ScintillaEdit* self, const char* encodedCharacter, const char* representation); +struct miqt_string ScintillaEdit_Representation(const ScintillaEdit* self, const char* encodedCharacter); +void ScintillaEdit_ClearRepresentation(ScintillaEdit* self, const char* encodedCharacter); +void ScintillaEdit_ClearAllRepresentations(ScintillaEdit* self); +void ScintillaEdit_SetRepresentationAppearance(ScintillaEdit* self, const char* encodedCharacter, intptr_t appearance); +intptr_t ScintillaEdit_RepresentationAppearance(const ScintillaEdit* self, const char* encodedCharacter); +void ScintillaEdit_SetRepresentationColour(ScintillaEdit* self, const char* encodedCharacter, intptr_t colour); +intptr_t ScintillaEdit_RepresentationColour(const ScintillaEdit* self, const char* encodedCharacter); +void ScintillaEdit_EOLAnnotationSetText(ScintillaEdit* self, intptr_t line, const char* text); +struct miqt_string ScintillaEdit_EOLAnnotationText(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_EOLAnnotationSetStyle(ScintillaEdit* self, intptr_t line, intptr_t style); +intptr_t ScintillaEdit_EOLAnnotationStyle(const ScintillaEdit* self, intptr_t line); +void ScintillaEdit_EOLAnnotationClearAll(ScintillaEdit* self); +void ScintillaEdit_EOLAnnotationSetVisible(ScintillaEdit* self, intptr_t visible); +intptr_t ScintillaEdit_EOLAnnotationVisible(const ScintillaEdit* self); +void ScintillaEdit_EOLAnnotationSetStyleOffset(ScintillaEdit* self, intptr_t style); +intptr_t ScintillaEdit_EOLAnnotationStyleOffset(const ScintillaEdit* self); +bool ScintillaEdit_SupportsFeature(const ScintillaEdit* self, intptr_t feature); +intptr_t ScintillaEdit_LineCharacterIndex(const ScintillaEdit* self); +void ScintillaEdit_AllocateLineCharacterIndex(ScintillaEdit* self, intptr_t lineCharacterIndex); +void ScintillaEdit_ReleaseLineCharacterIndex(ScintillaEdit* self, intptr_t lineCharacterIndex); +intptr_t ScintillaEdit_LineFromIndexPosition(ScintillaEdit* self, intptr_t pos, intptr_t lineCharacterIndex); +intptr_t ScintillaEdit_IndexPositionFromLine(ScintillaEdit* self, intptr_t line, intptr_t lineCharacterIndex); +void ScintillaEdit_StartRecord(ScintillaEdit* self); +void ScintillaEdit_StopRecord(ScintillaEdit* self); +intptr_t ScintillaEdit_Lexer(const ScintillaEdit* self); +void ScintillaEdit_Colourise(ScintillaEdit* self, intptr_t start, intptr_t end); +void ScintillaEdit_SetProperty(ScintillaEdit* self, const char* key, const char* value); +void ScintillaEdit_SetKeyWords(ScintillaEdit* self, intptr_t keyWordSet, const char* keyWords); +struct miqt_string ScintillaEdit_Property(const ScintillaEdit* self, const char* key); +struct miqt_string ScintillaEdit_PropertyExpanded(const ScintillaEdit* self, const char* key); +intptr_t ScintillaEdit_PropertyInt(const ScintillaEdit* self, const char* key, intptr_t defaultValue); +struct miqt_string ScintillaEdit_LexerLanguage(const ScintillaEdit* self); +intptr_t ScintillaEdit_PrivateLexerCall(ScintillaEdit* self, intptr_t operation, intptr_t pointer); +struct miqt_string ScintillaEdit_PropertyNames(ScintillaEdit* self); +intptr_t ScintillaEdit_PropertyType(ScintillaEdit* self, const char* name); +struct miqt_string ScintillaEdit_DescribeProperty(ScintillaEdit* self, const char* name); +struct miqt_string ScintillaEdit_DescribeKeyWordSets(ScintillaEdit* self); +intptr_t ScintillaEdit_LineEndTypesSupported(const ScintillaEdit* self); +intptr_t ScintillaEdit_AllocateSubStyles(ScintillaEdit* self, intptr_t styleBase, intptr_t numberStyles); +intptr_t ScintillaEdit_SubStylesStart(const ScintillaEdit* self, intptr_t styleBase); +intptr_t ScintillaEdit_SubStylesLength(const ScintillaEdit* self, intptr_t styleBase); +intptr_t ScintillaEdit_StyleFromSubStyle(const ScintillaEdit* self, intptr_t subStyle); +intptr_t ScintillaEdit_PrimaryStyleFromStyle(const ScintillaEdit* self, intptr_t style); +void ScintillaEdit_FreeSubStyles(ScintillaEdit* self); +void ScintillaEdit_SetIdentifiers(ScintillaEdit* self, intptr_t style, const char* identifiers); +intptr_t ScintillaEdit_DistanceToSecondaryStyles(const ScintillaEdit* self); +struct miqt_string ScintillaEdit_SubStyleBases(const ScintillaEdit* self); +intptr_t ScintillaEdit_NamedStyles(const ScintillaEdit* self); +struct miqt_string ScintillaEdit_NameOfStyle(ScintillaEdit* self, intptr_t style); +struct miqt_string ScintillaEdit_TagsOfStyle(ScintillaEdit* self, intptr_t style); +struct miqt_string ScintillaEdit_DescriptionOfStyle(ScintillaEdit* self, intptr_t style); +void ScintillaEdit_SetILexer(ScintillaEdit* self, intptr_t ilexer); +intptr_t ScintillaEdit_Bidirectional(const ScintillaEdit* self); +void ScintillaEdit_SetBidirectional(ScintillaEdit* self, intptr_t bidirectional); +struct miqt_string ScintillaEdit_Tr2(const char* s, const char* c); +struct miqt_string ScintillaEdit_Tr3(const char* s, const char* c, int n); +struct miqt_string ScintillaEdit_TrUtf82(const char* s, const char* c); +struct miqt_string ScintillaEdit_TrUtf83(const char* s, const char* c, int n); +void ScintillaEdit_Delete(ScintillaEdit* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif