mirror of
https://github.com/mappu/miqt.git
synced 2025-02-08 22:10:23 +00:00
11660 lines
395 KiB
C++
11660 lines
395 KiB
C++
#include <QAbstractScrollArea>
|
|
#include <QActionEvent>
|
|
#include <QByteArray>
|
|
#include <QChildEvent>
|
|
#include <QCloseEvent>
|
|
#include <QContextMenuEvent>
|
|
#include <QDragEnterEvent>
|
|
#include <QDragLeaveEvent>
|
|
#include <QDragMoveEvent>
|
|
#include <QDropEvent>
|
|
#include <QEvent>
|
|
#include <QFocusEvent>
|
|
#include <QFrame>
|
|
#include <QHideEvent>
|
|
#include <QInputMethodEvent>
|
|
#include <QKeyEvent>
|
|
#include <QMargins>
|
|
#include <QMetaMethod>
|
|
#include <QMetaObject>
|
|
#include <QMimeData>
|
|
#include <QMouseEvent>
|
|
#include <QMoveEvent>
|
|
#include <QObject>
|
|
#include <QPaintDevice>
|
|
#include <QPaintEngine>
|
|
#include <QPaintEvent>
|
|
#include <QPainter>
|
|
#include <QPair>
|
|
#include <QPoint>
|
|
#include <QRect>
|
|
#include <QResizeEvent>
|
|
#include <QShowEvent>
|
|
#include <QSize>
|
|
#include <QString>
|
|
#include <QByteArray>
|
|
#include <cstring>
|
|
#include <QStyleOptionFrame>
|
|
#include <QTabletEvent>
|
|
#include <QTimerEvent>
|
|
#include <QVariant>
|
|
#include <QWheelEvent>
|
|
#include <QWidget>
|
|
#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 <ScintillaEdit.h>
|
|
#include "gen_ScintillaEdit.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_Init(Scintilla__Internal__Surface*, intptr_t, void*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_Init2(Scintilla__Internal__Surface*, intptr_t, void*, void*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_SetMode(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__SurfaceMode*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_Release(Scintilla__Internal__Surface*, intptr_t);
|
|
int miqt_exec_callback_Scintilla__Internal__Surface_SupportsFeature(Scintilla__Internal__Surface*, intptr_t, int);
|
|
bool miqt_exec_callback_Scintilla__Internal__Surface_Initialised(Scintilla__Internal__Surface*, intptr_t);
|
|
int miqt_exec_callback_Scintilla__Internal__Surface_LogPixelsY(Scintilla__Internal__Surface*, intptr_t);
|
|
int miqt_exec_callback_Scintilla__Internal__Surface_PixelDivisions(Scintilla__Internal__Surface*, intptr_t);
|
|
int miqt_exec_callback_Scintilla__Internal__Surface_DeviceHeightFont(Scintilla__Internal__Surface*, intptr_t, int);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_LineDraw(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__Point*, Scintilla__Internal__Point*, Scintilla__Internal__Stroke*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_PolyLine(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__Point*, size_t, Scintilla__Internal__Stroke*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_Polygon(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__Point*, size_t, Scintilla__Internal__FillStroke*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_RectangleDraw(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, Scintilla__Internal__FillStroke*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_RectangleFrame(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, Scintilla__Internal__Stroke*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_FillRectangle(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, Scintilla__Internal__Fill*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_FillRectangleAligned(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, Scintilla__Internal__Fill*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_FillRectangle2(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, Scintilla__Internal__Surface*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_RoundedRectangle(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, Scintilla__Internal__FillStroke*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_AlphaRectangle(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, double, Scintilla__Internal__FillStroke*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_DrawRGBAImage(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, int, int, const unsigned char*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_Ellipse(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, Scintilla__Internal__FillStroke*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_Stadium(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, Scintilla__Internal__FillStroke*, int);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_Copy(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*, Scintilla__Internal__Point*, Scintilla__Internal__Surface*);
|
|
double miqt_exec_callback_Scintilla__Internal__Surface_Ascent(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__Font*);
|
|
double miqt_exec_callback_Scintilla__Internal__Surface_Descent(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__Font*);
|
|
double miqt_exec_callback_Scintilla__Internal__Surface_InternalLeading(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__Font*);
|
|
double miqt_exec_callback_Scintilla__Internal__Surface_Height(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__Font*);
|
|
double miqt_exec_callback_Scintilla__Internal__Surface_AverageCharWidth(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__Font*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_SetClip(Scintilla__Internal__Surface*, intptr_t, Scintilla__Internal__PRectangle*);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_PopClip(Scintilla__Internal__Surface*, intptr_t);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_FlushCachedState(Scintilla__Internal__Surface*, intptr_t);
|
|
void miqt_exec_callback_Scintilla__Internal__Surface_FlushDrawing(Scintilla__Internal__Surface*, intptr_t);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_SetFont(Scintilla__Internal__ListBox*, intptr_t, Scintilla__Internal__Font*);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_Create(Scintilla__Internal__ListBox*, intptr_t, Scintilla__Internal__Window*, int, Scintilla__Internal__Point*, int, bool, int);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_SetAverageCharWidth(Scintilla__Internal__ListBox*, intptr_t, int);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_SetVisibleRows(Scintilla__Internal__ListBox*, intptr_t, int);
|
|
int miqt_exec_callback_Scintilla__Internal__ListBox_GetVisibleRows(const Scintilla__Internal__ListBox*, intptr_t);
|
|
Scintilla__Internal__PRectangle* miqt_exec_callback_Scintilla__Internal__ListBox_GetDesiredRect(Scintilla__Internal__ListBox*, intptr_t);
|
|
int miqt_exec_callback_Scintilla__Internal__ListBox_CaretFromEdge(Scintilla__Internal__ListBox*, intptr_t);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_Clear(Scintilla__Internal__ListBox*, intptr_t);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_Append(Scintilla__Internal__ListBox*, intptr_t, char*, int);
|
|
int miqt_exec_callback_Scintilla__Internal__ListBox_Length(Scintilla__Internal__ListBox*, intptr_t);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_Select(Scintilla__Internal__ListBox*, intptr_t, int);
|
|
int miqt_exec_callback_Scintilla__Internal__ListBox_GetSelection(Scintilla__Internal__ListBox*, intptr_t);
|
|
int miqt_exec_callback_Scintilla__Internal__ListBox_Find(Scintilla__Internal__ListBox*, intptr_t, const char*);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_RegisterImage(Scintilla__Internal__ListBox*, intptr_t, int, const char*);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_RegisterRGBAImage(Scintilla__Internal__ListBox*, intptr_t, int, int, int, const unsigned char*);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_ClearRegisteredImages(Scintilla__Internal__ListBox*, intptr_t);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_SetDelegate(Scintilla__Internal__ListBox*, intptr_t, Scintilla__Internal__IListBoxDelegate*);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_SetList(Scintilla__Internal__ListBox*, intptr_t, const char*, char, char);
|
|
void miqt_exec_callback_Scintilla__Internal__ListBox_SetOptions(Scintilla__Internal__ListBox*, intptr_t, Scintilla__Internal__ListOptions*);
|
|
void miqt_exec_callback_ScintillaEditBase_horizontalScrolled(intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_verticalScrolled(intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_horizontalRangeChanged(intptr_t, int, int);
|
|
void miqt_exec_callback_ScintillaEditBase_verticalRangeChanged(intptr_t, int, int);
|
|
void miqt_exec_callback_ScintillaEditBase_notifyChange(intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_linesAdded(intptr_t, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_aboutToCopy(intptr_t, QMimeData*);
|
|
void miqt_exec_callback_ScintillaEditBase_styleNeeded(intptr_t, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_charAdded(intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_savePointChanged(intptr_t, bool);
|
|
void miqt_exec_callback_ScintillaEditBase_modifyAttemptReadOnly(intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_key(intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_doubleClick(intptr_t, intptr_t, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_updateUi(intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_modified(intptr_t, int, intptr_t, intptr_t, intptr_t, struct miqt_string, intptr_t, int, int);
|
|
void miqt_exec_callback_ScintillaEditBase_macroRecord(intptr_t, int, uintptr_t, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_marginClicked(intptr_t, intptr_t, int, int);
|
|
void miqt_exec_callback_ScintillaEditBase_textAreaClicked(intptr_t, intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_needShown(intptr_t, intptr_t, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_painted(intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_userListSelection(intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_uriDropped(intptr_t, struct miqt_string);
|
|
void miqt_exec_callback_ScintillaEditBase_dwellStart(intptr_t, int, int);
|
|
void miqt_exec_callback_ScintillaEditBase_dwellEnd(intptr_t, int, int);
|
|
void miqt_exec_callback_ScintillaEditBase_zoom(intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_hotSpotClick(intptr_t, intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_hotSpotDoubleClick(intptr_t, intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_callTipClick(intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_autoCompleteSelection(intptr_t, intptr_t, struct miqt_string);
|
|
void miqt_exec_callback_ScintillaEditBase_autoCompleteCancelled(intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_focusChanged(intptr_t, bool);
|
|
void miqt_exec_callback_ScintillaEditBase_notify(intptr_t, Scintilla__NotificationData*);
|
|
void miqt_exec_callback_ScintillaEditBase_command(intptr_t, uintptr_t, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_buttonPressed(intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_buttonReleased(intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_keyPressed(intptr_t, QKeyEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_resized(intptr_t);
|
|
intptr_t miqt_exec_callback_ScintillaEditBase_send(const ScintillaEditBase*, intptr_t, unsigned int, uintptr_t, intptr_t);
|
|
intptr_t miqt_exec_callback_ScintillaEditBase_sends(const ScintillaEditBase*, intptr_t, unsigned int, uintptr_t, const char*);
|
|
bool miqt_exec_callback_ScintillaEditBase_event(ScintillaEditBase*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_paintEvent(ScintillaEditBase*, intptr_t, QPaintEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_wheelEvent(ScintillaEditBase*, intptr_t, QWheelEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_focusInEvent(ScintillaEditBase*, intptr_t, QFocusEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_focusOutEvent(ScintillaEditBase*, intptr_t, QFocusEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_resizeEvent(ScintillaEditBase*, intptr_t, QResizeEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_keyPressEvent(ScintillaEditBase*, intptr_t, QKeyEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_mousePressEvent(ScintillaEditBase*, intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_mouseReleaseEvent(ScintillaEditBase*, intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_mouseDoubleClickEvent(ScintillaEditBase*, intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_mouseMoveEvent(ScintillaEditBase*, intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_contextMenuEvent(ScintillaEditBase*, intptr_t, QContextMenuEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_dragEnterEvent(ScintillaEditBase*, intptr_t, QDragEnterEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_dragLeaveEvent(ScintillaEditBase*, intptr_t, QDragLeaveEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_dragMoveEvent(ScintillaEditBase*, intptr_t, QDragMoveEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_dropEvent(ScintillaEditBase*, intptr_t, QDropEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_inputMethodEvent(ScintillaEditBase*, intptr_t, QInputMethodEvent*);
|
|
QVariant* miqt_exec_callback_ScintillaEditBase_inputMethodQuery(const ScintillaEditBase*, intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_scrollContentsBy(ScintillaEditBase*, intptr_t, int, int);
|
|
QSize* miqt_exec_callback_ScintillaEditBase_minimumSizeHint(const ScintillaEditBase*, intptr_t);
|
|
QSize* miqt_exec_callback_ScintillaEditBase_sizeHint(const ScintillaEditBase*, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_setupViewport(ScintillaEditBase*, intptr_t, QWidget*);
|
|
bool miqt_exec_callback_ScintillaEditBase_eventFilter(ScintillaEditBase*, intptr_t, QObject*, QEvent*);
|
|
bool miqt_exec_callback_ScintillaEditBase_viewportEvent(ScintillaEditBase*, intptr_t, QEvent*);
|
|
QSize* miqt_exec_callback_ScintillaEditBase_viewportSizeHint(const ScintillaEditBase*, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_changeEvent(ScintillaEditBase*, intptr_t, QEvent*);
|
|
int miqt_exec_callback_ScintillaEditBase_devType(const ScintillaEditBase*, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_setVisible(ScintillaEditBase*, intptr_t, bool);
|
|
int miqt_exec_callback_ScintillaEditBase_heightForWidth(const ScintillaEditBase*, intptr_t, int);
|
|
bool miqt_exec_callback_ScintillaEditBase_hasHeightForWidth(const ScintillaEditBase*, intptr_t);
|
|
QPaintEngine* miqt_exec_callback_ScintillaEditBase_paintEngine(const ScintillaEditBase*, intptr_t);
|
|
void miqt_exec_callback_ScintillaEditBase_keyReleaseEvent(ScintillaEditBase*, intptr_t, QKeyEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_enterEvent(ScintillaEditBase*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_leaveEvent(ScintillaEditBase*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_moveEvent(ScintillaEditBase*, intptr_t, QMoveEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_closeEvent(ScintillaEditBase*, intptr_t, QCloseEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_tabletEvent(ScintillaEditBase*, intptr_t, QTabletEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_actionEvent(ScintillaEditBase*, intptr_t, QActionEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_showEvent(ScintillaEditBase*, intptr_t, QShowEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_hideEvent(ScintillaEditBase*, intptr_t, QHideEvent*);
|
|
bool miqt_exec_callback_ScintillaEditBase_nativeEvent(ScintillaEditBase*, intptr_t, struct miqt_string, void*, long*);
|
|
int miqt_exec_callback_ScintillaEditBase_metric(const ScintillaEditBase*, intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEditBase_initPainter(const ScintillaEditBase*, intptr_t, QPainter*);
|
|
QPaintDevice* miqt_exec_callback_ScintillaEditBase_redirected(const ScintillaEditBase*, intptr_t, QPoint*);
|
|
QPainter* miqt_exec_callback_ScintillaEditBase_sharedPainter(const ScintillaEditBase*, intptr_t);
|
|
bool miqt_exec_callback_ScintillaEditBase_focusNextPrevChild(ScintillaEditBase*, intptr_t, bool);
|
|
void miqt_exec_callback_ScintillaEditBase_timerEvent(ScintillaEditBase*, intptr_t, QTimerEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_childEvent(ScintillaEditBase*, intptr_t, QChildEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_customEvent(ScintillaEditBase*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_ScintillaEditBase_connectNotify(ScintillaEditBase*, intptr_t, QMetaMethod*);
|
|
void miqt_exec_callback_ScintillaEditBase_disconnectNotify(ScintillaEditBase*, intptr_t, QMetaMethod*);
|
|
void miqt_exec_callback_ScintillaDocument_modifyAttempt(intptr_t);
|
|
void miqt_exec_callback_ScintillaDocument_savePoint(intptr_t, bool);
|
|
void miqt_exec_callback_ScintillaDocument_modified(intptr_t, int, int, struct miqt_string, int, int, int, int, int);
|
|
void miqt_exec_callback_ScintillaDocument_styleNeeded(intptr_t, int);
|
|
void miqt_exec_callback_ScintillaDocument_errorOccurred(intptr_t, int);
|
|
bool miqt_exec_callback_ScintillaDocument_event(ScintillaDocument*, intptr_t, QEvent*);
|
|
bool miqt_exec_callback_ScintillaDocument_eventFilter(ScintillaDocument*, intptr_t, QObject*, QEvent*);
|
|
void miqt_exec_callback_ScintillaDocument_timerEvent(ScintillaDocument*, intptr_t, QTimerEvent*);
|
|
void miqt_exec_callback_ScintillaDocument_childEvent(ScintillaDocument*, intptr_t, QChildEvent*);
|
|
void miqt_exec_callback_ScintillaDocument_customEvent(ScintillaDocument*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_ScintillaDocument_connectNotify(ScintillaDocument*, intptr_t, QMetaMethod*);
|
|
void miqt_exec_callback_ScintillaDocument_disconnectNotify(ScintillaDocument*, intptr_t, QMetaMethod*);
|
|
intptr_t miqt_exec_callback_ScintillaEdit_send(const ScintillaEdit*, intptr_t, unsigned int, uintptr_t, intptr_t);
|
|
intptr_t miqt_exec_callback_ScintillaEdit_sends(const ScintillaEdit*, intptr_t, unsigned int, uintptr_t, const char*);
|
|
bool miqt_exec_callback_ScintillaEdit_event(ScintillaEdit*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_paintEvent(ScintillaEdit*, intptr_t, QPaintEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_wheelEvent(ScintillaEdit*, intptr_t, QWheelEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_focusInEvent(ScintillaEdit*, intptr_t, QFocusEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_focusOutEvent(ScintillaEdit*, intptr_t, QFocusEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_resizeEvent(ScintillaEdit*, intptr_t, QResizeEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_keyPressEvent(ScintillaEdit*, intptr_t, QKeyEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_mousePressEvent(ScintillaEdit*, intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_mouseReleaseEvent(ScintillaEdit*, intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_mouseDoubleClickEvent(ScintillaEdit*, intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_mouseMoveEvent(ScintillaEdit*, intptr_t, QMouseEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_contextMenuEvent(ScintillaEdit*, intptr_t, QContextMenuEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_dragEnterEvent(ScintillaEdit*, intptr_t, QDragEnterEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_dragLeaveEvent(ScintillaEdit*, intptr_t, QDragLeaveEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_dragMoveEvent(ScintillaEdit*, intptr_t, QDragMoveEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_dropEvent(ScintillaEdit*, intptr_t, QDropEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_inputMethodEvent(ScintillaEdit*, intptr_t, QInputMethodEvent*);
|
|
QVariant* miqt_exec_callback_ScintillaEdit_inputMethodQuery(const ScintillaEdit*, intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEdit_scrollContentsBy(ScintillaEdit*, intptr_t, int, int);
|
|
QSize* miqt_exec_callback_ScintillaEdit_minimumSizeHint(const ScintillaEdit*, intptr_t);
|
|
QSize* miqt_exec_callback_ScintillaEdit_sizeHint(const ScintillaEdit*, intptr_t);
|
|
void miqt_exec_callback_ScintillaEdit_setupViewport(ScintillaEdit*, intptr_t, QWidget*);
|
|
bool miqt_exec_callback_ScintillaEdit_eventFilter(ScintillaEdit*, intptr_t, QObject*, QEvent*);
|
|
bool miqt_exec_callback_ScintillaEdit_viewportEvent(ScintillaEdit*, intptr_t, QEvent*);
|
|
QSize* miqt_exec_callback_ScintillaEdit_viewportSizeHint(const ScintillaEdit*, intptr_t);
|
|
void miqt_exec_callback_ScintillaEdit_changeEvent(ScintillaEdit*, intptr_t, QEvent*);
|
|
int miqt_exec_callback_ScintillaEdit_devType(const ScintillaEdit*, intptr_t);
|
|
void miqt_exec_callback_ScintillaEdit_setVisible(ScintillaEdit*, intptr_t, bool);
|
|
int miqt_exec_callback_ScintillaEdit_heightForWidth(const ScintillaEdit*, intptr_t, int);
|
|
bool miqt_exec_callback_ScintillaEdit_hasHeightForWidth(const ScintillaEdit*, intptr_t);
|
|
QPaintEngine* miqt_exec_callback_ScintillaEdit_paintEngine(const ScintillaEdit*, intptr_t);
|
|
void miqt_exec_callback_ScintillaEdit_keyReleaseEvent(ScintillaEdit*, intptr_t, QKeyEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_enterEvent(ScintillaEdit*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_leaveEvent(ScintillaEdit*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_moveEvent(ScintillaEdit*, intptr_t, QMoveEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_closeEvent(ScintillaEdit*, intptr_t, QCloseEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_tabletEvent(ScintillaEdit*, intptr_t, QTabletEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_actionEvent(ScintillaEdit*, intptr_t, QActionEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_showEvent(ScintillaEdit*, intptr_t, QShowEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_hideEvent(ScintillaEdit*, intptr_t, QHideEvent*);
|
|
bool miqt_exec_callback_ScintillaEdit_nativeEvent(ScintillaEdit*, intptr_t, struct miqt_string, void*, long*);
|
|
int miqt_exec_callback_ScintillaEdit_metric(const ScintillaEdit*, intptr_t, int);
|
|
void miqt_exec_callback_ScintillaEdit_initPainter(const ScintillaEdit*, intptr_t, QPainter*);
|
|
QPaintDevice* miqt_exec_callback_ScintillaEdit_redirected(const ScintillaEdit*, intptr_t, QPoint*);
|
|
QPainter* miqt_exec_callback_ScintillaEdit_sharedPainter(const ScintillaEdit*, intptr_t);
|
|
bool miqt_exec_callback_ScintillaEdit_focusNextPrevChild(ScintillaEdit*, intptr_t, bool);
|
|
void miqt_exec_callback_ScintillaEdit_timerEvent(ScintillaEdit*, intptr_t, QTimerEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_childEvent(ScintillaEdit*, intptr_t, QChildEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_customEvent(ScintillaEdit*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_ScintillaEdit_connectNotify(ScintillaEdit*, intptr_t, QMetaMethod*);
|
|
void miqt_exec_callback_ScintillaEdit_disconnectNotify(ScintillaEdit*, intptr_t, QMetaMethod*);
|
|
#ifdef __cplusplus
|
|
} /* extern C */
|
|
#endif
|
|
|
|
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<Scintilla::Internal::XYPOSITION>(x_));
|
|
}
|
|
|
|
Scintilla__Internal__Point* Scintilla__Internal__Point_new4(double x_, double y_) {
|
|
return new Scintilla::Internal::Point(static_cast<Scintilla::Internal::XYPOSITION>(x_), static_cast<Scintilla::Internal::XYPOSITION>(y_));
|
|
}
|
|
|
|
Scintilla__Internal__Point* Scintilla__Internal__Point_FromInts(int x_, int y_) {
|
|
return new Scintilla::Internal::Point(Scintilla::Internal::Point::FromInts(static_cast<int>(x_), static_cast<int>(y_)));
|
|
}
|
|
|
|
bool Scintilla__Internal__Point_operatorEqual(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other) {
|
|
return (*self == *other);
|
|
}
|
|
|
|
bool Scintilla__Internal__Point_operatorNotEqual(const Scintilla__Internal__Point* self, Scintilla__Internal__Point* other) {
|
|
return (*self != *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 == *other);
|
|
}
|
|
|
|
double Scintilla__Internal__Interval_Width(const Scintilla__Internal__Interval* self) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->Width();
|
|
return static_cast<double>(_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<Scintilla::Internal::XYPOSITION>(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<Scintilla::Internal::XYPOSITION>(left_));
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new4(double left_, double top_) {
|
|
return new Scintilla::Internal::PRectangle(static_cast<Scintilla::Internal::XYPOSITION>(left_), static_cast<Scintilla::Internal::XYPOSITION>(top_));
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new5(double left_, double top_, double right_) {
|
|
return new Scintilla::Internal::PRectangle(static_cast<Scintilla::Internal::XYPOSITION>(left_), static_cast<Scintilla::Internal::XYPOSITION>(top_), static_cast<Scintilla::Internal::XYPOSITION>(right_));
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* Scintilla__Internal__PRectangle_new6(double left_, double top_, double right_, double bottom_) {
|
|
return new Scintilla::Internal::PRectangle(static_cast<Scintilla::Internal::XYPOSITION>(left_), static_cast<Scintilla::Internal::XYPOSITION>(top_), static_cast<Scintilla::Internal::XYPOSITION>(right_), static_cast<Scintilla::Internal::XYPOSITION>(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<int>(left_), static_cast<int>(top_), static_cast<int>(right_), static_cast<int>(bottom_)));
|
|
}
|
|
|
|
bool Scintilla__Internal__PRectangle_operatorEqual(const Scintilla__Internal__PRectangle* self, Scintilla__Internal__PRectangle* rc) {
|
|
return (*self == *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<Scintilla::Internal::XYPOSITION>(xDelta), static_cast<Scintilla::Internal::XYPOSITION>(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<Scintilla::Internal::XYPOSITION>(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<double>(_ret);
|
|
}
|
|
|
|
double Scintilla__Internal__PRectangle_Height(const Scintilla__Internal__PRectangle* self) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->Height();
|
|
return static_cast<double>(_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<unsigned int>(red), static_cast<unsigned int>(green), static_cast<unsigned int>(blue));
|
|
}
|
|
|
|
Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_new3(Scintilla__Internal__ColourRGBA* cd, unsigned int alpha) {
|
|
return new Scintilla::Internal::ColourRGBA(*cd, static_cast<unsigned int>(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<int>(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<unsigned int>(red), static_cast<unsigned int>(green), static_cast<unsigned int>(blue), static_cast<unsigned int>(alpha));
|
|
}
|
|
|
|
Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_FromRGB(int co_) {
|
|
return new Scintilla::Internal::ColourRGBA(Scintilla::Internal::ColourRGBA::FromRGB(static_cast<int>(co_)));
|
|
}
|
|
|
|
Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_Grey(unsigned int grey) {
|
|
return new Scintilla::Internal::ColourRGBA(Scintilla::Internal::ColourRGBA::Grey(static_cast<unsigned int>(grey)));
|
|
}
|
|
|
|
Scintilla__Internal__ColourRGBA* Scintilla__Internal__ColourRGBA_FromIpRGB(intptr_t co_) {
|
|
return new Scintilla::Internal::ColourRGBA(Scintilla::Internal::ColourRGBA::FromIpRGB(static_cast<intptr_t>(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 == *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<double>(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<unsigned int>(grey), static_cast<unsigned int>(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<Scintilla::Internal::XYPOSITION>(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<Scintilla::Internal::XYPOSITION>(widthStroke_));
|
|
}
|
|
|
|
Scintilla__Internal__FillStroke* Scintilla__Internal__FillStroke_new4(Scintilla__Internal__ColourRGBA* colourBoth, double widthStroke_) {
|
|
return new Scintilla::Internal::FillStroke(*colourBoth, static_cast<Scintilla::Internal::XYPOSITION>(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<Scintilla::Internal::XYPOSITION>(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<Scintilla::Internal::XYPOSITION>(size_));
|
|
}
|
|
|
|
Scintilla__Internal__FontParameters* Scintilla__Internal__FontParameters_new3(const char* faceName_, double size_, int weight_) {
|
|
return new Scintilla::Internal::FontParameters(faceName_, static_cast<Scintilla::Internal::XYPOSITION>(size_), static_cast<Scintilla::FontWeight>(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<Scintilla::Internal::XYPOSITION>(size_), static_cast<Scintilla::FontWeight>(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<Scintilla::Internal::XYPOSITION>(size_), static_cast<Scintilla::FontWeight>(weight_), italic_, static_cast<Scintilla::FontQuality>(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<Scintilla::Internal::XYPOSITION>(size_), static_cast<Scintilla::FontWeight>(weight_), italic_, static_cast<Scintilla::FontQuality>(extraFontFlag_), static_cast<Scintilla::Technology>(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<Scintilla::Internal::XYPOSITION>(size_), static_cast<Scintilla::FontWeight>(weight_), italic_, static_cast<Scintilla::FontQuality>(extraFontFlag_), static_cast<Scintilla::Technology>(technology_), static_cast<Scintilla::CharacterSet>(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<Scintilla::Internal::XYPOSITION>(size_), static_cast<Scintilla::FontWeight>(weight_), italic_, static_cast<Scintilla::FontQuality>(extraFontFlag_), static_cast<Scintilla::Technology>(technology_), static_cast<Scintilla::CharacterSet>(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<Scintilla::Internal::XYPOSITION>(size_), static_cast<Scintilla::FontWeight>(weight_), italic_, static_cast<Scintilla::FontQuality>(extraFontFlag_), static_cast<Scintilla::Technology>(technology_), static_cast<Scintilla::CharacterSet>(characterSet_), localeName_, static_cast<Scintilla::FontStretch>(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<double>(_ret);
|
|
}
|
|
|
|
double Scintilla__Internal__IScreenLine_Height(const Scintilla__Internal__IScreenLine* self) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->Height();
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
double Scintilla__Internal__IScreenLine_TabWidth(const Scintilla__Internal__IScreenLine* self) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->TabWidth();
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
double Scintilla__Internal__IScreenLine_TabWidthMinimumPixels(const Scintilla__Internal__IScreenLine* self) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->TabWidthMinimumPixels();
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
Scintilla__Internal__Font* Scintilla__Internal__IScreenLine_FontOfPosition(const Scintilla__Internal__IScreenLine* self, size_t position) {
|
|
return (Scintilla__Internal__Font*) self->FontOfPosition(static_cast<size_t>(position));
|
|
}
|
|
|
|
double Scintilla__Internal__IScreenLine_RepresentationWidth(const Scintilla__Internal__IScreenLine* self, size_t position) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->RepresentationWidth(static_cast<size_t>(position));
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
double Scintilla__Internal__IScreenLine_TabPositionAfter(const Scintilla__Internal__IScreenLine* self, double xPosition) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->TabPositionAfter(static_cast<Scintilla::Internal::XYPOSITION>(xPosition));
|
|
return static_cast<double>(_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<Scintilla::Internal::XYPOSITION>(xDistance), charPosition);
|
|
}
|
|
|
|
double Scintilla__Internal__IScreenLineLayout_XFromPosition(Scintilla__Internal__IScreenLineLayout* self, size_t caretPosition) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->XFromPosition(static_cast<size_t>(caretPosition));
|
|
return static_cast<double>(_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<int>(codePage_), bidiR2L_);
|
|
}
|
|
|
|
void Scintilla__Internal__SurfaceMode_delete(Scintilla__Internal__SurfaceMode* self) {
|
|
delete self;
|
|
}
|
|
|
|
class MiqtVirtualScintillaInternalSurface final : public Scintilla::Internal::Surface {
|
|
public:
|
|
|
|
MiqtVirtualScintillaInternalSurface(): Scintilla::Internal::Surface() {};
|
|
|
|
virtual ~MiqtVirtualScintillaInternalSurface() override = default;
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Init = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Init(Scintilla::Internal::WindowID wid) override {
|
|
if (handle__Init == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla::Internal::WindowID wid_ret = wid;
|
|
void* sigval1 = static_cast<void*>(wid_ret);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_Init(this, handle__Init, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Init2 = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Init(Scintilla::Internal::SurfaceID sid, Scintilla::Internal::WindowID wid) override {
|
|
if (handle__Init2 == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla::Internal::SurfaceID sid_ret = sid;
|
|
void* sigval1 = static_cast<void*>(sid_ret);
|
|
Scintilla::Internal::WindowID wid_ret = wid;
|
|
void* sigval2 = static_cast<void*>(wid_ret);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_Init2(this, handle__Init2, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__SetMode = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void SetMode(Scintilla::Internal::SurfaceMode mode) override {
|
|
if (handle__SetMode == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__SurfaceMode* sigval1 = new Scintilla::Internal::SurfaceMode(mode);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_SetMode(this, handle__SetMode, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Release = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Release() override {
|
|
if (handle__Release == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_Release(this, handle__Release);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__SupportsFeature = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int SupportsFeature(Scintilla::Supports feature) override {
|
|
if (handle__SupportsFeature == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla::Supports feature_ret = feature;
|
|
int sigval1 = static_cast<int>(feature_ret);
|
|
|
|
int callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_SupportsFeature(this, handle__SupportsFeature, sigval1);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Initialised = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool Initialised() override {
|
|
if (handle__Initialised == 0) {
|
|
return false; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
bool callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_Initialised(this, handle__Initialised);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__LogPixelsY = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int LogPixelsY() override {
|
|
if (handle__LogPixelsY == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_LogPixelsY(this, handle__LogPixelsY);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__PixelDivisions = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int PixelDivisions() override {
|
|
if (handle__PixelDivisions == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_PixelDivisions(this, handle__PixelDivisions);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DeviceHeightFont = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int DeviceHeightFont(int points) override {
|
|
if (handle__DeviceHeightFont == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
int sigval1 = points;
|
|
|
|
int callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_DeviceHeightFont(this, handle__DeviceHeightFont, sigval1);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__LineDraw = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void LineDraw(Scintilla::Internal::Point start, Scintilla::Internal::Point end, Scintilla::Internal::Stroke stroke) override {
|
|
if (handle__LineDraw == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__Point* sigval1 = new Scintilla::Internal::Point(start);
|
|
Scintilla__Internal__Point* sigval2 = new Scintilla::Internal::Point(end);
|
|
Scintilla__Internal__Stroke* sigval3 = new Scintilla::Internal::Stroke(stroke);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_LineDraw(this, handle__LineDraw, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__PolyLine = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void PolyLine(const Scintilla::Internal::Point* pts, size_t npts, Scintilla::Internal::Stroke stroke) override {
|
|
if (handle__PolyLine == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__Point* sigval1 = (Scintilla__Internal__Point*) pts;
|
|
size_t sigval2 = npts;
|
|
Scintilla__Internal__Stroke* sigval3 = new Scintilla::Internal::Stroke(stroke);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_PolyLine(this, handle__PolyLine, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Polygon = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Polygon(const Scintilla::Internal::Point* pts, size_t npts, Scintilla::Internal::FillStroke fillStroke) override {
|
|
if (handle__Polygon == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__Point* sigval1 = (Scintilla__Internal__Point*) pts;
|
|
size_t sigval2 = npts;
|
|
Scintilla__Internal__FillStroke* sigval3 = new Scintilla::Internal::FillStroke(fillStroke);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_Polygon(this, handle__Polygon, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__RectangleDraw = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void RectangleDraw(Scintilla::Internal::PRectangle rc, Scintilla::Internal::FillStroke fillStroke) override {
|
|
if (handle__RectangleDraw == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla__Internal__FillStroke* sigval2 = new Scintilla::Internal::FillStroke(fillStroke);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_RectangleDraw(this, handle__RectangleDraw, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__RectangleFrame = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void RectangleFrame(Scintilla::Internal::PRectangle rc, Scintilla::Internal::Stroke stroke) override {
|
|
if (handle__RectangleFrame == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla__Internal__Stroke* sigval2 = new Scintilla::Internal::Stroke(stroke);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_RectangleFrame(this, handle__RectangleFrame, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__FillRectangle = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void FillRectangle(Scintilla::Internal::PRectangle rc, Scintilla::Internal::Fill fill) override {
|
|
if (handle__FillRectangle == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla__Internal__Fill* sigval2 = new Scintilla::Internal::Fill(fill);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_FillRectangle(this, handle__FillRectangle, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__FillRectangleAligned = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void FillRectangleAligned(Scintilla::Internal::PRectangle rc, Scintilla::Internal::Fill fill) override {
|
|
if (handle__FillRectangleAligned == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla__Internal__Fill* sigval2 = new Scintilla::Internal::Fill(fill);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_FillRectangleAligned(this, handle__FillRectangleAligned, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__FillRectangle2 = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void FillRectangle(Scintilla::Internal::PRectangle rc, Scintilla::Internal::Surface& surfacePattern) override {
|
|
if (handle__FillRectangle2 == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla::Internal::Surface& surfacePattern_ret = surfacePattern;
|
|
// Cast returned reference into pointer
|
|
Scintilla__Internal__Surface* sigval2 = &surfacePattern_ret;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_FillRectangle2(this, handle__FillRectangle2, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__RoundedRectangle = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void RoundedRectangle(Scintilla::Internal::PRectangle rc, Scintilla::Internal::FillStroke fillStroke) override {
|
|
if (handle__RoundedRectangle == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla__Internal__FillStroke* sigval2 = new Scintilla::Internal::FillStroke(fillStroke);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_RoundedRectangle(this, handle__RoundedRectangle, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__AlphaRectangle = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void AlphaRectangle(Scintilla::Internal::PRectangle rc, Scintilla::Internal::XYPOSITION cornerSize, Scintilla::Internal::FillStroke fillStroke) override {
|
|
if (handle__AlphaRectangle == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla::Internal::XYPOSITION cornerSize_ret = cornerSize;
|
|
double sigval2 = static_cast<double>(cornerSize_ret);
|
|
Scintilla__Internal__FillStroke* sigval3 = new Scintilla::Internal::FillStroke(fillStroke);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_AlphaRectangle(this, handle__AlphaRectangle, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawRGBAImage = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void DrawRGBAImage(Scintilla::Internal::PRectangle rc, int width, int height, const unsigned char* pixelsImage) override {
|
|
if (handle__DrawRGBAImage == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
int sigval2 = width;
|
|
int sigval3 = height;
|
|
const unsigned char* sigval4 = (const unsigned char*) pixelsImage;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_DrawRGBAImage(this, handle__DrawRGBAImage, sigval1, sigval2, sigval3, sigval4);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Ellipse = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Ellipse(Scintilla::Internal::PRectangle rc, Scintilla::Internal::FillStroke fillStroke) override {
|
|
if (handle__Ellipse == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla__Internal__FillStroke* sigval2 = new Scintilla::Internal::FillStroke(fillStroke);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_Ellipse(this, handle__Ellipse, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Stadium = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Stadium(Scintilla::Internal::PRectangle rc, Scintilla::Internal::FillStroke fillStroke, Scintilla::Internal::Surface::Ends ends) override {
|
|
if (handle__Stadium == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla__Internal__FillStroke* sigval2 = new Scintilla::Internal::FillStroke(fillStroke);
|
|
Scintilla::Internal::Surface::Ends ends_ret = ends;
|
|
int sigval3 = static_cast<int>(ends_ret);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_Stadium(this, handle__Stadium, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Copy = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Copy(Scintilla::Internal::PRectangle rc, Scintilla::Internal::Point from, Scintilla::Internal::Surface& surfaceSource) override {
|
|
if (handle__Copy == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
Scintilla__Internal__Point* sigval2 = new Scintilla::Internal::Point(from);
|
|
Scintilla::Internal::Surface& surfaceSource_ret = surfaceSource;
|
|
// Cast returned reference into pointer
|
|
Scintilla__Internal__Surface* sigval3 = &surfaceSource_ret;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_Copy(this, handle__Copy, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Ascent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual Scintilla::Internal::XYPOSITION Ascent(const Scintilla::Internal::Font* font_) override {
|
|
if (handle__Ascent == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__Font* sigval1 = (Scintilla__Internal__Font*) font_;
|
|
|
|
double callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_Ascent(this, handle__Ascent, sigval1);
|
|
|
|
return static_cast<Scintilla::Internal::XYPOSITION>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Descent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual Scintilla::Internal::XYPOSITION Descent(const Scintilla::Internal::Font* font_) override {
|
|
if (handle__Descent == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__Font* sigval1 = (Scintilla__Internal__Font*) font_;
|
|
|
|
double callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_Descent(this, handle__Descent, sigval1);
|
|
|
|
return static_cast<Scintilla::Internal::XYPOSITION>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__InternalLeading = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual Scintilla::Internal::XYPOSITION InternalLeading(const Scintilla::Internal::Font* font_) override {
|
|
if (handle__InternalLeading == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__Font* sigval1 = (Scintilla__Internal__Font*) font_;
|
|
|
|
double callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_InternalLeading(this, handle__InternalLeading, sigval1);
|
|
|
|
return static_cast<Scintilla::Internal::XYPOSITION>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Height = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual Scintilla::Internal::XYPOSITION Height(const Scintilla::Internal::Font* font_) override {
|
|
if (handle__Height == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__Font* sigval1 = (Scintilla__Internal__Font*) font_;
|
|
|
|
double callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_Height(this, handle__Height, sigval1);
|
|
|
|
return static_cast<Scintilla::Internal::XYPOSITION>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__AverageCharWidth = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual Scintilla::Internal::XYPOSITION AverageCharWidth(const Scintilla::Internal::Font* font_) override {
|
|
if (handle__AverageCharWidth == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__Font* sigval1 = (Scintilla__Internal__Font*) font_;
|
|
|
|
double callback_return_value = miqt_exec_callback_Scintilla__Internal__Surface_AverageCharWidth(this, handle__AverageCharWidth, sigval1);
|
|
|
|
return static_cast<Scintilla::Internal::XYPOSITION>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__SetClip = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void SetClip(Scintilla::Internal::PRectangle rc) override {
|
|
if (handle__SetClip == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__PRectangle* sigval1 = new Scintilla::Internal::PRectangle(rc);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_SetClip(this, handle__SetClip, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__PopClip = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void PopClip() override {
|
|
if (handle__PopClip == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_PopClip(this, handle__PopClip);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__FlushCachedState = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void FlushCachedState() override {
|
|
if (handle__FlushCachedState == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_FlushCachedState(this, handle__FlushCachedState);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__FlushDrawing = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void FlushDrawing() override {
|
|
if (handle__FlushDrawing == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
miqt_exec_callback_Scintilla__Internal__Surface_FlushDrawing(this, handle__FlushDrawing);
|
|
|
|
|
|
}
|
|
|
|
};
|
|
|
|
Scintilla__Internal__Surface* Scintilla__Internal__Surface_new() {
|
|
return new MiqtVirtualScintillaInternalSurface();
|
|
}
|
|
|
|
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<Scintilla::Supports>(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<int>(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<size_t>(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<size_t>(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<Scintilla::Internal::XYPOSITION>(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<int>(width), static_cast<int>(height), static_cast<const unsigned char*>(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<Scintilla::Internal::Surface::Ends>(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<double>(_ret);
|
|
}
|
|
|
|
double Scintilla__Internal__Surface_Descent(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->Descent(font_);
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
double Scintilla__Internal__Surface_InternalLeading(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->InternalLeading(font_);
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
double Scintilla__Internal__Surface_Height(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->Height(font_);
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
double Scintilla__Internal__Surface_AverageCharWidth(Scintilla__Internal__Surface* self, Scintilla__Internal__Font* font_) {
|
|
Scintilla::Internal::XYPOSITION _ret = self->AverageCharWidth(font_);
|
|
return static_cast<double>(_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();
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Init(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Init = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Init2(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Init2 = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_SetMode(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__SetMode = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Release(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Release = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_SupportsFeature(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__SupportsFeature = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Initialised(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Initialised = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_LogPixelsY(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__LogPixelsY = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_PixelDivisions(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__PixelDivisions = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_DeviceHeightFont(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__DeviceHeightFont = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_LineDraw(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__LineDraw = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_PolyLine(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__PolyLine = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Polygon(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Polygon = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_RectangleDraw(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__RectangleDraw = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_RectangleFrame(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__RectangleFrame = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_FillRectangle(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__FillRectangle = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_FillRectangleAligned(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__FillRectangleAligned = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_FillRectangle2(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__FillRectangle2 = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_RoundedRectangle(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__RoundedRectangle = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_AlphaRectangle(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__AlphaRectangle = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_DrawRGBAImage(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__DrawRGBAImage = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Ellipse(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Ellipse = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Stadium(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Stadium = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Copy(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Copy = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Ascent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Ascent = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Descent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Descent = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_InternalLeading(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__InternalLeading = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_Height(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Height = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_AverageCharWidth(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__AverageCharWidth = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_SetClip(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__SetClip = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_PopClip(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__PopClip = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_FlushCachedState(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__FlushCachedState = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__Surface_override_virtual_FlushDrawing(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalSurface* self_cast = dynamic_cast<MiqtVirtualScintillaInternalSurface*>( (Scintilla__Internal__Surface*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__FlushDrawing = slot;
|
|
return true;
|
|
}
|
|
|
|
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<void*>(_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<Scintilla::Internal::Window::Cursor>(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<Scintilla::Internal::ListBoxEvent::EventType>(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;
|
|
}
|
|
|
|
class MiqtVirtualScintillaInternalListBox final : public Scintilla::Internal::ListBox {
|
|
public:
|
|
|
|
MiqtVirtualScintillaInternalListBox(): Scintilla::Internal::ListBox() {};
|
|
|
|
virtual ~MiqtVirtualScintillaInternalListBox() override = default;
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__SetFont = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void SetFont(const Scintilla::Internal::Font* font) override {
|
|
if (handle__SetFont == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__Font* sigval1 = (Scintilla__Internal__Font*) font;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_SetFont(this, handle__SetFont, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Create = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Create(Scintilla::Internal::Window& parent, int ctrlID, Scintilla::Internal::Point location, int lineHeight_, bool unicodeMode_, Scintilla::Technology technology_) override {
|
|
if (handle__Create == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla::Internal::Window& parent_ret = parent;
|
|
// Cast returned reference into pointer
|
|
Scintilla__Internal__Window* sigval1 = &parent_ret;
|
|
int sigval2 = ctrlID;
|
|
Scintilla__Internal__Point* sigval3 = new Scintilla::Internal::Point(location);
|
|
int sigval4 = lineHeight_;
|
|
bool sigval5 = unicodeMode_;
|
|
Scintilla::Technology technology__ret = technology_;
|
|
int sigval6 = static_cast<int>(technology__ret);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_Create(this, handle__Create, sigval1, sigval2, sigval3, sigval4, sigval5, sigval6);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__SetAverageCharWidth = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void SetAverageCharWidth(int width) override {
|
|
if (handle__SetAverageCharWidth == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
int sigval1 = width;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_SetAverageCharWidth(this, handle__SetAverageCharWidth, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__SetVisibleRows = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void SetVisibleRows(int rows) override {
|
|
if (handle__SetVisibleRows == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
int sigval1 = rows;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_SetVisibleRows(this, handle__SetVisibleRows, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__GetVisibleRows = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int GetVisibleRows() const override {
|
|
if (handle__GetVisibleRows == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_Scintilla__Internal__ListBox_GetVisibleRows(this, handle__GetVisibleRows);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__GetDesiredRect = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual Scintilla::Internal::PRectangle GetDesiredRect() override {
|
|
if (handle__GetDesiredRect == 0) {
|
|
return Scintilla::Internal::PRectangle(); // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
Scintilla__Internal__PRectangle* callback_return_value = miqt_exec_callback_Scintilla__Internal__ListBox_GetDesiredRect(this, handle__GetDesiredRect);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__CaretFromEdge = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int CaretFromEdge() override {
|
|
if (handle__CaretFromEdge == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_Scintilla__Internal__ListBox_CaretFromEdge(this, handle__CaretFromEdge);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Clear = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Clear() override {
|
|
if (handle__Clear == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_Clear(this, handle__Clear);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Append = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Append(char* s, int type) override {
|
|
if (handle__Append == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
char* sigval1 = s;
|
|
int sigval2 = type;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_Append(this, handle__Append, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Length = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int Length() override {
|
|
if (handle__Length == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_Scintilla__Internal__ListBox_Length(this, handle__Length);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Select = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void Select(int n) override {
|
|
if (handle__Select == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
int sigval1 = n;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_Select(this, handle__Select, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__GetSelection = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int GetSelection() override {
|
|
if (handle__GetSelection == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_Scintilla__Internal__ListBox_GetSelection(this, handle__GetSelection);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Find = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int Find(const char* prefix) override {
|
|
if (handle__Find == 0) {
|
|
return 0; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
const char* sigval1 = (const char*) prefix;
|
|
|
|
int callback_return_value = miqt_exec_callback_Scintilla__Internal__ListBox_Find(this, handle__Find, sigval1);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__RegisterImage = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void RegisterImage(int type, const char* xpm_data) override {
|
|
if (handle__RegisterImage == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
int sigval1 = type;
|
|
const char* sigval2 = (const char*) xpm_data;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_RegisterImage(this, handle__RegisterImage, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__RegisterRGBAImage = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void RegisterRGBAImage(int type, int width, int height, const unsigned char* pixelsImage) override {
|
|
if (handle__RegisterRGBAImage == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
int sigval1 = type;
|
|
int sigval2 = width;
|
|
int sigval3 = height;
|
|
const unsigned char* sigval4 = (const unsigned char*) pixelsImage;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_RegisterRGBAImage(this, handle__RegisterRGBAImage, sigval1, sigval2, sigval3, sigval4);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__ClearRegisteredImages = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void ClearRegisteredImages() override {
|
|
if (handle__ClearRegisteredImages == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_ClearRegisteredImages(this, handle__ClearRegisteredImages);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__SetDelegate = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void SetDelegate(Scintilla::Internal::IListBoxDelegate* lbDelegate) override {
|
|
if (handle__SetDelegate == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__IListBoxDelegate* sigval1 = lbDelegate;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_SetDelegate(this, handle__SetDelegate, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__SetList = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void SetList(const char* list, char separator, char typesep) override {
|
|
if (handle__SetList == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
const char* sigval1 = (const char*) list;
|
|
char sigval2 = separator;
|
|
char sigval3 = typesep;
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_SetList(this, handle__SetList, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__SetOptions = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void SetOptions(Scintilla::Internal::ListOptions options_) override {
|
|
if (handle__SetOptions == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
Scintilla__Internal__ListOptions* sigval1 = new Scintilla::Internal::ListOptions(options_);
|
|
|
|
miqt_exec_callback_Scintilla__Internal__ListBox_SetOptions(this, handle__SetOptions, sigval1);
|
|
|
|
|
|
}
|
|
|
|
};
|
|
|
|
Scintilla__Internal__ListBox* Scintilla__Internal__ListBox_new() {
|
|
return new MiqtVirtualScintillaInternalListBox();
|
|
}
|
|
|
|
void Scintilla__Internal__ListBox_virtbase(Scintilla__Internal__ListBox* src, Scintilla::Internal::Window** outptr_Scintilla__Internal__Window) {
|
|
*outptr_Scintilla__Internal__Window = static_cast<Scintilla::Internal::Window*>(src);
|
|
}
|
|
|
|
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<int>(ctrlID), *location, static_cast<int>(lineHeight_), unicodeMode_, static_cast<Scintilla::Technology>(technology_));
|
|
}
|
|
|
|
void Scintilla__Internal__ListBox_SetAverageCharWidth(Scintilla__Internal__ListBox* self, int width) {
|
|
self->SetAverageCharWidth(static_cast<int>(width));
|
|
}
|
|
|
|
void Scintilla__Internal__ListBox_SetVisibleRows(Scintilla__Internal__ListBox* self, int rows) {
|
|
self->SetVisibleRows(static_cast<int>(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, int type) {
|
|
self->Append(s, static_cast<int>(type));
|
|
}
|
|
|
|
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<int>(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 type, const char* xpm_data) {
|
|
self->RegisterImage(static_cast<int>(type), xpm_data);
|
|
}
|
|
|
|
void Scintilla__Internal__ListBox_RegisterRGBAImage(Scintilla__Internal__ListBox* self, int type, int width, int height, const unsigned char* pixelsImage) {
|
|
self->RegisterRGBAImage(static_cast<int>(type), static_cast<int>(width), static_cast<int>(height), static_cast<const unsigned char*>(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<char>(separator), static_cast<char>(typesep));
|
|
}
|
|
|
|
void Scintilla__Internal__ListBox_SetOptions(Scintilla__Internal__ListBox* self, Scintilla__Internal__ListOptions* options_) {
|
|
self->SetOptions(*options_);
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_SetFont(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__SetFont = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_Create(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Create = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_SetAverageCharWidth(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__SetAverageCharWidth = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_SetVisibleRows(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__SetVisibleRows = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_GetVisibleRows(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__GetVisibleRows = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_GetDesiredRect(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__GetDesiredRect = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_CaretFromEdge(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__CaretFromEdge = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_Clear(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Clear = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_Append(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Append = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_Length(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Length = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_Select(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Select = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_GetSelection(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__GetSelection = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_Find(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__Find = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_RegisterImage(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__RegisterImage = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_RegisterRGBAImage(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__RegisterRGBAImage = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_ClearRegisteredImages(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__ClearRegisteredImages = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_SetDelegate(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__SetDelegate = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_SetList(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__SetList = slot;
|
|
return true;
|
|
}
|
|
|
|
bool Scintilla__Internal__ListBox_override_virtual_SetOptions(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaInternalListBox* self_cast = dynamic_cast<MiqtVirtualScintillaInternalListBox*>( (Scintilla__Internal__ListBox*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__SetOptions = slot;
|
|
return true;
|
|
}
|
|
|
|
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<void*>(_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;
|
|
}
|
|
|
|
class MiqtVirtualScintillaEditBase final : public ScintillaEditBase {
|
|
public:
|
|
|
|
MiqtVirtualScintillaEditBase(QWidget* parent): ScintillaEditBase(parent) {};
|
|
MiqtVirtualScintillaEditBase(): ScintillaEditBase() {};
|
|
|
|
virtual ~MiqtVirtualScintillaEditBase() override = default;
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__send = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual sptr_t send(unsigned int iMessage, uptr_t wParam, sptr_t lParam) const override {
|
|
if (handle__send == 0) {
|
|
return ScintillaEditBase::send(iMessage, wParam, lParam);
|
|
}
|
|
|
|
unsigned int sigval1 = iMessage;
|
|
uptr_t wParam_ret = wParam;
|
|
uintptr_t sigval2 = static_cast<uintptr_t>(wParam_ret);
|
|
sptr_t lParam_ret = lParam;
|
|
intptr_t sigval3 = static_cast<intptr_t>(lParam_ret);
|
|
|
|
intptr_t callback_return_value = miqt_exec_callback_ScintillaEditBase_send(this, handle__send, sigval1, sigval2, sigval3);
|
|
|
|
return static_cast<sptr_t>(callback_return_value);
|
|
}
|
|
|
|
friend intptr_t ScintillaEditBase_virtualbase_send(const void* self, unsigned int iMessage, uintptr_t wParam, intptr_t lParam);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__sends = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual sptr_t sends(unsigned int iMessage, uptr_t wParam, const char* s) const override {
|
|
if (handle__sends == 0) {
|
|
return ScintillaEditBase::sends(iMessage, wParam, s);
|
|
}
|
|
|
|
unsigned int sigval1 = iMessage;
|
|
uptr_t wParam_ret = wParam;
|
|
uintptr_t sigval2 = static_cast<uintptr_t>(wParam_ret);
|
|
const char* sigval3 = (const char*) s;
|
|
|
|
intptr_t callback_return_value = miqt_exec_callback_ScintillaEditBase_sends(this, handle__sends, sigval1, sigval2, sigval3);
|
|
|
|
return static_cast<sptr_t>(callback_return_value);
|
|
}
|
|
|
|
friend intptr_t ScintillaEditBase_virtualbase_sends(const void* self, unsigned int iMessage, uintptr_t wParam, const char* s);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__event = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool event(QEvent* event) override {
|
|
if (handle__event == 0) {
|
|
return ScintillaEditBase::event(event);
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEditBase_event(this, handle__event, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEditBase_virtualbase_event(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__paintEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void paintEvent(QPaintEvent* event) override {
|
|
if (handle__paintEvent == 0) {
|
|
ScintillaEditBase::paintEvent(event);
|
|
return;
|
|
}
|
|
|
|
QPaintEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_paintEvent(this, handle__paintEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_paintEvent(void* self, QPaintEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__wheelEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void wheelEvent(QWheelEvent* event) override {
|
|
if (handle__wheelEvent == 0) {
|
|
ScintillaEditBase::wheelEvent(event);
|
|
return;
|
|
}
|
|
|
|
QWheelEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_wheelEvent(this, handle__wheelEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_wheelEvent(void* self, QWheelEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__focusInEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void focusInEvent(QFocusEvent* event) override {
|
|
if (handle__focusInEvent == 0) {
|
|
ScintillaEditBase::focusInEvent(event);
|
|
return;
|
|
}
|
|
|
|
QFocusEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_focusInEvent(this, handle__focusInEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_focusInEvent(void* self, QFocusEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__focusOutEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void focusOutEvent(QFocusEvent* event) override {
|
|
if (handle__focusOutEvent == 0) {
|
|
ScintillaEditBase::focusOutEvent(event);
|
|
return;
|
|
}
|
|
|
|
QFocusEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_focusOutEvent(this, handle__focusOutEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__resizeEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void resizeEvent(QResizeEvent* event) override {
|
|
if (handle__resizeEvent == 0) {
|
|
ScintillaEditBase::resizeEvent(event);
|
|
return;
|
|
}
|
|
|
|
QResizeEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_resizeEvent(this, handle__resizeEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_resizeEvent(void* self, QResizeEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__keyPressEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void keyPressEvent(QKeyEvent* event) override {
|
|
if (handle__keyPressEvent == 0) {
|
|
ScintillaEditBase::keyPressEvent(event);
|
|
return;
|
|
}
|
|
|
|
QKeyEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_keyPressEvent(this, handle__keyPressEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__mousePressEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void mousePressEvent(QMouseEvent* event) override {
|
|
if (handle__mousePressEvent == 0) {
|
|
ScintillaEditBase::mousePressEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMouseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_mousePressEvent(this, handle__mousePressEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_mousePressEvent(void* self, QMouseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__mouseReleaseEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void mouseReleaseEvent(QMouseEvent* event) override {
|
|
if (handle__mouseReleaseEvent == 0) {
|
|
ScintillaEditBase::mouseReleaseEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMouseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_mouseReleaseEvent(this, handle__mouseReleaseEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__mouseDoubleClickEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void mouseDoubleClickEvent(QMouseEvent* event) override {
|
|
if (handle__mouseDoubleClickEvent == 0) {
|
|
ScintillaEditBase::mouseDoubleClickEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMouseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_mouseDoubleClickEvent(this, handle__mouseDoubleClickEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__mouseMoveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void mouseMoveEvent(QMouseEvent* event) override {
|
|
if (handle__mouseMoveEvent == 0) {
|
|
ScintillaEditBase::mouseMoveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMouseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_mouseMoveEvent(this, handle__mouseMoveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_mouseMoveEvent(void* self, QMouseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__contextMenuEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void contextMenuEvent(QContextMenuEvent* event) override {
|
|
if (handle__contextMenuEvent == 0) {
|
|
ScintillaEditBase::contextMenuEvent(event);
|
|
return;
|
|
}
|
|
|
|
QContextMenuEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_contextMenuEvent(this, handle__contextMenuEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__dragEnterEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void dragEnterEvent(QDragEnterEvent* event) override {
|
|
if (handle__dragEnterEvent == 0) {
|
|
ScintillaEditBase::dragEnterEvent(event);
|
|
return;
|
|
}
|
|
|
|
QDragEnterEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_dragEnterEvent(this, handle__dragEnterEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__dragLeaveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* event) override {
|
|
if (handle__dragLeaveEvent == 0) {
|
|
ScintillaEditBase::dragLeaveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QDragLeaveEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_dragLeaveEvent(this, handle__dragLeaveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__dragMoveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void dragMoveEvent(QDragMoveEvent* event) override {
|
|
if (handle__dragMoveEvent == 0) {
|
|
ScintillaEditBase::dragMoveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QDragMoveEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_dragMoveEvent(this, handle__dragMoveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__dropEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void dropEvent(QDropEvent* event) override {
|
|
if (handle__dropEvent == 0) {
|
|
ScintillaEditBase::dropEvent(event);
|
|
return;
|
|
}
|
|
|
|
QDropEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_dropEvent(this, handle__dropEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_dropEvent(void* self, QDropEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__inputMethodEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void inputMethodEvent(QInputMethodEvent* event) override {
|
|
if (handle__inputMethodEvent == 0) {
|
|
ScintillaEditBase::inputMethodEvent(event);
|
|
return;
|
|
}
|
|
|
|
QInputMethodEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_inputMethodEvent(this, handle__inputMethodEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__inputMethodQuery = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const override {
|
|
if (handle__inputMethodQuery == 0) {
|
|
return ScintillaEditBase::inputMethodQuery(query);
|
|
}
|
|
|
|
Qt::InputMethodQuery query_ret = query;
|
|
int sigval1 = static_cast<int>(query_ret);
|
|
|
|
QVariant* callback_return_value = miqt_exec_callback_ScintillaEditBase_inputMethodQuery(this, handle__inputMethodQuery, sigval1);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
friend QVariant* ScintillaEditBase_virtualbase_inputMethodQuery(const void* self, int query);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__scrollContentsBy = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void scrollContentsBy(int param1, int param2) override {
|
|
if (handle__scrollContentsBy == 0) {
|
|
ScintillaEditBase::scrollContentsBy(param1, param2);
|
|
return;
|
|
}
|
|
|
|
int sigval1 = param1;
|
|
int sigval2 = param2;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_scrollContentsBy(this, handle__scrollContentsBy, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_scrollContentsBy(void* self, int param1, int param2);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__minimumSizeHint = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QSize minimumSizeHint() const override {
|
|
if (handle__minimumSizeHint == 0) {
|
|
return ScintillaEditBase::minimumSizeHint();
|
|
}
|
|
|
|
|
|
QSize* callback_return_value = miqt_exec_callback_ScintillaEditBase_minimumSizeHint(this, handle__minimumSizeHint);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
friend QSize* ScintillaEditBase_virtualbase_minimumSizeHint(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__sizeHint = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QSize sizeHint() const override {
|
|
if (handle__sizeHint == 0) {
|
|
return ScintillaEditBase::sizeHint();
|
|
}
|
|
|
|
|
|
QSize* callback_return_value = miqt_exec_callback_ScintillaEditBase_sizeHint(this, handle__sizeHint);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
friend QSize* ScintillaEditBase_virtualbase_sizeHint(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__setupViewport = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void setupViewport(QWidget* viewport) override {
|
|
if (handle__setupViewport == 0) {
|
|
ScintillaEditBase::setupViewport(viewport);
|
|
return;
|
|
}
|
|
|
|
QWidget* sigval1 = viewport;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_setupViewport(this, handle__setupViewport, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_setupViewport(void* self, QWidget* viewport);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__eventFilter = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool eventFilter(QObject* param1, QEvent* param2) override {
|
|
if (handle__eventFilter == 0) {
|
|
return ScintillaEditBase::eventFilter(param1, param2);
|
|
}
|
|
|
|
QObject* sigval1 = param1;
|
|
QEvent* sigval2 = param2;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEditBase_eventFilter(this, handle__eventFilter, sigval1, sigval2);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEditBase_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__viewportEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool viewportEvent(QEvent* param1) override {
|
|
if (handle__viewportEvent == 0) {
|
|
return ScintillaEditBase::viewportEvent(param1);
|
|
}
|
|
|
|
QEvent* sigval1 = param1;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEditBase_viewportEvent(this, handle__viewportEvent, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEditBase_virtualbase_viewportEvent(void* self, QEvent* param1);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__viewportSizeHint = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QSize viewportSizeHint() const override {
|
|
if (handle__viewportSizeHint == 0) {
|
|
return ScintillaEditBase::viewportSizeHint();
|
|
}
|
|
|
|
|
|
QSize* callback_return_value = miqt_exec_callback_ScintillaEditBase_viewportSizeHint(this, handle__viewportSizeHint);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
friend QSize* ScintillaEditBase_virtualbase_viewportSizeHint(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__changeEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void changeEvent(QEvent* param1) override {
|
|
if (handle__changeEvent == 0) {
|
|
ScintillaEditBase::changeEvent(param1);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = param1;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_changeEvent(this, handle__changeEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_changeEvent(void* self, QEvent* param1);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__devType = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int devType() const override {
|
|
if (handle__devType == 0) {
|
|
return ScintillaEditBase::devType();
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_ScintillaEditBase_devType(this, handle__devType);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
friend int ScintillaEditBase_virtualbase_devType(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__setVisible = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void setVisible(bool visible) override {
|
|
if (handle__setVisible == 0) {
|
|
ScintillaEditBase::setVisible(visible);
|
|
return;
|
|
}
|
|
|
|
bool sigval1 = visible;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_setVisible(this, handle__setVisible, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_setVisible(void* self, bool visible);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__heightForWidth = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int heightForWidth(int param1) const override {
|
|
if (handle__heightForWidth == 0) {
|
|
return ScintillaEditBase::heightForWidth(param1);
|
|
}
|
|
|
|
int sigval1 = param1;
|
|
|
|
int callback_return_value = miqt_exec_callback_ScintillaEditBase_heightForWidth(this, handle__heightForWidth, sigval1);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
friend int ScintillaEditBase_virtualbase_heightForWidth(const void* self, int param1);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__hasHeightForWidth = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool hasHeightForWidth() const override {
|
|
if (handle__hasHeightForWidth == 0) {
|
|
return ScintillaEditBase::hasHeightForWidth();
|
|
}
|
|
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEditBase_hasHeightForWidth(this, handle__hasHeightForWidth);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEditBase_virtualbase_hasHeightForWidth(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__paintEngine = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPaintEngine* paintEngine() const override {
|
|
if (handle__paintEngine == 0) {
|
|
return ScintillaEditBase::paintEngine();
|
|
}
|
|
|
|
|
|
QPaintEngine* callback_return_value = miqt_exec_callback_ScintillaEditBase_paintEngine(this, handle__paintEngine);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend QPaintEngine* ScintillaEditBase_virtualbase_paintEngine(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__keyReleaseEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void keyReleaseEvent(QKeyEvent* event) override {
|
|
if (handle__keyReleaseEvent == 0) {
|
|
ScintillaEditBase::keyReleaseEvent(event);
|
|
return;
|
|
}
|
|
|
|
QKeyEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_keyReleaseEvent(this, handle__keyReleaseEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__enterEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void enterEvent(QEvent* event) override {
|
|
if (handle__enterEvent == 0) {
|
|
ScintillaEditBase::enterEvent(event);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_enterEvent(this, handle__enterEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_enterEvent(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__leaveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void leaveEvent(QEvent* event) override {
|
|
if (handle__leaveEvent == 0) {
|
|
ScintillaEditBase::leaveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_leaveEvent(this, handle__leaveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_leaveEvent(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__moveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void moveEvent(QMoveEvent* event) override {
|
|
if (handle__moveEvent == 0) {
|
|
ScintillaEditBase::moveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMoveEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_moveEvent(this, handle__moveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_moveEvent(void* self, QMoveEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__closeEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void closeEvent(QCloseEvent* event) override {
|
|
if (handle__closeEvent == 0) {
|
|
ScintillaEditBase::closeEvent(event);
|
|
return;
|
|
}
|
|
|
|
QCloseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_closeEvent(this, handle__closeEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_closeEvent(void* self, QCloseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__tabletEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void tabletEvent(QTabletEvent* event) override {
|
|
if (handle__tabletEvent == 0) {
|
|
ScintillaEditBase::tabletEvent(event);
|
|
return;
|
|
}
|
|
|
|
QTabletEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_tabletEvent(this, handle__tabletEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_tabletEvent(void* self, QTabletEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__actionEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void actionEvent(QActionEvent* event) override {
|
|
if (handle__actionEvent == 0) {
|
|
ScintillaEditBase::actionEvent(event);
|
|
return;
|
|
}
|
|
|
|
QActionEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_actionEvent(this, handle__actionEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_actionEvent(void* self, QActionEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__showEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void showEvent(QShowEvent* event) override {
|
|
if (handle__showEvent == 0) {
|
|
ScintillaEditBase::showEvent(event);
|
|
return;
|
|
}
|
|
|
|
QShowEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_showEvent(this, handle__showEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_showEvent(void* self, QShowEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__hideEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void hideEvent(QHideEvent* event) override {
|
|
if (handle__hideEvent == 0) {
|
|
ScintillaEditBase::hideEvent(event);
|
|
return;
|
|
}
|
|
|
|
QHideEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_hideEvent(this, handle__hideEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_hideEvent(void* self, QHideEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__nativeEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result) override {
|
|
if (handle__nativeEvent == 0) {
|
|
return ScintillaEditBase::nativeEvent(eventType, message, result);
|
|
}
|
|
|
|
const QByteArray eventType_qb = eventType;
|
|
struct miqt_string eventType_ms;
|
|
eventType_ms.len = eventType_qb.length();
|
|
eventType_ms.data = static_cast<char*>(malloc(eventType_ms.len));
|
|
memcpy(eventType_ms.data, eventType_qb.data(), eventType_ms.len);
|
|
struct miqt_string sigval1 = eventType_ms;
|
|
void* sigval2 = message;
|
|
long* sigval3 = result;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEditBase_nativeEvent(this, handle__nativeEvent, sigval1, sigval2, sigval3);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEditBase_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, long* result);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__metric = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric param1) const override {
|
|
if (handle__metric == 0) {
|
|
return ScintillaEditBase::metric(param1);
|
|
}
|
|
|
|
QPaintDevice::PaintDeviceMetric param1_ret = param1;
|
|
int sigval1 = static_cast<int>(param1_ret);
|
|
|
|
int callback_return_value = miqt_exec_callback_ScintillaEditBase_metric(this, handle__metric, sigval1);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
friend int ScintillaEditBase_virtualbase_metric(const void* self, int param1);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__initPainter = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void initPainter(QPainter* painter) const override {
|
|
if (handle__initPainter == 0) {
|
|
ScintillaEditBase::initPainter(painter);
|
|
return;
|
|
}
|
|
|
|
QPainter* sigval1 = painter;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_initPainter(this, handle__initPainter, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_initPainter(const void* self, QPainter* painter);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__redirected = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPaintDevice* redirected(QPoint* offset) const override {
|
|
if (handle__redirected == 0) {
|
|
return ScintillaEditBase::redirected(offset);
|
|
}
|
|
|
|
QPoint* sigval1 = offset;
|
|
|
|
QPaintDevice* callback_return_value = miqt_exec_callback_ScintillaEditBase_redirected(this, handle__redirected, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend QPaintDevice* ScintillaEditBase_virtualbase_redirected(const void* self, QPoint* offset);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__sharedPainter = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPainter* sharedPainter() const override {
|
|
if (handle__sharedPainter == 0) {
|
|
return ScintillaEditBase::sharedPainter();
|
|
}
|
|
|
|
|
|
QPainter* callback_return_value = miqt_exec_callback_ScintillaEditBase_sharedPainter(this, handle__sharedPainter);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend QPainter* ScintillaEditBase_virtualbase_sharedPainter(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__focusNextPrevChild = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool focusNextPrevChild(bool next) override {
|
|
if (handle__focusNextPrevChild == 0) {
|
|
return ScintillaEditBase::focusNextPrevChild(next);
|
|
}
|
|
|
|
bool sigval1 = next;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEditBase_focusNextPrevChild(this, handle__focusNextPrevChild, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEditBase_virtualbase_focusNextPrevChild(void* self, bool next);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__timerEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void timerEvent(QTimerEvent* event) override {
|
|
if (handle__timerEvent == 0) {
|
|
ScintillaEditBase::timerEvent(event);
|
|
return;
|
|
}
|
|
|
|
QTimerEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_timerEvent(this, handle__timerEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_timerEvent(void* self, QTimerEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__childEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void childEvent(QChildEvent* event) override {
|
|
if (handle__childEvent == 0) {
|
|
ScintillaEditBase::childEvent(event);
|
|
return;
|
|
}
|
|
|
|
QChildEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_childEvent(this, handle__childEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_childEvent(void* self, QChildEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__customEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void customEvent(QEvent* event) override {
|
|
if (handle__customEvent == 0) {
|
|
ScintillaEditBase::customEvent(event);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEditBase_customEvent(this, handle__customEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_customEvent(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__connectNotify = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void connectNotify(const QMetaMethod& signal) override {
|
|
if (handle__connectNotify == 0) {
|
|
ScintillaEditBase::connectNotify(signal);
|
|
return;
|
|
}
|
|
|
|
const QMetaMethod& signal_ret = signal;
|
|
// Cast returned reference into pointer
|
|
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
|
|
|
|
miqt_exec_callback_ScintillaEditBase_connectNotify(this, handle__connectNotify, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_connectNotify(void* self, QMetaMethod* signal);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__disconnectNotify = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void disconnectNotify(const QMetaMethod& signal) override {
|
|
if (handle__disconnectNotify == 0) {
|
|
ScintillaEditBase::disconnectNotify(signal);
|
|
return;
|
|
}
|
|
|
|
const QMetaMethod& signal_ret = signal;
|
|
// Cast returned reference into pointer
|
|
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
|
|
|
|
miqt_exec_callback_ScintillaEditBase_disconnectNotify(this, handle__disconnectNotify, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEditBase_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
|
|
|
|
// Wrappers to allow calling protected methods:
|
|
friend void ScintillaEditBase_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom);
|
|
friend QMargins* ScintillaEditBase_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self);
|
|
friend void ScintillaEditBase_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1);
|
|
friend void ScintillaEditBase_protectedbase_initStyleOption(bool* _dynamic_cast_ok, const void* self, QStyleOptionFrame* option);
|
|
friend void ScintillaEditBase_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self);
|
|
friend void ScintillaEditBase_protectedbase_create(bool* _dynamic_cast_ok, void* self);
|
|
friend void ScintillaEditBase_protectedbase_destroy(bool* _dynamic_cast_ok, void* self);
|
|
friend bool ScintillaEditBase_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self);
|
|
friend bool ScintillaEditBase_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self);
|
|
friend QObject* ScintillaEditBase_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
|
|
friend int ScintillaEditBase_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
|
|
friend int ScintillaEditBase_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
|
|
friend bool ScintillaEditBase_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
|
|
};
|
|
|
|
ScintillaEditBase* ScintillaEditBase_new(QWidget* parent) {
|
|
return new MiqtVirtualScintillaEditBase(parent);
|
|
}
|
|
|
|
ScintillaEditBase* ScintillaEditBase_new2() {
|
|
return new MiqtVirtualScintillaEditBase();
|
|
}
|
|
|
|
void ScintillaEditBase_virtbase(ScintillaEditBase* src, QAbstractScrollArea** outptr_QAbstractScrollArea) {
|
|
*outptr_QAbstractScrollArea = static_cast<QAbstractScrollArea*>(src);
|
|
}
|
|
|
|
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<char*>(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<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _b.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
intptr_t ScintillaEditBase_send(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam, intptr_t lParam) {
|
|
sptr_t _ret = self->send(static_cast<unsigned int>(iMessage), static_cast<uptr_t>(wParam), static_cast<sptr_t>(lParam));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEditBase_sends(const ScintillaEditBase* self, unsigned int iMessage, uintptr_t wParam, const char* s) {
|
|
sptr_t _ret = self->sends(static_cast<unsigned int>(iMessage), static_cast<uptr_t>(wParam), s);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEditBase_scrollHorizontal(ScintillaEditBase* self, int value) {
|
|
self->scrollHorizontal(static_cast<int>(value));
|
|
}
|
|
|
|
void ScintillaEditBase_scrollVertical(ScintillaEditBase* self, int value) {
|
|
self->scrollVertical(static_cast<int>(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<Scintilla::uptr_t>(wParam), static_cast<Scintilla::sptr_t>(lParam));
|
|
}
|
|
|
|
void ScintillaEditBase_horizontalScrolled(ScintillaEditBase* self, int value) {
|
|
self->horizontalScrolled(static_cast<int>(value));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_horizontalScrolled(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(int)>(&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<int>(value));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_verticalScrolled(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(int)>(&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<int>(max), static_cast<int>(page));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_horizontalRangeChanged(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(int, int)>(&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<int>(max), static_cast<int>(page));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_verticalRangeChanged(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(int, int)>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)()>(&ScintillaEditBase::notifyChange), self, [=]() {
|
|
miqt_exec_callback_ScintillaEditBase_notifyChange(slot);
|
|
});
|
|
}
|
|
|
|
void ScintillaEditBase_linesAdded(ScintillaEditBase* self, intptr_t linesAdded) {
|
|
self->linesAdded(static_cast<Scintilla::Position>(linesAdded));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_linesAdded(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Position)>(&ScintillaEditBase::linesAdded), self, [=](Scintilla::Position linesAdded) {
|
|
Scintilla::Position linesAdded_ret = linesAdded;
|
|
intptr_t sigval1 = static_cast<intptr_t>(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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(QMimeData*)>(&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<Scintilla::Position>(position));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_styleNeeded(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Position)>(&ScintillaEditBase::styleNeeded), self, [=](Scintilla::Position position) {
|
|
Scintilla::Position position_ret = position;
|
|
intptr_t sigval1 = static_cast<intptr_t>(position_ret);
|
|
miqt_exec_callback_ScintillaEditBase_styleNeeded(slot, sigval1);
|
|
});
|
|
}
|
|
|
|
void ScintillaEditBase_charAdded(ScintillaEditBase* self, int ch) {
|
|
self->charAdded(static_cast<int>(ch));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_charAdded(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(int)>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(bool)>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)()>(&ScintillaEditBase::modifyAttemptReadOnly), self, [=]() {
|
|
miqt_exec_callback_ScintillaEditBase_modifyAttemptReadOnly(slot);
|
|
});
|
|
}
|
|
|
|
void ScintillaEditBase_key(ScintillaEditBase* self, int key) {
|
|
self->key(static_cast<int>(key));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_key(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(int)>(&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<Scintilla::Position>(position), static_cast<Scintilla::Position>(line));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_doubleClick(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Position, Scintilla::Position)>(&ScintillaEditBase::doubleClick), self, [=](Scintilla::Position position, Scintilla::Position line) {
|
|
Scintilla::Position position_ret = position;
|
|
intptr_t sigval1 = static_cast<intptr_t>(position_ret);
|
|
Scintilla::Position line_ret = line;
|
|
intptr_t sigval2 = static_cast<intptr_t>(line_ret);
|
|
miqt_exec_callback_ScintillaEditBase_doubleClick(slot, sigval1, sigval2);
|
|
});
|
|
}
|
|
|
|
void ScintillaEditBase_updateUi(ScintillaEditBase* self, int updated) {
|
|
self->updateUi(static_cast<Scintilla::Update>(updated));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_updateUi(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Update)>(&ScintillaEditBase::updateUi), self, [=](Scintilla::Update updated) {
|
|
Scintilla::Update updated_ret = updated;
|
|
int sigval1 = static_cast<int>(updated_ret);
|
|
miqt_exec_callback_ScintillaEditBase_updateUi(slot, sigval1);
|
|
});
|
|
}
|
|
|
|
void ScintillaEditBase_modified(ScintillaEditBase* self, int type, 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<Scintilla::ModificationFlags>(type), static_cast<Scintilla::Position>(position), static_cast<Scintilla::Position>(length), static_cast<Scintilla::Position>(linesAdded), text_QByteArray, static_cast<Scintilla::Position>(line), static_cast<Scintilla::FoldLevel>(foldNow), static_cast<Scintilla::FoldLevel>(foldPrev));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_modified(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::ModificationFlags, Scintilla::Position, Scintilla::Position, Scintilla::Position, const QByteArray&, Scintilla::Position, Scintilla::FoldLevel, Scintilla::FoldLevel)>(&ScintillaEditBase::modified), self, [=](Scintilla::ModificationFlags type, Scintilla::Position position, Scintilla::Position length, Scintilla::Position linesAdded, const QByteArray& text, Scintilla::Position line, Scintilla::FoldLevel foldNow, Scintilla::FoldLevel foldPrev) {
|
|
Scintilla::ModificationFlags type_ret = type;
|
|
int sigval1 = static_cast<int>(type_ret);
|
|
Scintilla::Position position_ret = position;
|
|
intptr_t sigval2 = static_cast<intptr_t>(position_ret);
|
|
Scintilla::Position length_ret = length;
|
|
intptr_t sigval3 = static_cast<intptr_t>(length_ret);
|
|
Scintilla::Position linesAdded_ret = linesAdded;
|
|
intptr_t sigval4 = static_cast<intptr_t>(linesAdded_ret);
|
|
const QByteArray text_qb = text;
|
|
struct miqt_string text_ms;
|
|
text_ms.len = text_qb.length();
|
|
text_ms.data = static_cast<char*>(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<intptr_t>(line_ret);
|
|
Scintilla::FoldLevel foldNow_ret = foldNow;
|
|
int sigval7 = static_cast<int>(foldNow_ret);
|
|
Scintilla::FoldLevel foldPrev_ret = foldPrev;
|
|
int sigval8 = static_cast<int>(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<Scintilla::Message>(message), static_cast<Scintilla::uptr_t>(wParam), static_cast<Scintilla::sptr_t>(lParam));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_macroRecord(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Message, Scintilla::uptr_t, Scintilla::sptr_t)>(&ScintillaEditBase::macroRecord), self, [=](Scintilla::Message message, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) {
|
|
Scintilla::Message message_ret = message;
|
|
int sigval1 = static_cast<int>(message_ret);
|
|
Scintilla::uptr_t wParam_ret = wParam;
|
|
uintptr_t sigval2 = static_cast<uintptr_t>(wParam_ret);
|
|
Scintilla::sptr_t lParam_ret = lParam;
|
|
intptr_t sigval3 = static_cast<intptr_t>(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<Scintilla::Position>(position), static_cast<Scintilla::KeyMod>(modifiers), static_cast<int>(margin));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_marginClicked(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Position, Scintilla::KeyMod, int)>(&ScintillaEditBase::marginClicked), self, [=](Scintilla::Position position, Scintilla::KeyMod modifiers, int margin) {
|
|
Scintilla::Position position_ret = position;
|
|
intptr_t sigval1 = static_cast<intptr_t>(position_ret);
|
|
Scintilla::KeyMod modifiers_ret = modifiers;
|
|
int sigval2 = static_cast<int>(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<Scintilla::Position>(line), static_cast<int>(modifiers));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_textAreaClicked(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Position, int)>(&ScintillaEditBase::textAreaClicked), self, [=](Scintilla::Position line, int modifiers) {
|
|
Scintilla::Position line_ret = line;
|
|
intptr_t sigval1 = static_cast<intptr_t>(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<Scintilla::Position>(position), static_cast<Scintilla::Position>(length));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_needShown(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Position, Scintilla::Position)>(&ScintillaEditBase::needShown), self, [=](Scintilla::Position position, Scintilla::Position length) {
|
|
Scintilla::Position position_ret = position;
|
|
intptr_t sigval1 = static_cast<intptr_t>(position_ret);
|
|
Scintilla::Position length_ret = length;
|
|
intptr_t sigval2 = static_cast<intptr_t>(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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)()>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)()>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(const QString&)>(&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<char*>(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<int>(x), static_cast<int>(y));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_dwellStart(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(int, int)>(&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<int>(x), static_cast<int>(y));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_dwellEnd(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(int, int)>(&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<int>(zoom));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_zoom(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(int)>(&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<Scintilla::Position>(position), static_cast<Scintilla::KeyMod>(modifiers));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_hotSpotClick(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Position, Scintilla::KeyMod)>(&ScintillaEditBase::hotSpotClick), self, [=](Scintilla::Position position, Scintilla::KeyMod modifiers) {
|
|
Scintilla::Position position_ret = position;
|
|
intptr_t sigval1 = static_cast<intptr_t>(position_ret);
|
|
Scintilla::KeyMod modifiers_ret = modifiers;
|
|
int sigval2 = static_cast<int>(modifiers_ret);
|
|
miqt_exec_callback_ScintillaEditBase_hotSpotClick(slot, sigval1, sigval2);
|
|
});
|
|
}
|
|
|
|
void ScintillaEditBase_hotSpotDoubleClick(ScintillaEditBase* self, intptr_t position, int modifiers) {
|
|
self->hotSpotDoubleClick(static_cast<Scintilla::Position>(position), static_cast<Scintilla::KeyMod>(modifiers));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_hotSpotDoubleClick(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Position, Scintilla::KeyMod)>(&ScintillaEditBase::hotSpotDoubleClick), self, [=](Scintilla::Position position, Scintilla::KeyMod modifiers) {
|
|
Scintilla::Position position_ret = position;
|
|
intptr_t sigval1 = static_cast<intptr_t>(position_ret);
|
|
Scintilla::KeyMod modifiers_ret = modifiers;
|
|
int sigval2 = static_cast<int>(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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)()>(&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<Scintilla::Position>(position), text_QString);
|
|
}
|
|
|
|
void ScintillaEditBase_connect_autoCompleteSelection(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::Position, const QString&)>(&ScintillaEditBase::autoCompleteSelection), self, [=](Scintilla::Position position, const QString& text) {
|
|
Scintilla::Position position_ret = position;
|
|
intptr_t sigval1 = static_cast<intptr_t>(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<char*>(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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)()>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(bool)>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::NotificationData*)>(&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<Scintilla::uptr_t>(wParam), static_cast<Scintilla::sptr_t>(lParam));
|
|
}
|
|
|
|
void ScintillaEditBase_connect_command(ScintillaEditBase* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(Scintilla::uptr_t, Scintilla::sptr_t)>(&ScintillaEditBase::command), self, [=](Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) {
|
|
Scintilla::uptr_t wParam_ret = wParam;
|
|
uintptr_t sigval1 = static_cast<uintptr_t>(wParam_ret);
|
|
Scintilla::sptr_t lParam_ret = lParam;
|
|
intptr_t sigval2 = static_cast<intptr_t>(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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(QMouseEvent*)>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(QMouseEvent*)>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)(QKeyEvent*)>(&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) {
|
|
MiqtVirtualScintillaEditBase::connect(self, static_cast<void (ScintillaEditBase::*)()>(&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<char*>(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<int>(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<char*>(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<char*>(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<int>(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<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _b.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_send(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__send = slot;
|
|
return true;
|
|
}
|
|
|
|
intptr_t ScintillaEditBase_virtualbase_send(const void* self, unsigned int iMessage, uintptr_t wParam, intptr_t lParam) {
|
|
|
|
sptr_t _ret = ( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::send(static_cast<unsigned int>(iMessage), static_cast<uptr_t>(wParam), static_cast<sptr_t>(lParam));
|
|
return static_cast<intptr_t>(_ret);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_sends(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__sends = slot;
|
|
return true;
|
|
}
|
|
|
|
intptr_t ScintillaEditBase_virtualbase_sends(const void* self, unsigned int iMessage, uintptr_t wParam, const char* s) {
|
|
|
|
sptr_t _ret = ( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::sends(static_cast<unsigned int>(iMessage), static_cast<uptr_t>(wParam), s);
|
|
return static_cast<intptr_t>(_ret);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_event(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__event = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEditBase_virtualbase_event(void* self, QEvent* event) {
|
|
|
|
return ( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::event(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_paintEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__paintEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_paintEvent(void* self, QPaintEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::paintEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_wheelEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__wheelEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_wheelEvent(void* self, QWheelEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::wheelEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_focusInEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__focusInEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_focusInEvent(void* self, QFocusEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::focusInEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_focusOutEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__focusOutEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_focusOutEvent(void* self, QFocusEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::focusOutEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_resizeEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__resizeEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_resizeEvent(void* self, QResizeEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::resizeEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_keyPressEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__keyPressEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_keyPressEvent(void* self, QKeyEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::keyPressEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_mousePressEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__mousePressEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_mousePressEvent(void* self, QMouseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::mousePressEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_mouseReleaseEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__mouseReleaseEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::mouseReleaseEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__mouseDoubleClickEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::mouseDoubleClickEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_mouseMoveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__mouseMoveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_mouseMoveEvent(void* self, QMouseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::mouseMoveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_contextMenuEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__contextMenuEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::contextMenuEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_dragEnterEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__dragEnterEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::dragEnterEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_dragLeaveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__dragLeaveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::dragLeaveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_dragMoveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__dragMoveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::dragMoveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_dropEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__dropEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_dropEvent(void* self, QDropEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::dropEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_inputMethodEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__inputMethodEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::inputMethodEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_inputMethodQuery(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__inputMethodQuery = slot;
|
|
return true;
|
|
}
|
|
|
|
QVariant* ScintillaEditBase_virtualbase_inputMethodQuery(const void* self, int query) {
|
|
|
|
return new QVariant(( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_scrollContentsBy(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__scrollContentsBy = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_scrollContentsBy(void* self, int param1, int param2) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::scrollContentsBy(static_cast<int>(param1), static_cast<int>(param2));
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_minimumSizeHint(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__minimumSizeHint = slot;
|
|
return true;
|
|
}
|
|
|
|
QSize* ScintillaEditBase_virtualbase_minimumSizeHint(const void* self) {
|
|
|
|
return new QSize(( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::minimumSizeHint());
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_sizeHint(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__sizeHint = slot;
|
|
return true;
|
|
}
|
|
|
|
QSize* ScintillaEditBase_virtualbase_sizeHint(const void* self) {
|
|
|
|
return new QSize(( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::sizeHint());
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_setupViewport(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__setupViewport = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_setupViewport(void* self, QWidget* viewport) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::setupViewport(viewport);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_eventFilter(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__eventFilter = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEditBase_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2) {
|
|
|
|
return ( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::eventFilter(param1, param2);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_viewportEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__viewportEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEditBase_virtualbase_viewportEvent(void* self, QEvent* param1) {
|
|
|
|
return ( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::viewportEvent(param1);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_viewportSizeHint(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__viewportSizeHint = slot;
|
|
return true;
|
|
}
|
|
|
|
QSize* ScintillaEditBase_virtualbase_viewportSizeHint(const void* self) {
|
|
|
|
return new QSize(( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::viewportSizeHint());
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_changeEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__changeEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_changeEvent(void* self, QEvent* param1) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::changeEvent(param1);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_devType(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__devType = slot;
|
|
return true;
|
|
}
|
|
|
|
int ScintillaEditBase_virtualbase_devType(const void* self) {
|
|
|
|
return ( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::devType();
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_setVisible(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__setVisible = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_setVisible(void* self, bool visible) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::setVisible(visible);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_heightForWidth(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__heightForWidth = slot;
|
|
return true;
|
|
}
|
|
|
|
int ScintillaEditBase_virtualbase_heightForWidth(const void* self, int param1) {
|
|
|
|
return ( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::heightForWidth(static_cast<int>(param1));
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_hasHeightForWidth(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__hasHeightForWidth = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEditBase_virtualbase_hasHeightForWidth(const void* self) {
|
|
|
|
return ( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::hasHeightForWidth();
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_paintEngine(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__paintEngine = slot;
|
|
return true;
|
|
}
|
|
|
|
QPaintEngine* ScintillaEditBase_virtualbase_paintEngine(const void* self) {
|
|
|
|
return ( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::paintEngine();
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_keyReleaseEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__keyReleaseEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::keyReleaseEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_enterEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__enterEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_enterEvent(void* self, QEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::enterEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_leaveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__leaveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_leaveEvent(void* self, QEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::leaveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_moveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__moveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_moveEvent(void* self, QMoveEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::moveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_closeEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__closeEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_closeEvent(void* self, QCloseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::closeEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_tabletEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__tabletEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_tabletEvent(void* self, QTabletEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::tabletEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_actionEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__actionEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_actionEvent(void* self, QActionEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::actionEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_showEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__showEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_showEvent(void* self, QShowEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::showEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_hideEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__hideEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_hideEvent(void* self, QHideEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::hideEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_nativeEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__nativeEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEditBase_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, long* result) {
|
|
QByteArray eventType_QByteArray(eventType.data, eventType.len);
|
|
|
|
return ( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::nativeEvent(eventType_QByteArray, message, static_cast<long*>(result));
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_metric(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__metric = slot;
|
|
return true;
|
|
}
|
|
|
|
int ScintillaEditBase_virtualbase_metric(const void* self, int param1) {
|
|
|
|
return ( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::metric(static_cast<MiqtVirtualScintillaEditBase::PaintDeviceMetric>(param1));
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_initPainter(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__initPainter = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_initPainter(const void* self, QPainter* painter) {
|
|
|
|
( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::initPainter(painter);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_redirected(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__redirected = slot;
|
|
return true;
|
|
}
|
|
|
|
QPaintDevice* ScintillaEditBase_virtualbase_redirected(const void* self, QPoint* offset) {
|
|
|
|
return ( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::redirected(offset);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_sharedPainter(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__sharedPainter = slot;
|
|
return true;
|
|
}
|
|
|
|
QPainter* ScintillaEditBase_virtualbase_sharedPainter(const void* self) {
|
|
|
|
return ( (const MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::sharedPainter();
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_focusNextPrevChild(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__focusNextPrevChild = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEditBase_virtualbase_focusNextPrevChild(void* self, bool next) {
|
|
|
|
return ( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::focusNextPrevChild(next);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_timerEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__timerEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_timerEvent(void* self, QTimerEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::timerEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_childEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__childEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_childEvent(void* self, QChildEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::childEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_customEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__customEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_customEvent(void* self, QEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::customEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_connectNotify(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__connectNotify = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::connectNotify(*signal);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_override_virtual_disconnectNotify(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__disconnectNotify = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEditBase_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
|
|
|
|
( (MiqtVirtualScintillaEditBase*)(self) )->MiqtVirtualScintillaEditBase::disconnectNotify(*signal);
|
|
|
|
}
|
|
|
|
void ScintillaEditBase_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->setViewportMargins(static_cast<int>(left), static_cast<int>(top), static_cast<int>(right), static_cast<int>(bottom));
|
|
|
|
}
|
|
|
|
QMargins* ScintillaEditBase_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return nullptr;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return new QMargins(self_cast->viewportMargins());
|
|
|
|
}
|
|
|
|
void ScintillaEditBase_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->drawFrame(param1);
|
|
|
|
}
|
|
|
|
void ScintillaEditBase_protectedbase_initStyleOption(bool* _dynamic_cast_ok, const void* self, QStyleOptionFrame* option) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->initStyleOption(option);
|
|
|
|
}
|
|
|
|
void ScintillaEditBase_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->updateMicroFocus();
|
|
|
|
}
|
|
|
|
void ScintillaEditBase_protectedbase_create(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->create();
|
|
|
|
}
|
|
|
|
void ScintillaEditBase_protectedbase_destroy(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->destroy();
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return false;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->focusNextChild();
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return false;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->focusPreviousChild();
|
|
|
|
}
|
|
|
|
QObject* ScintillaEditBase_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return nullptr;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->sender();
|
|
|
|
}
|
|
|
|
int ScintillaEditBase_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return 0;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->senderSignalIndex();
|
|
|
|
}
|
|
|
|
int ScintillaEditBase_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return 0;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->receivers(signal);
|
|
|
|
}
|
|
|
|
bool ScintillaEditBase_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
|
|
MiqtVirtualScintillaEditBase* self_cast = dynamic_cast<MiqtVirtualScintillaEditBase*>( (ScintillaEditBase*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return false;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->isSignalConnected(*signal);
|
|
|
|
}
|
|
|
|
void ScintillaEditBase_delete(ScintillaEditBase* self) {
|
|
delete self;
|
|
}
|
|
|
|
class MiqtVirtualScintillaDocument final : public ScintillaDocument {
|
|
public:
|
|
|
|
MiqtVirtualScintillaDocument(): ScintillaDocument() {};
|
|
MiqtVirtualScintillaDocument(QObject* parent): ScintillaDocument(parent) {};
|
|
MiqtVirtualScintillaDocument(QObject* parent, void* pdoc_): ScintillaDocument(parent, pdoc_) {};
|
|
|
|
virtual ~MiqtVirtualScintillaDocument() override = default;
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__event = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool event(QEvent* event) override {
|
|
if (handle__event == 0) {
|
|
return ScintillaDocument::event(event);
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaDocument_event(this, handle__event, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaDocument_virtualbase_event(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__eventFilter = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool eventFilter(QObject* watched, QEvent* event) override {
|
|
if (handle__eventFilter == 0) {
|
|
return ScintillaDocument::eventFilter(watched, event);
|
|
}
|
|
|
|
QObject* sigval1 = watched;
|
|
QEvent* sigval2 = event;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaDocument_eventFilter(this, handle__eventFilter, sigval1, sigval2);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaDocument_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__timerEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void timerEvent(QTimerEvent* event) override {
|
|
if (handle__timerEvent == 0) {
|
|
ScintillaDocument::timerEvent(event);
|
|
return;
|
|
}
|
|
|
|
QTimerEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaDocument_timerEvent(this, handle__timerEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaDocument_virtualbase_timerEvent(void* self, QTimerEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__childEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void childEvent(QChildEvent* event) override {
|
|
if (handle__childEvent == 0) {
|
|
ScintillaDocument::childEvent(event);
|
|
return;
|
|
}
|
|
|
|
QChildEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaDocument_childEvent(this, handle__childEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaDocument_virtualbase_childEvent(void* self, QChildEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__customEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void customEvent(QEvent* event) override {
|
|
if (handle__customEvent == 0) {
|
|
ScintillaDocument::customEvent(event);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaDocument_customEvent(this, handle__customEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaDocument_virtualbase_customEvent(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__connectNotify = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void connectNotify(const QMetaMethod& signal) override {
|
|
if (handle__connectNotify == 0) {
|
|
ScintillaDocument::connectNotify(signal);
|
|
return;
|
|
}
|
|
|
|
const QMetaMethod& signal_ret = signal;
|
|
// Cast returned reference into pointer
|
|
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
|
|
|
|
miqt_exec_callback_ScintillaDocument_connectNotify(this, handle__connectNotify, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaDocument_virtualbase_connectNotify(void* self, QMetaMethod* signal);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__disconnectNotify = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void disconnectNotify(const QMetaMethod& signal) override {
|
|
if (handle__disconnectNotify == 0) {
|
|
ScintillaDocument::disconnectNotify(signal);
|
|
return;
|
|
}
|
|
|
|
const QMetaMethod& signal_ret = signal;
|
|
// Cast returned reference into pointer
|
|
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
|
|
|
|
miqt_exec_callback_ScintillaDocument_disconnectNotify(this, handle__disconnectNotify, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaDocument_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
|
|
|
|
// Wrappers to allow calling protected methods:
|
|
friend QObject* ScintillaDocument_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
|
|
friend int ScintillaDocument_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
|
|
friend int ScintillaDocument_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
|
|
friend bool ScintillaDocument_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
|
|
};
|
|
|
|
ScintillaDocument* ScintillaDocument_new() {
|
|
return new MiqtVirtualScintillaDocument();
|
|
}
|
|
|
|
ScintillaDocument* ScintillaDocument_new2(QObject* parent) {
|
|
return new MiqtVirtualScintillaDocument(parent);
|
|
}
|
|
|
|
ScintillaDocument* ScintillaDocument_new3(QObject* parent, void* pdoc_) {
|
|
return new MiqtVirtualScintillaDocument(parent, pdoc_);
|
|
}
|
|
|
|
void ScintillaDocument_virtbase(ScintillaDocument* src, QObject** outptr_QObject) {
|
|
*outptr_QObject = static_cast<QObject*>(src);
|
|
}
|
|
|
|
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<char*>(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<char*>(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<int>(pos));
|
|
}
|
|
|
|
bool ScintillaDocument_isCrLf(ScintillaDocument* self, int pos) {
|
|
return self->is_cr_lf(static_cast<int>(pos));
|
|
}
|
|
|
|
bool ScintillaDocument_deleteChars(ScintillaDocument* self, int pos, int len) {
|
|
return self->delete_chars(static_cast<int>(pos), static_cast<int>(len));
|
|
}
|
|
|
|
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<int>(position), str_QByteArray);
|
|
}
|
|
|
|
struct miqt_string ScintillaDocument_getCharRange(ScintillaDocument* self, int position, int length) {
|
|
QByteArray _qb = self->get_char_range(static_cast<int>(position), static_cast<int>(length));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<int>(position));
|
|
}
|
|
|
|
int ScintillaDocument_lineStart(ScintillaDocument* self, int lineno) {
|
|
return self->line_start(static_cast<int>(lineno));
|
|
}
|
|
|
|
int ScintillaDocument_lineEnd(ScintillaDocument* self, int lineno) {
|
|
return self->line_end(static_cast<int>(lineno));
|
|
}
|
|
|
|
int ScintillaDocument_lineEndPosition(ScintillaDocument* self, int pos) {
|
|
return self->line_end_position(static_cast<int>(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<int>(position));
|
|
}
|
|
|
|
bool ScintillaDocument_setStyleFor(ScintillaDocument* self, int length, char style) {
|
|
return self->set_style_for(static_cast<int>(length), static_cast<char>(style));
|
|
}
|
|
|
|
int ScintillaDocument_getEndStyled(ScintillaDocument* self) {
|
|
return self->get_end_styled();
|
|
}
|
|
|
|
void ScintillaDocument_ensureStyledTo(ScintillaDocument* self, int position) {
|
|
self->ensure_styled_to(static_cast<int>(position));
|
|
}
|
|
|
|
void ScintillaDocument_setCurrentIndicator(ScintillaDocument* self, int indic) {
|
|
self->set_current_indicator(static_cast<int>(indic));
|
|
}
|
|
|
|
void ScintillaDocument_decorationFillRange(ScintillaDocument* self, int position, int value, int fillLength) {
|
|
self->decoration_fill_range(static_cast<int>(position), static_cast<int>(value), static_cast<int>(fillLength));
|
|
}
|
|
|
|
int ScintillaDocument_decorationsValueAt(ScintillaDocument* self, int indic, int position) {
|
|
return self->decorations_value_at(static_cast<int>(indic), static_cast<int>(position));
|
|
}
|
|
|
|
int ScintillaDocument_decorationsStart(ScintillaDocument* self, int indic, int position) {
|
|
return self->decorations_start(static_cast<int>(indic), static_cast<int>(position));
|
|
}
|
|
|
|
int ScintillaDocument_decorationsEnd(ScintillaDocument* self, int indic, int position) {
|
|
return self->decorations_end(static_cast<int>(indic), static_cast<int>(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<int>(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<int>(eol_mode));
|
|
}
|
|
|
|
int ScintillaDocument_movePositionOutsideChar(ScintillaDocument* self, int pos, int move_dir, bool check_line_end) {
|
|
return self->move_position_outside_char(static_cast<int>(pos), static_cast<int>(move_dir), check_line_end);
|
|
}
|
|
|
|
int ScintillaDocument_getCharacter(ScintillaDocument* self, int pos) {
|
|
return self->get_character(static_cast<int>(pos));
|
|
}
|
|
|
|
void ScintillaDocument_modifyAttempt(ScintillaDocument* self) {
|
|
self->modify_attempt();
|
|
}
|
|
|
|
void ScintillaDocument_connect_modifyAttempt(ScintillaDocument* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument::connect(self, static_cast<void (ScintillaDocument::*)()>(&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) {
|
|
MiqtVirtualScintillaDocument::connect(self, static_cast<void (ScintillaDocument::*)(bool)>(&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<int>(position), static_cast<int>(modification_type), text_QByteArray, static_cast<int>(length), static_cast<int>(linesAdded), static_cast<int>(line), static_cast<int>(foldLevelNow), static_cast<int>(foldLevelPrev));
|
|
}
|
|
|
|
void ScintillaDocument_connect_modified(ScintillaDocument* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument::connect(self, static_cast<void (ScintillaDocument::*)(int, int, const QByteArray&, int, int, int, int, int)>(&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<char*>(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<int>(pos));
|
|
}
|
|
|
|
void ScintillaDocument_connect_styleNeeded(ScintillaDocument* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument::connect(self, static_cast<void (ScintillaDocument::*)(int)>(&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<int>(status));
|
|
}
|
|
|
|
void ScintillaDocument_connect_errorOccurred(ScintillaDocument* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument::connect(self, static_cast<void (ScintillaDocument::*)(int)>(&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<char*>(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<int>(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<char*>(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<char*>(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<int>(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<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _b.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
void ScintillaDocument_beginUndoAction1(ScintillaDocument* self, bool coalesceWithPrior) {
|
|
self->begin_undo_action(coalesceWithPrior);
|
|
}
|
|
|
|
bool ScintillaDocument_override_virtual_event(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__event = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaDocument_virtualbase_event(void* self, QEvent* event) {
|
|
|
|
return ( (MiqtVirtualScintillaDocument*)(self) )->MiqtVirtualScintillaDocument::event(event);
|
|
|
|
}
|
|
|
|
bool ScintillaDocument_override_virtual_eventFilter(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__eventFilter = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaDocument_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
|
|
|
|
return ( (MiqtVirtualScintillaDocument*)(self) )->MiqtVirtualScintillaDocument::eventFilter(watched, event);
|
|
|
|
}
|
|
|
|
bool ScintillaDocument_override_virtual_timerEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__timerEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaDocument_virtualbase_timerEvent(void* self, QTimerEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaDocument*)(self) )->MiqtVirtualScintillaDocument::timerEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaDocument_override_virtual_childEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__childEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaDocument_virtualbase_childEvent(void* self, QChildEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaDocument*)(self) )->MiqtVirtualScintillaDocument::childEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaDocument_override_virtual_customEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__customEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaDocument_virtualbase_customEvent(void* self, QEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaDocument*)(self) )->MiqtVirtualScintillaDocument::customEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaDocument_override_virtual_connectNotify(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__connectNotify = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaDocument_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
|
|
|
|
( (MiqtVirtualScintillaDocument*)(self) )->MiqtVirtualScintillaDocument::connectNotify(*signal);
|
|
|
|
}
|
|
|
|
bool ScintillaDocument_override_virtual_disconnectNotify(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__disconnectNotify = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaDocument_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
|
|
|
|
( (MiqtVirtualScintillaDocument*)(self) )->MiqtVirtualScintillaDocument::disconnectNotify(*signal);
|
|
|
|
}
|
|
|
|
QObject* ScintillaDocument_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return nullptr;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->sender();
|
|
|
|
}
|
|
|
|
int ScintillaDocument_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return 0;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->senderSignalIndex();
|
|
|
|
}
|
|
|
|
int ScintillaDocument_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return 0;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->receivers(signal);
|
|
|
|
}
|
|
|
|
bool ScintillaDocument_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
|
|
MiqtVirtualScintillaDocument* self_cast = dynamic_cast<MiqtVirtualScintillaDocument*>( (ScintillaDocument*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return false;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->isSignalConnected(*signal);
|
|
|
|
}
|
|
|
|
void ScintillaDocument_delete(ScintillaDocument* self) {
|
|
delete self;
|
|
}
|
|
|
|
class MiqtVirtualScintillaEdit final : public ScintillaEdit {
|
|
public:
|
|
|
|
MiqtVirtualScintillaEdit(QWidget* parent): ScintillaEdit(parent) {};
|
|
MiqtVirtualScintillaEdit(): ScintillaEdit() {};
|
|
|
|
virtual ~MiqtVirtualScintillaEdit() override = default;
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__send = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual sptr_t send(unsigned int iMessage, uptr_t wParam, sptr_t lParam) const override {
|
|
if (handle__send == 0) {
|
|
return ScintillaEdit::send(iMessage, wParam, lParam);
|
|
}
|
|
|
|
unsigned int sigval1 = iMessage;
|
|
uptr_t wParam_ret = wParam;
|
|
uintptr_t sigval2 = static_cast<uintptr_t>(wParam_ret);
|
|
sptr_t lParam_ret = lParam;
|
|
intptr_t sigval3 = static_cast<intptr_t>(lParam_ret);
|
|
|
|
intptr_t callback_return_value = miqt_exec_callback_ScintillaEdit_send(this, handle__send, sigval1, sigval2, sigval3);
|
|
|
|
return static_cast<sptr_t>(callback_return_value);
|
|
}
|
|
|
|
friend intptr_t ScintillaEdit_virtualbase_send(const void* self, unsigned int iMessage, uintptr_t wParam, intptr_t lParam);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__sends = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual sptr_t sends(unsigned int iMessage, uptr_t wParam, const char* s) const override {
|
|
if (handle__sends == 0) {
|
|
return ScintillaEdit::sends(iMessage, wParam, s);
|
|
}
|
|
|
|
unsigned int sigval1 = iMessage;
|
|
uptr_t wParam_ret = wParam;
|
|
uintptr_t sigval2 = static_cast<uintptr_t>(wParam_ret);
|
|
const char* sigval3 = (const char*) s;
|
|
|
|
intptr_t callback_return_value = miqt_exec_callback_ScintillaEdit_sends(this, handle__sends, sigval1, sigval2, sigval3);
|
|
|
|
return static_cast<sptr_t>(callback_return_value);
|
|
}
|
|
|
|
friend intptr_t ScintillaEdit_virtualbase_sends(const void* self, unsigned int iMessage, uintptr_t wParam, const char* s);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__event = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool event(QEvent* event) override {
|
|
if (handle__event == 0) {
|
|
return ScintillaEdit::event(event);
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEdit_event(this, handle__event, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEdit_virtualbase_event(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__paintEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void paintEvent(QPaintEvent* event) override {
|
|
if (handle__paintEvent == 0) {
|
|
ScintillaEdit::paintEvent(event);
|
|
return;
|
|
}
|
|
|
|
QPaintEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_paintEvent(this, handle__paintEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_paintEvent(void* self, QPaintEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__wheelEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void wheelEvent(QWheelEvent* event) override {
|
|
if (handle__wheelEvent == 0) {
|
|
ScintillaEdit::wheelEvent(event);
|
|
return;
|
|
}
|
|
|
|
QWheelEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_wheelEvent(this, handle__wheelEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_wheelEvent(void* self, QWheelEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__focusInEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void focusInEvent(QFocusEvent* event) override {
|
|
if (handle__focusInEvent == 0) {
|
|
ScintillaEdit::focusInEvent(event);
|
|
return;
|
|
}
|
|
|
|
QFocusEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_focusInEvent(this, handle__focusInEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_focusInEvent(void* self, QFocusEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__focusOutEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void focusOutEvent(QFocusEvent* event) override {
|
|
if (handle__focusOutEvent == 0) {
|
|
ScintillaEdit::focusOutEvent(event);
|
|
return;
|
|
}
|
|
|
|
QFocusEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_focusOutEvent(this, handle__focusOutEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__resizeEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void resizeEvent(QResizeEvent* event) override {
|
|
if (handle__resizeEvent == 0) {
|
|
ScintillaEdit::resizeEvent(event);
|
|
return;
|
|
}
|
|
|
|
QResizeEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_resizeEvent(this, handle__resizeEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_resizeEvent(void* self, QResizeEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__keyPressEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void keyPressEvent(QKeyEvent* event) override {
|
|
if (handle__keyPressEvent == 0) {
|
|
ScintillaEdit::keyPressEvent(event);
|
|
return;
|
|
}
|
|
|
|
QKeyEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_keyPressEvent(this, handle__keyPressEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__mousePressEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void mousePressEvent(QMouseEvent* event) override {
|
|
if (handle__mousePressEvent == 0) {
|
|
ScintillaEdit::mousePressEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMouseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_mousePressEvent(this, handle__mousePressEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_mousePressEvent(void* self, QMouseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__mouseReleaseEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void mouseReleaseEvent(QMouseEvent* event) override {
|
|
if (handle__mouseReleaseEvent == 0) {
|
|
ScintillaEdit::mouseReleaseEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMouseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_mouseReleaseEvent(this, handle__mouseReleaseEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__mouseDoubleClickEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void mouseDoubleClickEvent(QMouseEvent* event) override {
|
|
if (handle__mouseDoubleClickEvent == 0) {
|
|
ScintillaEdit::mouseDoubleClickEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMouseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_mouseDoubleClickEvent(this, handle__mouseDoubleClickEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__mouseMoveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void mouseMoveEvent(QMouseEvent* event) override {
|
|
if (handle__mouseMoveEvent == 0) {
|
|
ScintillaEdit::mouseMoveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMouseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_mouseMoveEvent(this, handle__mouseMoveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_mouseMoveEvent(void* self, QMouseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__contextMenuEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void contextMenuEvent(QContextMenuEvent* event) override {
|
|
if (handle__contextMenuEvent == 0) {
|
|
ScintillaEdit::contextMenuEvent(event);
|
|
return;
|
|
}
|
|
|
|
QContextMenuEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_contextMenuEvent(this, handle__contextMenuEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__dragEnterEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void dragEnterEvent(QDragEnterEvent* event) override {
|
|
if (handle__dragEnterEvent == 0) {
|
|
ScintillaEdit::dragEnterEvent(event);
|
|
return;
|
|
}
|
|
|
|
QDragEnterEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_dragEnterEvent(this, handle__dragEnterEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__dragLeaveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* event) override {
|
|
if (handle__dragLeaveEvent == 0) {
|
|
ScintillaEdit::dragLeaveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QDragLeaveEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_dragLeaveEvent(this, handle__dragLeaveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__dragMoveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void dragMoveEvent(QDragMoveEvent* event) override {
|
|
if (handle__dragMoveEvent == 0) {
|
|
ScintillaEdit::dragMoveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QDragMoveEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_dragMoveEvent(this, handle__dragMoveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__dropEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void dropEvent(QDropEvent* event) override {
|
|
if (handle__dropEvent == 0) {
|
|
ScintillaEdit::dropEvent(event);
|
|
return;
|
|
}
|
|
|
|
QDropEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_dropEvent(this, handle__dropEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_dropEvent(void* self, QDropEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__inputMethodEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void inputMethodEvent(QInputMethodEvent* event) override {
|
|
if (handle__inputMethodEvent == 0) {
|
|
ScintillaEdit::inputMethodEvent(event);
|
|
return;
|
|
}
|
|
|
|
QInputMethodEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_inputMethodEvent(this, handle__inputMethodEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__inputMethodQuery = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const override {
|
|
if (handle__inputMethodQuery == 0) {
|
|
return ScintillaEdit::inputMethodQuery(query);
|
|
}
|
|
|
|
Qt::InputMethodQuery query_ret = query;
|
|
int sigval1 = static_cast<int>(query_ret);
|
|
|
|
QVariant* callback_return_value = miqt_exec_callback_ScintillaEdit_inputMethodQuery(this, handle__inputMethodQuery, sigval1);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
friend QVariant* ScintillaEdit_virtualbase_inputMethodQuery(const void* self, int query);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__scrollContentsBy = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void scrollContentsBy(int param1, int param2) override {
|
|
if (handle__scrollContentsBy == 0) {
|
|
ScintillaEdit::scrollContentsBy(param1, param2);
|
|
return;
|
|
}
|
|
|
|
int sigval1 = param1;
|
|
int sigval2 = param2;
|
|
|
|
miqt_exec_callback_ScintillaEdit_scrollContentsBy(this, handle__scrollContentsBy, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_scrollContentsBy(void* self, int param1, int param2);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__minimumSizeHint = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QSize minimumSizeHint() const override {
|
|
if (handle__minimumSizeHint == 0) {
|
|
return ScintillaEdit::minimumSizeHint();
|
|
}
|
|
|
|
|
|
QSize* callback_return_value = miqt_exec_callback_ScintillaEdit_minimumSizeHint(this, handle__minimumSizeHint);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
friend QSize* ScintillaEdit_virtualbase_minimumSizeHint(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__sizeHint = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QSize sizeHint() const override {
|
|
if (handle__sizeHint == 0) {
|
|
return ScintillaEdit::sizeHint();
|
|
}
|
|
|
|
|
|
QSize* callback_return_value = miqt_exec_callback_ScintillaEdit_sizeHint(this, handle__sizeHint);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
friend QSize* ScintillaEdit_virtualbase_sizeHint(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__setupViewport = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void setupViewport(QWidget* viewport) override {
|
|
if (handle__setupViewport == 0) {
|
|
ScintillaEdit::setupViewport(viewport);
|
|
return;
|
|
}
|
|
|
|
QWidget* sigval1 = viewport;
|
|
|
|
miqt_exec_callback_ScintillaEdit_setupViewport(this, handle__setupViewport, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_setupViewport(void* self, QWidget* viewport);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__eventFilter = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool eventFilter(QObject* param1, QEvent* param2) override {
|
|
if (handle__eventFilter == 0) {
|
|
return ScintillaEdit::eventFilter(param1, param2);
|
|
}
|
|
|
|
QObject* sigval1 = param1;
|
|
QEvent* sigval2 = param2;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEdit_eventFilter(this, handle__eventFilter, sigval1, sigval2);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEdit_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__viewportEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool viewportEvent(QEvent* param1) override {
|
|
if (handle__viewportEvent == 0) {
|
|
return ScintillaEdit::viewportEvent(param1);
|
|
}
|
|
|
|
QEvent* sigval1 = param1;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEdit_viewportEvent(this, handle__viewportEvent, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEdit_virtualbase_viewportEvent(void* self, QEvent* param1);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__viewportSizeHint = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QSize viewportSizeHint() const override {
|
|
if (handle__viewportSizeHint == 0) {
|
|
return ScintillaEdit::viewportSizeHint();
|
|
}
|
|
|
|
|
|
QSize* callback_return_value = miqt_exec_callback_ScintillaEdit_viewportSizeHint(this, handle__viewportSizeHint);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
friend QSize* ScintillaEdit_virtualbase_viewportSizeHint(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__changeEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void changeEvent(QEvent* param1) override {
|
|
if (handle__changeEvent == 0) {
|
|
ScintillaEdit::changeEvent(param1);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = param1;
|
|
|
|
miqt_exec_callback_ScintillaEdit_changeEvent(this, handle__changeEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_changeEvent(void* self, QEvent* param1);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__devType = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int devType() const override {
|
|
if (handle__devType == 0) {
|
|
return ScintillaEdit::devType();
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_ScintillaEdit_devType(this, handle__devType);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
friend int ScintillaEdit_virtualbase_devType(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__setVisible = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void setVisible(bool visible) override {
|
|
if (handle__setVisible == 0) {
|
|
ScintillaEdit::setVisible(visible);
|
|
return;
|
|
}
|
|
|
|
bool sigval1 = visible;
|
|
|
|
miqt_exec_callback_ScintillaEdit_setVisible(this, handle__setVisible, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_setVisible(void* self, bool visible);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__heightForWidth = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int heightForWidth(int param1) const override {
|
|
if (handle__heightForWidth == 0) {
|
|
return ScintillaEdit::heightForWidth(param1);
|
|
}
|
|
|
|
int sigval1 = param1;
|
|
|
|
int callback_return_value = miqt_exec_callback_ScintillaEdit_heightForWidth(this, handle__heightForWidth, sigval1);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
friend int ScintillaEdit_virtualbase_heightForWidth(const void* self, int param1);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__hasHeightForWidth = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool hasHeightForWidth() const override {
|
|
if (handle__hasHeightForWidth == 0) {
|
|
return ScintillaEdit::hasHeightForWidth();
|
|
}
|
|
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEdit_hasHeightForWidth(this, handle__hasHeightForWidth);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEdit_virtualbase_hasHeightForWidth(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__paintEngine = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPaintEngine* paintEngine() const override {
|
|
if (handle__paintEngine == 0) {
|
|
return ScintillaEdit::paintEngine();
|
|
}
|
|
|
|
|
|
QPaintEngine* callback_return_value = miqt_exec_callback_ScintillaEdit_paintEngine(this, handle__paintEngine);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend QPaintEngine* ScintillaEdit_virtualbase_paintEngine(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__keyReleaseEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void keyReleaseEvent(QKeyEvent* event) override {
|
|
if (handle__keyReleaseEvent == 0) {
|
|
ScintillaEdit::keyReleaseEvent(event);
|
|
return;
|
|
}
|
|
|
|
QKeyEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_keyReleaseEvent(this, handle__keyReleaseEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__enterEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void enterEvent(QEvent* event) override {
|
|
if (handle__enterEvent == 0) {
|
|
ScintillaEdit::enterEvent(event);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_enterEvent(this, handle__enterEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_enterEvent(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__leaveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void leaveEvent(QEvent* event) override {
|
|
if (handle__leaveEvent == 0) {
|
|
ScintillaEdit::leaveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_leaveEvent(this, handle__leaveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_leaveEvent(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__moveEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void moveEvent(QMoveEvent* event) override {
|
|
if (handle__moveEvent == 0) {
|
|
ScintillaEdit::moveEvent(event);
|
|
return;
|
|
}
|
|
|
|
QMoveEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_moveEvent(this, handle__moveEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_moveEvent(void* self, QMoveEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__closeEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void closeEvent(QCloseEvent* event) override {
|
|
if (handle__closeEvent == 0) {
|
|
ScintillaEdit::closeEvent(event);
|
|
return;
|
|
}
|
|
|
|
QCloseEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_closeEvent(this, handle__closeEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_closeEvent(void* self, QCloseEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__tabletEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void tabletEvent(QTabletEvent* event) override {
|
|
if (handle__tabletEvent == 0) {
|
|
ScintillaEdit::tabletEvent(event);
|
|
return;
|
|
}
|
|
|
|
QTabletEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_tabletEvent(this, handle__tabletEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_tabletEvent(void* self, QTabletEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__actionEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void actionEvent(QActionEvent* event) override {
|
|
if (handle__actionEvent == 0) {
|
|
ScintillaEdit::actionEvent(event);
|
|
return;
|
|
}
|
|
|
|
QActionEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_actionEvent(this, handle__actionEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_actionEvent(void* self, QActionEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__showEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void showEvent(QShowEvent* event) override {
|
|
if (handle__showEvent == 0) {
|
|
ScintillaEdit::showEvent(event);
|
|
return;
|
|
}
|
|
|
|
QShowEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_showEvent(this, handle__showEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_showEvent(void* self, QShowEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__hideEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void hideEvent(QHideEvent* event) override {
|
|
if (handle__hideEvent == 0) {
|
|
ScintillaEdit::hideEvent(event);
|
|
return;
|
|
}
|
|
|
|
QHideEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_hideEvent(this, handle__hideEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_hideEvent(void* self, QHideEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__nativeEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result) override {
|
|
if (handle__nativeEvent == 0) {
|
|
return ScintillaEdit::nativeEvent(eventType, message, result);
|
|
}
|
|
|
|
const QByteArray eventType_qb = eventType;
|
|
struct miqt_string eventType_ms;
|
|
eventType_ms.len = eventType_qb.length();
|
|
eventType_ms.data = static_cast<char*>(malloc(eventType_ms.len));
|
|
memcpy(eventType_ms.data, eventType_qb.data(), eventType_ms.len);
|
|
struct miqt_string sigval1 = eventType_ms;
|
|
void* sigval2 = message;
|
|
long* sigval3 = result;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEdit_nativeEvent(this, handle__nativeEvent, sigval1, sigval2, sigval3);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEdit_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, long* result);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__metric = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric param1) const override {
|
|
if (handle__metric == 0) {
|
|
return ScintillaEdit::metric(param1);
|
|
}
|
|
|
|
QPaintDevice::PaintDeviceMetric param1_ret = param1;
|
|
int sigval1 = static_cast<int>(param1_ret);
|
|
|
|
int callback_return_value = miqt_exec_callback_ScintillaEdit_metric(this, handle__metric, sigval1);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
friend int ScintillaEdit_virtualbase_metric(const void* self, int param1);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__initPainter = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void initPainter(QPainter* painter) const override {
|
|
if (handle__initPainter == 0) {
|
|
ScintillaEdit::initPainter(painter);
|
|
return;
|
|
}
|
|
|
|
QPainter* sigval1 = painter;
|
|
|
|
miqt_exec_callback_ScintillaEdit_initPainter(this, handle__initPainter, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_initPainter(const void* self, QPainter* painter);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__redirected = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPaintDevice* redirected(QPoint* offset) const override {
|
|
if (handle__redirected == 0) {
|
|
return ScintillaEdit::redirected(offset);
|
|
}
|
|
|
|
QPoint* sigval1 = offset;
|
|
|
|
QPaintDevice* callback_return_value = miqt_exec_callback_ScintillaEdit_redirected(this, handle__redirected, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend QPaintDevice* ScintillaEdit_virtualbase_redirected(const void* self, QPoint* offset);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__sharedPainter = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPainter* sharedPainter() const override {
|
|
if (handle__sharedPainter == 0) {
|
|
return ScintillaEdit::sharedPainter();
|
|
}
|
|
|
|
|
|
QPainter* callback_return_value = miqt_exec_callback_ScintillaEdit_sharedPainter(this, handle__sharedPainter);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend QPainter* ScintillaEdit_virtualbase_sharedPainter(const void* self);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__focusNextPrevChild = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool focusNextPrevChild(bool next) override {
|
|
if (handle__focusNextPrevChild == 0) {
|
|
return ScintillaEdit::focusNextPrevChild(next);
|
|
}
|
|
|
|
bool sigval1 = next;
|
|
|
|
bool callback_return_value = miqt_exec_callback_ScintillaEdit_focusNextPrevChild(this, handle__focusNextPrevChild, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
friend bool ScintillaEdit_virtualbase_focusNextPrevChild(void* self, bool next);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__timerEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void timerEvent(QTimerEvent* event) override {
|
|
if (handle__timerEvent == 0) {
|
|
ScintillaEdit::timerEvent(event);
|
|
return;
|
|
}
|
|
|
|
QTimerEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_timerEvent(this, handle__timerEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_timerEvent(void* self, QTimerEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__childEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void childEvent(QChildEvent* event) override {
|
|
if (handle__childEvent == 0) {
|
|
ScintillaEdit::childEvent(event);
|
|
return;
|
|
}
|
|
|
|
QChildEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_childEvent(this, handle__childEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_childEvent(void* self, QChildEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__customEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void customEvent(QEvent* event) override {
|
|
if (handle__customEvent == 0) {
|
|
ScintillaEdit::customEvent(event);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_ScintillaEdit_customEvent(this, handle__customEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_customEvent(void* self, QEvent* event);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__connectNotify = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void connectNotify(const QMetaMethod& signal) override {
|
|
if (handle__connectNotify == 0) {
|
|
ScintillaEdit::connectNotify(signal);
|
|
return;
|
|
}
|
|
|
|
const QMetaMethod& signal_ret = signal;
|
|
// Cast returned reference into pointer
|
|
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
|
|
|
|
miqt_exec_callback_ScintillaEdit_connectNotify(this, handle__connectNotify, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_connectNotify(void* self, QMetaMethod* signal);
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__disconnectNotify = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void disconnectNotify(const QMetaMethod& signal) override {
|
|
if (handle__disconnectNotify == 0) {
|
|
ScintillaEdit::disconnectNotify(signal);
|
|
return;
|
|
}
|
|
|
|
const QMetaMethod& signal_ret = signal;
|
|
// Cast returned reference into pointer
|
|
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
|
|
|
|
miqt_exec_callback_ScintillaEdit_disconnectNotify(this, handle__disconnectNotify, sigval1);
|
|
|
|
|
|
}
|
|
|
|
friend void ScintillaEdit_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
|
|
|
|
// Wrappers to allow calling protected methods:
|
|
friend void ScintillaEdit_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom);
|
|
friend QMargins* ScintillaEdit_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self);
|
|
friend void ScintillaEdit_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1);
|
|
friend void ScintillaEdit_protectedbase_initStyleOption(bool* _dynamic_cast_ok, const void* self, QStyleOptionFrame* option);
|
|
friend void ScintillaEdit_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self);
|
|
friend void ScintillaEdit_protectedbase_create(bool* _dynamic_cast_ok, void* self);
|
|
friend void ScintillaEdit_protectedbase_destroy(bool* _dynamic_cast_ok, void* self);
|
|
friend bool ScintillaEdit_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self);
|
|
friend bool ScintillaEdit_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self);
|
|
friend QObject* ScintillaEdit_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
|
|
friend int ScintillaEdit_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
|
|
friend int ScintillaEdit_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
|
|
friend bool ScintillaEdit_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
|
|
};
|
|
|
|
ScintillaEdit* ScintillaEdit_new(QWidget* parent) {
|
|
return new MiqtVirtualScintillaEdit(parent);
|
|
}
|
|
|
|
ScintillaEdit* ScintillaEdit_new2() {
|
|
return new MiqtVirtualScintillaEdit();
|
|
}
|
|
|
|
void ScintillaEdit_virtbase(ScintillaEdit* src, ScintillaEditBase** outptr_ScintillaEditBase) {
|
|
*outptr_ScintillaEditBase = static_cast<ScintillaEditBase*>(src);
|
|
}
|
|
|
|
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<char*>(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<char*>(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<int>(message), static_cast<uptr_t>(wParam));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _qb.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
struct miqt_map /* tuple of int and int */ ScintillaEdit_findText(ScintillaEdit* self, int flags, const char* text, int cpMin, int cpMax) {
|
|
QPair<int, int> _ret = self->find_text(static_cast<int>(flags), text, static_cast<int>(cpMin), static_cast<int>(cpMax));
|
|
// Convert QPair<> from C++ memory to manually-managed C memory
|
|
int* _first_arr = static_cast<int*>(malloc(sizeof(int)));
|
|
int* _second_arr = static_cast<int*>(malloc(sizeof(int)));
|
|
_first_arr[0] = _ret.first;
|
|
_second_arr[0] = _ret.second;
|
|
struct miqt_map _out;
|
|
_out.len = 1;
|
|
_out.keys = static_cast<void*>(_first_arr);
|
|
_out.values = static_cast<void*>(_second_arr);
|
|
return _out;
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_getTextRange(ScintillaEdit* self, int start, int end) {
|
|
QByteArray _qb = self->get_text_range(static_cast<int>(start), static_cast<int>(end));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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_map /* tuple of int and int */ ScintillaEdit_findText2(ScintillaEdit* self, int flags, const char* text, int cpMin, int cpMax) {
|
|
QPair<int, int> _ret = self->findText(static_cast<int>(flags), text, static_cast<int>(cpMin), static_cast<int>(cpMax));
|
|
// Convert QPair<> from C++ memory to manually-managed C memory
|
|
int* _first_arr = static_cast<int*>(malloc(sizeof(int)));
|
|
int* _second_arr = static_cast<int*>(malloc(sizeof(int)));
|
|
_first_arr[0] = _ret.first;
|
|
_second_arr[0] = _ret.second;
|
|
struct miqt_map _out;
|
|
_out.len = 1;
|
|
_out.keys = static_cast<void*>(_first_arr);
|
|
_out.values = static_cast<void*>(_second_arr);
|
|
return _out;
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_textRange(ScintillaEdit* self, int start, int end) {
|
|
QByteArray _qb = self->textRange(static_cast<int>(start), static_cast<int>(end));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<long>(range_start), static_cast<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) {
|
|
return self->formatRange(draw, target, measure, *print_rect, *page_rect, static_cast<long>(range_start), static_cast<long>(range_end));
|
|
}
|
|
|
|
void ScintillaEdit_addText(ScintillaEdit* self, intptr_t length, const char* text) {
|
|
self->addText(static_cast<sptr_t>(length), text);
|
|
}
|
|
|
|
void ScintillaEdit_addStyledText(ScintillaEdit* self, intptr_t length, const char* c) {
|
|
self->addStyledText(static_cast<sptr_t>(length), c);
|
|
}
|
|
|
|
void ScintillaEdit_insertText(ScintillaEdit* self, intptr_t pos, const char* text) {
|
|
self->insertText(static_cast<sptr_t>(pos), text);
|
|
}
|
|
|
|
void ScintillaEdit_changeInsertion(ScintillaEdit* self, intptr_t length, const char* text) {
|
|
self->changeInsertion(static_cast<sptr_t>(length), text);
|
|
}
|
|
|
|
void ScintillaEdit_clearAll(ScintillaEdit* self) {
|
|
self->clearAll();
|
|
}
|
|
|
|
void ScintillaEdit_deleteRange(ScintillaEdit* self, intptr_t start, intptr_t lengthDelete) {
|
|
self->deleteRange(static_cast<sptr_t>(start), static_cast<sptr_t>(lengthDelete));
|
|
}
|
|
|
|
void ScintillaEdit_clearDocumentStyle(ScintillaEdit* self) {
|
|
self->clearDocumentStyle();
|
|
}
|
|
|
|
intptr_t ScintillaEdit_length(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->length();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_charAt(const ScintillaEdit* self, intptr_t pos) {
|
|
sptr_t _ret = self->charAt(static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_currentPos(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->currentPos();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_anchor(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->anchor();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleAt(const ScintillaEdit* self, intptr_t pos) {
|
|
sptr_t _ret = self->styleAt(static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleIndexAt(const ScintillaEdit* self, intptr_t pos) {
|
|
sptr_t _ret = self->styleIndexAt(static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_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<sptr_t>(markerHandle));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_markerDeleteHandle(ScintillaEdit* self, intptr_t markerHandle) {
|
|
self->markerDeleteHandle(static_cast<sptr_t>(markerHandle));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_markerHandleFromLine(ScintillaEdit* self, intptr_t line, intptr_t which) {
|
|
sptr_t _ret = self->markerHandleFromLine(static_cast<sptr_t>(line), static_cast<sptr_t>(which));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_markerNumberFromLine(ScintillaEdit* self, intptr_t line, intptr_t which) {
|
|
sptr_t _ret = self->markerNumberFromLine(static_cast<sptr_t>(line), static_cast<sptr_t>(which));
|
|
return static_cast<intptr_t>(_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<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setViewWS(ScintillaEdit* self, intptr_t viewWS) {
|
|
self->setViewWS(static_cast<sptr_t>(viewWS));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_tabDrawMode(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->tabDrawMode();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setTabDrawMode(ScintillaEdit* self, intptr_t tabDrawMode) {
|
|
self->setTabDrawMode(static_cast<sptr_t>(tabDrawMode));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_positionFromPoint(ScintillaEdit* self, intptr_t x, intptr_t y) {
|
|
sptr_t _ret = self->positionFromPoint(static_cast<sptr_t>(x), static_cast<sptr_t>(y));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_positionFromPointClose(ScintillaEdit* self, intptr_t x, intptr_t y) {
|
|
sptr_t _ret = self->positionFromPointClose(static_cast<sptr_t>(x), static_cast<sptr_t>(y));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_gotoLine(ScintillaEdit* self, intptr_t line) {
|
|
self->gotoLine(static_cast<sptr_t>(line));
|
|
}
|
|
|
|
void ScintillaEdit_gotoPos(ScintillaEdit* self, intptr_t caret) {
|
|
self->gotoPos(static_cast<sptr_t>(caret));
|
|
}
|
|
|
|
void ScintillaEdit_setAnchor(ScintillaEdit* self, intptr_t anchor) {
|
|
self->setAnchor(static_cast<sptr_t>(anchor));
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_getCurLine(ScintillaEdit* self, intptr_t length) {
|
|
QByteArray _qb = self->getCurLine(static_cast<sptr_t>(length));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_convertEOLs(ScintillaEdit* self, intptr_t eolMode) {
|
|
self->convertEOLs(static_cast<sptr_t>(eolMode));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_eOLMode(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->eOLMode();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setEOLMode(ScintillaEdit* self, intptr_t eolMode) {
|
|
self->setEOLMode(static_cast<sptr_t>(eolMode));
|
|
}
|
|
|
|
void ScintillaEdit_startStyling(ScintillaEdit* self, intptr_t start, intptr_t unused) {
|
|
self->startStyling(static_cast<sptr_t>(start), static_cast<sptr_t>(unused));
|
|
}
|
|
|
|
void ScintillaEdit_setStyling(ScintillaEdit* self, intptr_t length, intptr_t style) {
|
|
self->setStyling(static_cast<sptr_t>(length), static_cast<sptr_t>(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<sptr_t>(tabWidth));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_tabWidth(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->tabWidth();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setTabMinimumWidth(ScintillaEdit* self, intptr_t pixels) {
|
|
self->setTabMinimumWidth(static_cast<sptr_t>(pixels));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_tabMinimumWidth(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->tabMinimumWidth();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_clearTabStops(ScintillaEdit* self, intptr_t line) {
|
|
self->clearTabStops(static_cast<sptr_t>(line));
|
|
}
|
|
|
|
void ScintillaEdit_addTabStop(ScintillaEdit* self, intptr_t line, intptr_t x) {
|
|
self->addTabStop(static_cast<sptr_t>(line), static_cast<sptr_t>(x));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_getNextTabStop(ScintillaEdit* self, intptr_t line, intptr_t x) {
|
|
sptr_t _ret = self->getNextTabStop(static_cast<sptr_t>(line), static_cast<sptr_t>(x));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setCodePage(ScintillaEdit* self, intptr_t codePage) {
|
|
self->setCodePage(static_cast<sptr_t>(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<char*>(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<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setIMEInteraction(ScintillaEdit* self, intptr_t imeInteraction) {
|
|
self->setIMEInteraction(static_cast<sptr_t>(imeInteraction));
|
|
}
|
|
|
|
void ScintillaEdit_markerDefine(ScintillaEdit* self, intptr_t markerNumber, intptr_t markerSymbol) {
|
|
self->markerDefine(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(markerSymbol));
|
|
}
|
|
|
|
void ScintillaEdit_markerSetFore(ScintillaEdit* self, intptr_t markerNumber, intptr_t fore) {
|
|
self->markerSetFore(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_markerSetBack(ScintillaEdit* self, intptr_t markerNumber, intptr_t back) {
|
|
self->markerSetBack(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(back));
|
|
}
|
|
|
|
void ScintillaEdit_markerSetBackSelected(ScintillaEdit* self, intptr_t markerNumber, intptr_t back) {
|
|
self->markerSetBackSelected(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(back));
|
|
}
|
|
|
|
void ScintillaEdit_markerSetForeTranslucent(ScintillaEdit* self, intptr_t markerNumber, intptr_t fore) {
|
|
self->markerSetForeTranslucent(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_markerSetBackTranslucent(ScintillaEdit* self, intptr_t markerNumber, intptr_t back) {
|
|
self->markerSetBackTranslucent(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(back));
|
|
}
|
|
|
|
void ScintillaEdit_markerSetBackSelectedTranslucent(ScintillaEdit* self, intptr_t markerNumber, intptr_t back) {
|
|
self->markerSetBackSelectedTranslucent(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(back));
|
|
}
|
|
|
|
void ScintillaEdit_markerSetStrokeWidth(ScintillaEdit* self, intptr_t markerNumber, intptr_t hundredths) {
|
|
self->markerSetStrokeWidth(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(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<sptr_t>(line), static_cast<sptr_t>(markerNumber));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_markerDelete(ScintillaEdit* self, intptr_t line, intptr_t markerNumber) {
|
|
self->markerDelete(static_cast<sptr_t>(line), static_cast<sptr_t>(markerNumber));
|
|
}
|
|
|
|
void ScintillaEdit_markerDeleteAll(ScintillaEdit* self, intptr_t markerNumber) {
|
|
self->markerDeleteAll(static_cast<sptr_t>(markerNumber));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_markerGet(ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->markerGet(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_markerNext(ScintillaEdit* self, intptr_t lineStart, intptr_t markerMask) {
|
|
sptr_t _ret = self->markerNext(static_cast<sptr_t>(lineStart), static_cast<sptr_t>(markerMask));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_markerPrevious(ScintillaEdit* self, intptr_t lineStart, intptr_t markerMask) {
|
|
sptr_t _ret = self->markerPrevious(static_cast<sptr_t>(lineStart), static_cast<sptr_t>(markerMask));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_markerDefinePixmap(ScintillaEdit* self, intptr_t markerNumber, const char* pixmap) {
|
|
self->markerDefinePixmap(static_cast<sptr_t>(markerNumber), pixmap);
|
|
}
|
|
|
|
void ScintillaEdit_markerAddSet(ScintillaEdit* self, intptr_t line, intptr_t markerSet) {
|
|
self->markerAddSet(static_cast<sptr_t>(line), static_cast<sptr_t>(markerSet));
|
|
}
|
|
|
|
void ScintillaEdit_markerSetAlpha(ScintillaEdit* self, intptr_t markerNumber, intptr_t alpha) {
|
|
self->markerSetAlpha(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(alpha));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_markerLayer(const ScintillaEdit* self, intptr_t markerNumber) {
|
|
sptr_t _ret = self->markerLayer(static_cast<sptr_t>(markerNumber));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_markerSetLayer(ScintillaEdit* self, intptr_t markerNumber, intptr_t layer) {
|
|
self->markerSetLayer(static_cast<sptr_t>(markerNumber), static_cast<sptr_t>(layer));
|
|
}
|
|
|
|
void ScintillaEdit_setMarginTypeN(ScintillaEdit* self, intptr_t margin, intptr_t marginType) {
|
|
self->setMarginTypeN(static_cast<sptr_t>(margin), static_cast<sptr_t>(marginType));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginTypeN(const ScintillaEdit* self, intptr_t margin) {
|
|
sptr_t _ret = self->marginTypeN(static_cast<sptr_t>(margin));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setMarginWidthN(ScintillaEdit* self, intptr_t margin, intptr_t pixelWidth) {
|
|
self->setMarginWidthN(static_cast<sptr_t>(margin), static_cast<sptr_t>(pixelWidth));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginWidthN(const ScintillaEdit* self, intptr_t margin) {
|
|
sptr_t _ret = self->marginWidthN(static_cast<sptr_t>(margin));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setMarginMaskN(ScintillaEdit* self, intptr_t margin, intptr_t mask) {
|
|
self->setMarginMaskN(static_cast<sptr_t>(margin), static_cast<sptr_t>(mask));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginMaskN(const ScintillaEdit* self, intptr_t margin) {
|
|
sptr_t _ret = self->marginMaskN(static_cast<sptr_t>(margin));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setMarginSensitiveN(ScintillaEdit* self, intptr_t margin, bool sensitive) {
|
|
self->setMarginSensitiveN(static_cast<sptr_t>(margin), sensitive);
|
|
}
|
|
|
|
bool ScintillaEdit_marginSensitiveN(const ScintillaEdit* self, intptr_t margin) {
|
|
return self->marginSensitiveN(static_cast<sptr_t>(margin));
|
|
}
|
|
|
|
void ScintillaEdit_setMarginCursorN(ScintillaEdit* self, intptr_t margin, intptr_t cursor) {
|
|
self->setMarginCursorN(static_cast<sptr_t>(margin), static_cast<sptr_t>(cursor));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginCursorN(const ScintillaEdit* self, intptr_t margin) {
|
|
sptr_t _ret = self->marginCursorN(static_cast<sptr_t>(margin));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setMarginBackN(ScintillaEdit* self, intptr_t margin, intptr_t back) {
|
|
self->setMarginBackN(static_cast<sptr_t>(margin), static_cast<sptr_t>(back));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginBackN(const ScintillaEdit* self, intptr_t margin) {
|
|
sptr_t _ret = self->marginBackN(static_cast<sptr_t>(margin));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setMargins(ScintillaEdit* self, intptr_t margins) {
|
|
self->setMargins(static_cast<sptr_t>(margins));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_margins(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->margins();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_styleClearAll(ScintillaEdit* self) {
|
|
self->styleClearAll();
|
|
}
|
|
|
|
void ScintillaEdit_styleSetFore(ScintillaEdit* self, intptr_t style, intptr_t fore) {
|
|
self->styleSetFore(static_cast<sptr_t>(style), static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_styleSetBack(ScintillaEdit* self, intptr_t style, intptr_t back) {
|
|
self->styleSetBack(static_cast<sptr_t>(style), static_cast<sptr_t>(back));
|
|
}
|
|
|
|
void ScintillaEdit_styleSetBold(ScintillaEdit* self, intptr_t style, bool bold) {
|
|
self->styleSetBold(static_cast<sptr_t>(style), bold);
|
|
}
|
|
|
|
void ScintillaEdit_styleSetItalic(ScintillaEdit* self, intptr_t style, bool italic) {
|
|
self->styleSetItalic(static_cast<sptr_t>(style), italic);
|
|
}
|
|
|
|
void ScintillaEdit_styleSetSize(ScintillaEdit* self, intptr_t style, intptr_t sizePoints) {
|
|
self->styleSetSize(static_cast<sptr_t>(style), static_cast<sptr_t>(sizePoints));
|
|
}
|
|
|
|
void ScintillaEdit_styleSetFont(ScintillaEdit* self, intptr_t style, const char* fontName) {
|
|
self->styleSetFont(static_cast<sptr_t>(style), fontName);
|
|
}
|
|
|
|
void ScintillaEdit_styleSetEOLFilled(ScintillaEdit* self, intptr_t style, bool eolFilled) {
|
|
self->styleSetEOLFilled(static_cast<sptr_t>(style), eolFilled);
|
|
}
|
|
|
|
void ScintillaEdit_styleResetDefault(ScintillaEdit* self) {
|
|
self->styleResetDefault();
|
|
}
|
|
|
|
void ScintillaEdit_styleSetUnderline(ScintillaEdit* self, intptr_t style, bool underline) {
|
|
self->styleSetUnderline(static_cast<sptr_t>(style), underline);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleFore(const ScintillaEdit* self, intptr_t style) {
|
|
sptr_t _ret = self->styleFore(static_cast<sptr_t>(style));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleBack(const ScintillaEdit* self, intptr_t style) {
|
|
sptr_t _ret = self->styleBack(static_cast<sptr_t>(style));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
bool ScintillaEdit_styleBold(const ScintillaEdit* self, intptr_t style) {
|
|
return self->styleBold(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
bool ScintillaEdit_styleItalic(const ScintillaEdit* self, intptr_t style) {
|
|
return self->styleItalic(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleSize(const ScintillaEdit* self, intptr_t style) {
|
|
sptr_t _ret = self->styleSize(static_cast<sptr_t>(style));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_styleFont(const ScintillaEdit* self, intptr_t style) {
|
|
QByteArray _qb = self->styleFont(static_cast<sptr_t>(style));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(style));
|
|
}
|
|
|
|
bool ScintillaEdit_styleUnderline(const ScintillaEdit* self, intptr_t style) {
|
|
return self->styleUnderline(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleCase(const ScintillaEdit* self, intptr_t style) {
|
|
sptr_t _ret = self->styleCase(static_cast<sptr_t>(style));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleCharacterSet(const ScintillaEdit* self, intptr_t style) {
|
|
sptr_t _ret = self->styleCharacterSet(static_cast<sptr_t>(style));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
bool ScintillaEdit_styleVisible(const ScintillaEdit* self, intptr_t style) {
|
|
return self->styleVisible(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
bool ScintillaEdit_styleChangeable(const ScintillaEdit* self, intptr_t style) {
|
|
return self->styleChangeable(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
bool ScintillaEdit_styleHotSpot(const ScintillaEdit* self, intptr_t style) {
|
|
return self->styleHotSpot(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
void ScintillaEdit_styleSetCase(ScintillaEdit* self, intptr_t style, intptr_t caseVisible) {
|
|
self->styleSetCase(static_cast<sptr_t>(style), static_cast<sptr_t>(caseVisible));
|
|
}
|
|
|
|
void ScintillaEdit_styleSetSizeFractional(ScintillaEdit* self, intptr_t style, intptr_t sizeHundredthPoints) {
|
|
self->styleSetSizeFractional(static_cast<sptr_t>(style), static_cast<sptr_t>(sizeHundredthPoints));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleSizeFractional(const ScintillaEdit* self, intptr_t style) {
|
|
sptr_t _ret = self->styleSizeFractional(static_cast<sptr_t>(style));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_styleSetWeight(ScintillaEdit* self, intptr_t style, intptr_t weight) {
|
|
self->styleSetWeight(static_cast<sptr_t>(style), static_cast<sptr_t>(weight));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleWeight(const ScintillaEdit* self, intptr_t style) {
|
|
sptr_t _ret = self->styleWeight(static_cast<sptr_t>(style));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_styleSetCharacterSet(ScintillaEdit* self, intptr_t style, intptr_t characterSet) {
|
|
self->styleSetCharacterSet(static_cast<sptr_t>(style), static_cast<sptr_t>(characterSet));
|
|
}
|
|
|
|
void ScintillaEdit_styleSetHotSpot(ScintillaEdit* self, intptr_t style, bool hotspot) {
|
|
self->styleSetHotSpot(static_cast<sptr_t>(style), hotspot);
|
|
}
|
|
|
|
void ScintillaEdit_styleSetCheckMonospaced(ScintillaEdit* self, intptr_t style, bool checkMonospaced) {
|
|
self->styleSetCheckMonospaced(static_cast<sptr_t>(style), checkMonospaced);
|
|
}
|
|
|
|
bool ScintillaEdit_styleCheckMonospaced(const ScintillaEdit* self, intptr_t style) {
|
|
return self->styleCheckMonospaced(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
void ScintillaEdit_styleSetStretch(ScintillaEdit* self, intptr_t style, intptr_t stretch) {
|
|
self->styleSetStretch(static_cast<sptr_t>(style), static_cast<sptr_t>(stretch));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleStretch(const ScintillaEdit* self, intptr_t style) {
|
|
sptr_t _ret = self->styleStretch(static_cast<sptr_t>(style));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_styleSetInvisibleRepresentation(ScintillaEdit* self, intptr_t style, const char* representation) {
|
|
self->styleSetInvisibleRepresentation(static_cast<sptr_t>(style), representation);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_styleInvisibleRepresentation(const ScintillaEdit* self, intptr_t style) {
|
|
QByteArray _qb = self->styleInvisibleRepresentation(static_cast<sptr_t>(style));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(element), static_cast<sptr_t>(colourElement));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_elementColour(const ScintillaEdit* self, intptr_t element) {
|
|
sptr_t _ret = self->elementColour(static_cast<sptr_t>(element));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_resetElementColour(ScintillaEdit* self, intptr_t element) {
|
|
self->resetElementColour(static_cast<sptr_t>(element));
|
|
}
|
|
|
|
bool ScintillaEdit_elementIsSet(const ScintillaEdit* self, intptr_t element) {
|
|
return self->elementIsSet(static_cast<sptr_t>(element));
|
|
}
|
|
|
|
bool ScintillaEdit_elementAllowsTranslucent(const ScintillaEdit* self, intptr_t element) {
|
|
return self->elementAllowsTranslucent(static_cast<sptr_t>(element));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_elementBaseColour(const ScintillaEdit* self, intptr_t element) {
|
|
sptr_t _ret = self->elementBaseColour(static_cast<sptr_t>(element));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelFore(ScintillaEdit* self, bool useSetting, intptr_t fore) {
|
|
self->setSelFore(useSetting, static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_setSelBack(ScintillaEdit* self, bool useSetting, intptr_t back) {
|
|
self->setSelBack(useSetting, static_cast<sptr_t>(back));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selAlpha(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->selAlpha();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelAlpha(ScintillaEdit* self, intptr_t alpha) {
|
|
self->setSelAlpha(static_cast<sptr_t>(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<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionLayer(ScintillaEdit* self, intptr_t layer) {
|
|
self->setSelectionLayer(static_cast<sptr_t>(layer));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_caretLineLayer(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->caretLineLayer();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setCaretLineLayer(ScintillaEdit* self, intptr_t layer) {
|
|
self->setCaretLineLayer(static_cast<sptr_t>(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<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_assignCmdKey(ScintillaEdit* self, intptr_t keyDefinition, intptr_t sciCommand) {
|
|
self->assignCmdKey(static_cast<sptr_t>(keyDefinition), static_cast<sptr_t>(sciCommand));
|
|
}
|
|
|
|
void ScintillaEdit_clearCmdKey(ScintillaEdit* self, intptr_t keyDefinition) {
|
|
self->clearCmdKey(static_cast<sptr_t>(keyDefinition));
|
|
}
|
|
|
|
void ScintillaEdit_clearAllCmdKeys(ScintillaEdit* self) {
|
|
self->clearAllCmdKeys();
|
|
}
|
|
|
|
void ScintillaEdit_setStylingEx(ScintillaEdit* self, intptr_t length, const char* styles) {
|
|
self->setStylingEx(static_cast<sptr_t>(length), styles);
|
|
}
|
|
|
|
void ScintillaEdit_styleSetVisible(ScintillaEdit* self, intptr_t style, bool visible) {
|
|
self->styleSetVisible(static_cast<sptr_t>(style), visible);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_caretPeriod(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->caretPeriod();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setCaretPeriod(ScintillaEdit* self, intptr_t periodMilliseconds) {
|
|
self->setCaretPeriod(static_cast<sptr_t>(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<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _qb.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
void ScintillaEdit_setCharacterCategoryOptimization(ScintillaEdit* self, intptr_t countCharacters) {
|
|
self->setCharacterCategoryOptimization(static_cast<sptr_t>(countCharacters));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_characterCategoryOptimization(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->characterCategoryOptimization();
|
|
return static_cast<intptr_t>(_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<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_undoActions(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->undoActions();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setUndoSavePoint(ScintillaEdit* self, intptr_t action) {
|
|
self->setUndoSavePoint(static_cast<sptr_t>(action));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_undoSavePoint(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->undoSavePoint();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setUndoDetach(ScintillaEdit* self, intptr_t action) {
|
|
self->setUndoDetach(static_cast<sptr_t>(action));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_undoDetach(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->undoDetach();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setUndoTentative(ScintillaEdit* self, intptr_t action) {
|
|
self->setUndoTentative(static_cast<sptr_t>(action));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_undoTentative(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->undoTentative();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setUndoCurrent(ScintillaEdit* self, intptr_t action) {
|
|
self->setUndoCurrent(static_cast<sptr_t>(action));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_undoCurrent(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->undoCurrent();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_pushUndoActionType(ScintillaEdit* self, intptr_t type, intptr_t pos) {
|
|
self->pushUndoActionType(static_cast<sptr_t>(type), static_cast<sptr_t>(pos));
|
|
}
|
|
|
|
void ScintillaEdit_changeLastUndoActionText(ScintillaEdit* self, intptr_t length, const char* text) {
|
|
self->changeLastUndoActionText(static_cast<sptr_t>(length), text);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_undoActionType(const ScintillaEdit* self, intptr_t action) {
|
|
sptr_t _ret = self->undoActionType(static_cast<sptr_t>(action));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_undoActionPosition(const ScintillaEdit* self, intptr_t action) {
|
|
sptr_t _ret = self->undoActionPosition(static_cast<sptr_t>(action));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_undoActionText(const ScintillaEdit* self, intptr_t action) {
|
|
QByteArray _qb = self->undoActionText(static_cast<sptr_t>(action));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(indicator), static_cast<sptr_t>(indicatorStyle));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicStyle(const ScintillaEdit* self, intptr_t indicator) {
|
|
sptr_t _ret = self->indicStyle(static_cast<sptr_t>(indicator));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_indicSetFore(ScintillaEdit* self, intptr_t indicator, intptr_t fore) {
|
|
self->indicSetFore(static_cast<sptr_t>(indicator), static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicFore(const ScintillaEdit* self, intptr_t indicator) {
|
|
sptr_t _ret = self->indicFore(static_cast<sptr_t>(indicator));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_indicSetUnder(ScintillaEdit* self, intptr_t indicator, bool under) {
|
|
self->indicSetUnder(static_cast<sptr_t>(indicator), under);
|
|
}
|
|
|
|
bool ScintillaEdit_indicUnder(const ScintillaEdit* self, intptr_t indicator) {
|
|
return self->indicUnder(static_cast<sptr_t>(indicator));
|
|
}
|
|
|
|
void ScintillaEdit_indicSetHoverStyle(ScintillaEdit* self, intptr_t indicator, intptr_t indicatorStyle) {
|
|
self->indicSetHoverStyle(static_cast<sptr_t>(indicator), static_cast<sptr_t>(indicatorStyle));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicHoverStyle(const ScintillaEdit* self, intptr_t indicator) {
|
|
sptr_t _ret = self->indicHoverStyle(static_cast<sptr_t>(indicator));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_indicSetHoverFore(ScintillaEdit* self, intptr_t indicator, intptr_t fore) {
|
|
self->indicSetHoverFore(static_cast<sptr_t>(indicator), static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicHoverFore(const ScintillaEdit* self, intptr_t indicator) {
|
|
sptr_t _ret = self->indicHoverFore(static_cast<sptr_t>(indicator));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_indicSetFlags(ScintillaEdit* self, intptr_t indicator, intptr_t flags) {
|
|
self->indicSetFlags(static_cast<sptr_t>(indicator), static_cast<sptr_t>(flags));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicFlags(const ScintillaEdit* self, intptr_t indicator) {
|
|
sptr_t _ret = self->indicFlags(static_cast<sptr_t>(indicator));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_indicSetStrokeWidth(ScintillaEdit* self, intptr_t indicator, intptr_t hundredths) {
|
|
self->indicSetStrokeWidth(static_cast<sptr_t>(indicator), static_cast<sptr_t>(hundredths));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicStrokeWidth(const ScintillaEdit* self, intptr_t indicator) {
|
|
sptr_t _ret = self->indicStrokeWidth(static_cast<sptr_t>(indicator));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setWhitespaceFore(ScintillaEdit* self, bool useSetting, intptr_t fore) {
|
|
self->setWhitespaceFore(useSetting, static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_setWhitespaceBack(ScintillaEdit* self, bool useSetting, intptr_t back) {
|
|
self->setWhitespaceBack(useSetting, static_cast<sptr_t>(back));
|
|
}
|
|
|
|
void ScintillaEdit_setWhitespaceSize(ScintillaEdit* self, intptr_t size) {
|
|
self->setWhitespaceSize(static_cast<sptr_t>(size));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_whitespaceSize(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->whitespaceSize();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setLineState(ScintillaEdit* self, intptr_t line, intptr_t state) {
|
|
self->setLineState(static_cast<sptr_t>(line), static_cast<sptr_t>(state));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lineState(const ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->lineState(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_maxLineState(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->maxLineState();
|
|
return static_cast<intptr_t>(_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<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setCaretLineBack(ScintillaEdit* self, intptr_t back) {
|
|
self->setCaretLineBack(static_cast<sptr_t>(back));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_caretLineFrame(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->caretLineFrame();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setCaretLineFrame(ScintillaEdit* self, intptr_t width) {
|
|
self->setCaretLineFrame(static_cast<sptr_t>(width));
|
|
}
|
|
|
|
void ScintillaEdit_styleSetChangeable(ScintillaEdit* self, intptr_t style, bool changeable) {
|
|
self->styleSetChangeable(static_cast<sptr_t>(style), changeable);
|
|
}
|
|
|
|
void ScintillaEdit_autoCShow(ScintillaEdit* self, intptr_t lengthEntered, const char* itemList) {
|
|
self->autoCShow(static_cast<sptr_t>(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<intptr_t>(_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<sptr_t>(separatorCharacter));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_autoCSeparator(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->autoCSeparator();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_autoCSelect(ScintillaEdit* self, const char* select) {
|
|
self->autoCSelect(select);
|
|
}
|
|
|
|
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<sptr_t>(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<sptr_t>(options));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_autoCOptions(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->autoCOptions();
|
|
return static_cast<intptr_t>(_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 type, const char* xpmData) {
|
|
self->registerImage(static_cast<sptr_t>(type), xpmData);
|
|
}
|
|
|
|
void ScintillaEdit_clearRegisteredImages(ScintillaEdit* self) {
|
|
self->clearRegisteredImages();
|
|
}
|
|
|
|
intptr_t ScintillaEdit_autoCTypeSeparator(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->autoCTypeSeparator();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_autoCSetTypeSeparator(ScintillaEdit* self, intptr_t separatorCharacter) {
|
|
self->autoCSetTypeSeparator(static_cast<sptr_t>(separatorCharacter));
|
|
}
|
|
|
|
void ScintillaEdit_autoCSetMaxWidth(ScintillaEdit* self, intptr_t characterCount) {
|
|
self->autoCSetMaxWidth(static_cast<sptr_t>(characterCount));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_autoCMaxWidth(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->autoCMaxWidth();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_autoCSetMaxHeight(ScintillaEdit* self, intptr_t rowCount) {
|
|
self->autoCSetMaxHeight(static_cast<sptr_t>(rowCount));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_autoCMaxHeight(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->autoCMaxHeight();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_autoCSetStyle(ScintillaEdit* self, intptr_t style) {
|
|
self->autoCSetStyle(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_autoCStyle(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->autoCStyle();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setIndent(ScintillaEdit* self, intptr_t indentSize) {
|
|
self->setIndent(static_cast<sptr_t>(indentSize));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indent(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->indent();
|
|
return static_cast<intptr_t>(_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<sptr_t>(line), static_cast<sptr_t>(indentation));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lineIndentation(const ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->lineIndentation(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lineIndentPosition(const ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->lineIndentPosition(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_column(const ScintillaEdit* self, intptr_t pos) {
|
|
sptr_t _ret = self->column(static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_countCharacters(ScintillaEdit* self, intptr_t start, intptr_t end) {
|
|
sptr_t _ret = self->countCharacters(static_cast<sptr_t>(start), static_cast<sptr_t>(end));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_countCodeUnits(ScintillaEdit* self, intptr_t start, intptr_t end) {
|
|
sptr_t _ret = self->countCodeUnits(static_cast<sptr_t>(start), static_cast<sptr_t>(end));
|
|
return static_cast<intptr_t>(_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<sptr_t>(indentView));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indentationGuides(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->indentationGuides();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setHighlightGuide(ScintillaEdit* self, intptr_t column) {
|
|
self->setHighlightGuide(static_cast<sptr_t>(column));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_highlightGuide(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->highlightGuide();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lineEndPosition(const ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->lineEndPosition(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_codePage(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->codePage();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_caretFore(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->caretFore();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
bool ScintillaEdit_readOnly(const ScintillaEdit* self) {
|
|
return self->readOnly();
|
|
}
|
|
|
|
void ScintillaEdit_setCurrentPos(ScintillaEdit* self, intptr_t caret) {
|
|
self->setCurrentPos(static_cast<sptr_t>(caret));
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionStart(ScintillaEdit* self, intptr_t anchor) {
|
|
self->setSelectionStart(static_cast<sptr_t>(anchor));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionStart(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->selectionStart();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionEnd(ScintillaEdit* self, intptr_t caret) {
|
|
self->setSelectionEnd(static_cast<sptr_t>(caret));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionEnd(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->selectionEnd();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setEmptySelection(ScintillaEdit* self, intptr_t caret) {
|
|
self->setEmptySelection(static_cast<sptr_t>(caret));
|
|
}
|
|
|
|
void ScintillaEdit_setPrintMagnification(ScintillaEdit* self, intptr_t magnification) {
|
|
self->setPrintMagnification(static_cast<sptr_t>(magnification));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_printMagnification(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->printMagnification();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setPrintColourMode(ScintillaEdit* self, intptr_t mode) {
|
|
self->setPrintColourMode(static_cast<sptr_t>(mode));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_printColourMode(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->printColourMode();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setChangeHistory(ScintillaEdit* self, intptr_t changeHistory) {
|
|
self->setChangeHistory(static_cast<sptr_t>(changeHistory));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_changeHistory(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->changeHistory();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_firstVisibleLine(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->firstVisibleLine();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_getLine(ScintillaEdit* self, intptr_t line) {
|
|
QByteArray _qb = self->getLine(static_cast<sptr_t>(line));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_allocateLines(ScintillaEdit* self, intptr_t lines) {
|
|
self->allocateLines(static_cast<sptr_t>(lines));
|
|
}
|
|
|
|
void ScintillaEdit_setMarginLeft(ScintillaEdit* self, intptr_t pixelWidth) {
|
|
self->setMarginLeft(static_cast<sptr_t>(pixelWidth));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginLeft(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->marginLeft();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setMarginRight(ScintillaEdit* self, intptr_t pixelWidth) {
|
|
self->setMarginRight(static_cast<sptr_t>(pixelWidth));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginRight(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->marginRight();
|
|
return static_cast<intptr_t>(_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<sptr_t>(anchor), static_cast<sptr_t>(caret));
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_getSelText(ScintillaEdit* self) {
|
|
QByteArray _qb = self->getSelText();
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_pointYFromPosition(ScintillaEdit* self, intptr_t pos) {
|
|
sptr_t _ret = self->pointYFromPosition(static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lineFromPosition(ScintillaEdit* self, intptr_t pos) {
|
|
sptr_t _ret = self->lineFromPosition(static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_positionFromLine(ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->positionFromLine(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_lineScroll(ScintillaEdit* self, intptr_t columns, intptr_t lines) {
|
|
self->lineScroll(static_cast<sptr_t>(columns), static_cast<sptr_t>(lines));
|
|
}
|
|
|
|
void ScintillaEdit_scrollCaret(ScintillaEdit* self) {
|
|
self->scrollCaret();
|
|
}
|
|
|
|
void ScintillaEdit_scrollRange(ScintillaEdit* self, intptr_t secondary, intptr_t primary) {
|
|
self->scrollRange(static_cast<sptr_t>(secondary), static_cast<sptr_t>(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<sptr_t>(length));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_directFunction(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->directFunction();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_directStatusFunction(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->directStatusFunction();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_directPointer(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->directPointer();
|
|
return static_cast<intptr_t>(_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<sptr_t>(pixelWidth));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_caretWidth(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->caretWidth();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setTargetStart(ScintillaEdit* self, intptr_t start) {
|
|
self->setTargetStart(static_cast<sptr_t>(start));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_targetStart(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->targetStart();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setTargetStartVirtualSpace(ScintillaEdit* self, intptr_t space) {
|
|
self->setTargetStartVirtualSpace(static_cast<sptr_t>(space));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_targetStartVirtualSpace(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->targetStartVirtualSpace();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setTargetEnd(ScintillaEdit* self, intptr_t end) {
|
|
self->setTargetEnd(static_cast<sptr_t>(end));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_targetEnd(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->targetEnd();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setTargetEndVirtualSpace(ScintillaEdit* self, intptr_t space) {
|
|
self->setTargetEndVirtualSpace(static_cast<sptr_t>(space));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_targetEndVirtualSpace(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->targetEndVirtualSpace();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setTargetRange(ScintillaEdit* self, intptr_t start, intptr_t end) {
|
|
self->setTargetRange(static_cast<sptr_t>(start), static_cast<sptr_t>(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<char*>(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<sptr_t>(length), text);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_replaceTargetRE(ScintillaEdit* self, intptr_t length, const char* text) {
|
|
sptr_t _ret = self->replaceTargetRE(static_cast<sptr_t>(length), text);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_replaceTargetMinimal(ScintillaEdit* self, intptr_t length, const char* text) {
|
|
sptr_t _ret = self->replaceTargetMinimal(static_cast<sptr_t>(length), text);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_searchInTarget(ScintillaEdit* self, intptr_t length, const char* text) {
|
|
sptr_t _ret = self->searchInTarget(static_cast<sptr_t>(length), text);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSearchFlags(ScintillaEdit* self, intptr_t searchFlags) {
|
|
self->setSearchFlags(static_cast<sptr_t>(searchFlags));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_searchFlags(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->searchFlags();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_callTipShow(ScintillaEdit* self, intptr_t pos, const char* definition) {
|
|
self->callTipShow(static_cast<sptr_t>(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<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_callTipSetPosStart(ScintillaEdit* self, intptr_t posStart) {
|
|
self->callTipSetPosStart(static_cast<sptr_t>(posStart));
|
|
}
|
|
|
|
void ScintillaEdit_callTipSetHlt(ScintillaEdit* self, intptr_t highlightStart, intptr_t highlightEnd) {
|
|
self->callTipSetHlt(static_cast<sptr_t>(highlightStart), static_cast<sptr_t>(highlightEnd));
|
|
}
|
|
|
|
void ScintillaEdit_callTipSetBack(ScintillaEdit* self, intptr_t back) {
|
|
self->callTipSetBack(static_cast<sptr_t>(back));
|
|
}
|
|
|
|
void ScintillaEdit_callTipSetFore(ScintillaEdit* self, intptr_t fore) {
|
|
self->callTipSetFore(static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_callTipSetForeHlt(ScintillaEdit* self, intptr_t fore) {
|
|
self->callTipSetForeHlt(static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_callTipUseStyle(ScintillaEdit* self, intptr_t tabSize) {
|
|
self->callTipUseStyle(static_cast<sptr_t>(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<sptr_t>(docLine));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_docLineFromVisible(ScintillaEdit* self, intptr_t displayLine) {
|
|
sptr_t _ret = self->docLineFromVisible(static_cast<sptr_t>(displayLine));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_wrapCount(ScintillaEdit* self, intptr_t docLine) {
|
|
sptr_t _ret = self->wrapCount(static_cast<sptr_t>(docLine));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setFoldLevel(ScintillaEdit* self, intptr_t line, intptr_t level) {
|
|
self->setFoldLevel(static_cast<sptr_t>(line), static_cast<sptr_t>(level));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_foldLevel(const ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->foldLevel(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lastChild(const ScintillaEdit* self, intptr_t line, intptr_t level) {
|
|
sptr_t _ret = self->lastChild(static_cast<sptr_t>(line), static_cast<sptr_t>(level));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_foldParent(const ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->foldParent(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_showLines(ScintillaEdit* self, intptr_t lineStart, intptr_t lineEnd) {
|
|
self->showLines(static_cast<sptr_t>(lineStart), static_cast<sptr_t>(lineEnd));
|
|
}
|
|
|
|
void ScintillaEdit_hideLines(ScintillaEdit* self, intptr_t lineStart, intptr_t lineEnd) {
|
|
self->hideLines(static_cast<sptr_t>(lineStart), static_cast<sptr_t>(lineEnd));
|
|
}
|
|
|
|
bool ScintillaEdit_lineVisible(const ScintillaEdit* self, intptr_t line) {
|
|
return self->lineVisible(static_cast<sptr_t>(line));
|
|
}
|
|
|
|
bool ScintillaEdit_allLinesVisible(const ScintillaEdit* self) {
|
|
return self->allLinesVisible();
|
|
}
|
|
|
|
void ScintillaEdit_setFoldExpanded(ScintillaEdit* self, intptr_t line, bool expanded) {
|
|
self->setFoldExpanded(static_cast<sptr_t>(line), expanded);
|
|
}
|
|
|
|
bool ScintillaEdit_foldExpanded(const ScintillaEdit* self, intptr_t line) {
|
|
return self->foldExpanded(static_cast<sptr_t>(line));
|
|
}
|
|
|
|
void ScintillaEdit_toggleFold(ScintillaEdit* self, intptr_t line) {
|
|
self->toggleFold(static_cast<sptr_t>(line));
|
|
}
|
|
|
|
void ScintillaEdit_toggleFoldShowText(ScintillaEdit* self, intptr_t line, const char* text) {
|
|
self->toggleFoldShowText(static_cast<sptr_t>(line), text);
|
|
}
|
|
|
|
void ScintillaEdit_foldDisplayTextSetStyle(ScintillaEdit* self, intptr_t style) {
|
|
self->foldDisplayTextSetStyle(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_foldDisplayTextStyle(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->foldDisplayTextStyle();
|
|
return static_cast<intptr_t>(_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<char*>(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<sptr_t>(line), static_cast<sptr_t>(action));
|
|
}
|
|
|
|
void ScintillaEdit_foldChildren(ScintillaEdit* self, intptr_t line, intptr_t action) {
|
|
self->foldChildren(static_cast<sptr_t>(line), static_cast<sptr_t>(action));
|
|
}
|
|
|
|
void ScintillaEdit_expandChildren(ScintillaEdit* self, intptr_t line, intptr_t level) {
|
|
self->expandChildren(static_cast<sptr_t>(line), static_cast<sptr_t>(level));
|
|
}
|
|
|
|
void ScintillaEdit_foldAll(ScintillaEdit* self, intptr_t action) {
|
|
self->foldAll(static_cast<sptr_t>(action));
|
|
}
|
|
|
|
void ScintillaEdit_ensureVisible(ScintillaEdit* self, intptr_t line) {
|
|
self->ensureVisible(static_cast<sptr_t>(line));
|
|
}
|
|
|
|
void ScintillaEdit_setAutomaticFold(ScintillaEdit* self, intptr_t automaticFold) {
|
|
self->setAutomaticFold(static_cast<sptr_t>(automaticFold));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_automaticFold(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->automaticFold();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setFoldFlags(ScintillaEdit* self, intptr_t flags) {
|
|
self->setFoldFlags(static_cast<sptr_t>(flags));
|
|
}
|
|
|
|
void ScintillaEdit_ensureVisibleEnforcePolicy(ScintillaEdit* self, intptr_t line) {
|
|
self->ensureVisibleEnforcePolicy(static_cast<sptr_t>(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<sptr_t>(periodMilliseconds));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_mouseDwellTime(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->mouseDwellTime();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_wordStartPosition(ScintillaEdit* self, intptr_t pos, bool onlyWordCharacters) {
|
|
sptr_t _ret = self->wordStartPosition(static_cast<sptr_t>(pos), onlyWordCharacters);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_wordEndPosition(ScintillaEdit* self, intptr_t pos, bool onlyWordCharacters) {
|
|
sptr_t _ret = self->wordEndPosition(static_cast<sptr_t>(pos), onlyWordCharacters);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
bool ScintillaEdit_isRangeWord(ScintillaEdit* self, intptr_t start, intptr_t end) {
|
|
return self->isRangeWord(static_cast<sptr_t>(start), static_cast<sptr_t>(end));
|
|
}
|
|
|
|
void ScintillaEdit_setIdleStyling(ScintillaEdit* self, intptr_t idleStyling) {
|
|
self->setIdleStyling(static_cast<sptr_t>(idleStyling));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_idleStyling(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->idleStyling();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setWrapMode(ScintillaEdit* self, intptr_t wrapMode) {
|
|
self->setWrapMode(static_cast<sptr_t>(wrapMode));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_wrapMode(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->wrapMode();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setWrapVisualFlags(ScintillaEdit* self, intptr_t wrapVisualFlags) {
|
|
self->setWrapVisualFlags(static_cast<sptr_t>(wrapVisualFlags));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_wrapVisualFlags(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->wrapVisualFlags();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setWrapVisualFlagsLocation(ScintillaEdit* self, intptr_t wrapVisualFlagsLocation) {
|
|
self->setWrapVisualFlagsLocation(static_cast<sptr_t>(wrapVisualFlagsLocation));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_wrapVisualFlagsLocation(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->wrapVisualFlagsLocation();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setWrapStartIndent(ScintillaEdit* self, intptr_t indent) {
|
|
self->setWrapStartIndent(static_cast<sptr_t>(indent));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_wrapStartIndent(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->wrapStartIndent();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setWrapIndentMode(ScintillaEdit* self, intptr_t wrapIndentMode) {
|
|
self->setWrapIndentMode(static_cast<sptr_t>(wrapIndentMode));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_wrapIndentMode(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->wrapIndentMode();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setLayoutCache(ScintillaEdit* self, intptr_t cacheMode) {
|
|
self->setLayoutCache(static_cast<sptr_t>(cacheMode));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_layoutCache(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->layoutCache();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setScrollWidth(ScintillaEdit* self, intptr_t pixelWidth) {
|
|
self->setScrollWidth(static_cast<sptr_t>(pixelWidth));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_scrollWidth(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->scrollWidth();
|
|
return static_cast<intptr_t>(_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<sptr_t>(style), text);
|
|
return static_cast<intptr_t>(_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<sptr_t>(line));
|
|
return static_cast<intptr_t>(_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<sptr_t>(length), text);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_phasesDraw(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->phasesDraw();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setPhasesDraw(ScintillaEdit* self, intptr_t phases) {
|
|
self->setPhasesDraw(static_cast<sptr_t>(phases));
|
|
}
|
|
|
|
void ScintillaEdit_setFontQuality(ScintillaEdit* self, intptr_t fontQuality) {
|
|
self->setFontQuality(static_cast<sptr_t>(fontQuality));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_fontQuality(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->fontQuality();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setFirstVisibleLine(ScintillaEdit* self, intptr_t displayLine) {
|
|
self->setFirstVisibleLine(static_cast<sptr_t>(displayLine));
|
|
}
|
|
|
|
void ScintillaEdit_setMultiPaste(ScintillaEdit* self, intptr_t multiPaste) {
|
|
self->setMultiPaste(static_cast<sptr_t>(multiPaste));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_multiPaste(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->multiPaste();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_tag(const ScintillaEdit* self, intptr_t tagNumber) {
|
|
QByteArray _qb = self->tag(static_cast<sptr_t>(tagNumber));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(pixelWidth));
|
|
}
|
|
|
|
void ScintillaEdit_setFoldMarginColour(ScintillaEdit* self, bool useSetting, intptr_t back) {
|
|
self->setFoldMarginColour(useSetting, static_cast<sptr_t>(back));
|
|
}
|
|
|
|
void ScintillaEdit_setFoldMarginHiColour(ScintillaEdit* self, bool useSetting, intptr_t fore) {
|
|
self->setFoldMarginHiColour(useSetting, static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_setAccessibility(ScintillaEdit* self, intptr_t accessibility) {
|
|
self->setAccessibility(static_cast<sptr_t>(accessibility));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_accessibility(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->accessibility();
|
|
return static_cast<intptr_t>(_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<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_braceHighlight(ScintillaEdit* self, intptr_t posA, intptr_t posB) {
|
|
self->braceHighlight(static_cast<sptr_t>(posA), static_cast<sptr_t>(posB));
|
|
}
|
|
|
|
void ScintillaEdit_braceHighlightIndicator(ScintillaEdit* self, bool useSetting, intptr_t indicator) {
|
|
self->braceHighlightIndicator(useSetting, static_cast<sptr_t>(indicator));
|
|
}
|
|
|
|
void ScintillaEdit_braceBadLight(ScintillaEdit* self, intptr_t pos) {
|
|
self->braceBadLight(static_cast<sptr_t>(pos));
|
|
}
|
|
|
|
void ScintillaEdit_braceBadLightIndicator(ScintillaEdit* self, bool useSetting, intptr_t indicator) {
|
|
self->braceBadLightIndicator(useSetting, static_cast<sptr_t>(indicator));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_braceMatch(ScintillaEdit* self, intptr_t pos, intptr_t maxReStyle) {
|
|
sptr_t _ret = self->braceMatch(static_cast<sptr_t>(pos), static_cast<sptr_t>(maxReStyle));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_braceMatchNext(ScintillaEdit* self, intptr_t pos, intptr_t startPos) {
|
|
sptr_t _ret = self->braceMatchNext(static_cast<sptr_t>(pos), static_cast<sptr_t>(startPos));
|
|
return static_cast<intptr_t>(_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<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setDocPointer(ScintillaEdit* self, intptr_t doc) {
|
|
self->setDocPointer(static_cast<sptr_t>(doc));
|
|
}
|
|
|
|
void ScintillaEdit_setModEventMask(ScintillaEdit* self, intptr_t eventMask) {
|
|
self->setModEventMask(static_cast<sptr_t>(eventMask));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_edgeColumn(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->edgeColumn();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setEdgeColumn(ScintillaEdit* self, intptr_t column) {
|
|
self->setEdgeColumn(static_cast<sptr_t>(column));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_edgeMode(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->edgeMode();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setEdgeMode(ScintillaEdit* self, intptr_t edgeMode) {
|
|
self->setEdgeMode(static_cast<sptr_t>(edgeMode));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_edgeColour(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->edgeColour();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setEdgeColour(ScintillaEdit* self, intptr_t edgeColour) {
|
|
self->setEdgeColour(static_cast<sptr_t>(edgeColour));
|
|
}
|
|
|
|
void ScintillaEdit_multiEdgeAddLine(ScintillaEdit* self, intptr_t column, intptr_t edgeColour) {
|
|
self->multiEdgeAddLine(static_cast<sptr_t>(column), static_cast<sptr_t>(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<sptr_t>(which));
|
|
return static_cast<intptr_t>(_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<sptr_t>(searchFlags), text);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_searchPrev(ScintillaEdit* self, intptr_t searchFlags, const char* text) {
|
|
sptr_t _ret = self->searchPrev(static_cast<sptr_t>(searchFlags), text);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_linesOnScreen(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->linesOnScreen();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_usePopUp(ScintillaEdit* self, intptr_t popUpMode) {
|
|
self->usePopUp(static_cast<sptr_t>(popUpMode));
|
|
}
|
|
|
|
bool ScintillaEdit_selectionIsRectangle(const ScintillaEdit* self) {
|
|
return self->selectionIsRectangle();
|
|
}
|
|
|
|
void ScintillaEdit_setZoom(ScintillaEdit* self, intptr_t zoomInPoints) {
|
|
self->setZoom(static_cast<sptr_t>(zoomInPoints));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_zoom(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->zoom();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_createDocument(ScintillaEdit* self, intptr_t bytes, intptr_t documentOptions) {
|
|
sptr_t _ret = self->createDocument(static_cast<sptr_t>(bytes), static_cast<sptr_t>(documentOptions));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_addRefDocument(ScintillaEdit* self, intptr_t doc) {
|
|
self->addRefDocument(static_cast<sptr_t>(doc));
|
|
}
|
|
|
|
void ScintillaEdit_releaseDocument(ScintillaEdit* self, intptr_t doc) {
|
|
self->releaseDocument(static_cast<sptr_t>(doc));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_documentOptions(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->documentOptions();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_modEventMask(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->modEventMask();
|
|
return static_cast<intptr_t>(_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<sptr_t>(status));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_status(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->status();
|
|
return static_cast<intptr_t>(_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<sptr_t>(cursorType));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_cursor(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->cursor();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setControlCharSymbol(ScintillaEdit* self, intptr_t symbol) {
|
|
self->setControlCharSymbol(static_cast<sptr_t>(symbol));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_controlCharSymbol(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->controlCharSymbol();
|
|
return static_cast<intptr_t>(_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<sptr_t>(visiblePolicy), static_cast<sptr_t>(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<sptr_t>(xOffset));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_xOffset(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->xOffset();
|
|
return static_cast<intptr_t>(_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<sptr_t>(caretPolicy), static_cast<sptr_t>(caretSlop));
|
|
}
|
|
|
|
void ScintillaEdit_setYCaretPolicy(ScintillaEdit* self, intptr_t caretPolicy, intptr_t caretSlop) {
|
|
self->setYCaretPolicy(static_cast<sptr_t>(caretPolicy), static_cast<sptr_t>(caretSlop));
|
|
}
|
|
|
|
void ScintillaEdit_setPrintWrapMode(ScintillaEdit* self, intptr_t wrapMode) {
|
|
self->setPrintWrapMode(static_cast<sptr_t>(wrapMode));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_printWrapMode(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->printWrapMode();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setHotspotActiveFore(ScintillaEdit* self, bool useSetting, intptr_t fore) {
|
|
self->setHotspotActiveFore(useSetting, static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_hotspotActiveFore(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->hotspotActiveFore();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setHotspotActiveBack(ScintillaEdit* self, bool useSetting, intptr_t back) {
|
|
self->setHotspotActiveBack(useSetting, static_cast<sptr_t>(back));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_hotspotActiveBack(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->hotspotActiveBack();
|
|
return static_cast<intptr_t>(_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<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_positionAfter(ScintillaEdit* self, intptr_t pos) {
|
|
sptr_t _ret = self->positionAfter(static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_positionRelative(ScintillaEdit* self, intptr_t pos, intptr_t relative) {
|
|
sptr_t _ret = self->positionRelative(static_cast<sptr_t>(pos), static_cast<sptr_t>(relative));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_positionRelativeCodeUnits(ScintillaEdit* self, intptr_t pos, intptr_t relative) {
|
|
sptr_t _ret = self->positionRelativeCodeUnits(static_cast<sptr_t>(pos), static_cast<sptr_t>(relative));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_copyRange(ScintillaEdit* self, intptr_t start, intptr_t end) {
|
|
self->copyRange(static_cast<sptr_t>(start), static_cast<sptr_t>(end));
|
|
}
|
|
|
|
void ScintillaEdit_copyText(ScintillaEdit* self, intptr_t length, const char* text) {
|
|
self->copyText(static_cast<sptr_t>(length), text);
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionMode(ScintillaEdit* self, intptr_t selectionMode) {
|
|
self->setSelectionMode(static_cast<sptr_t>(selectionMode));
|
|
}
|
|
|
|
void ScintillaEdit_changeSelectionMode(ScintillaEdit* self, intptr_t selectionMode) {
|
|
self->changeSelectionMode(static_cast<sptr_t>(selectionMode));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionMode(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->selectionMode();
|
|
return static_cast<intptr_t>(_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<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_getLineSelEndPosition(ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->getLineSelEndPosition(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_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<char*>(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<char*>(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<intptr_t>(_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<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _qb.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
void ScintillaEdit_autoCSetCaseInsensitiveBehaviour(ScintillaEdit* self, intptr_t behaviour) {
|
|
self->autoCSetCaseInsensitiveBehaviour(static_cast<sptr_t>(behaviour));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_autoCCaseInsensitiveBehaviour(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->autoCCaseInsensitiveBehaviour();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_autoCSetMulti(ScintillaEdit* self, intptr_t multi) {
|
|
self->autoCSetMulti(static_cast<sptr_t>(multi));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_autoCMulti(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->autoCMulti();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_autoCSetOrder(ScintillaEdit* self, intptr_t order) {
|
|
self->autoCSetOrder(static_cast<sptr_t>(order));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_autoCOrder(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->autoCOrder();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_allocate(ScintillaEdit* self, intptr_t bytes) {
|
|
self->allocate(static_cast<sptr_t>(bytes));
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_targetAsUTF8(ScintillaEdit* self) {
|
|
QByteArray _qb = self->targetAsUTF8();
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _qb.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
void ScintillaEdit_setLengthForEncode(ScintillaEdit* self, intptr_t bytes) {
|
|
self->setLengthForEncode(static_cast<sptr_t>(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<char*>(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<sptr_t>(line), static_cast<sptr_t>(column));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_caretSticky(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->caretSticky();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setCaretSticky(ScintillaEdit* self, intptr_t useCaretStickyBehaviour) {
|
|
self->setCaretSticky(static_cast<sptr_t>(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<sptr_t>(length), text);
|
|
}
|
|
|
|
void ScintillaEdit_selectionDuplicate(ScintillaEdit* self) {
|
|
self->selectionDuplicate();
|
|
}
|
|
|
|
void ScintillaEdit_setCaretLineBackAlpha(ScintillaEdit* self, intptr_t alpha) {
|
|
self->setCaretLineBackAlpha(static_cast<sptr_t>(alpha));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_caretLineBackAlpha(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->caretLineBackAlpha();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setCaretStyle(ScintillaEdit* self, intptr_t caretStyle) {
|
|
self->setCaretStyle(static_cast<sptr_t>(caretStyle));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_caretStyle(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->caretStyle();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setIndicatorCurrent(ScintillaEdit* self, intptr_t indicator) {
|
|
self->setIndicatorCurrent(static_cast<sptr_t>(indicator));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicatorCurrent(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->indicatorCurrent();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setIndicatorValue(ScintillaEdit* self, intptr_t value) {
|
|
self->setIndicatorValue(static_cast<sptr_t>(value));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicatorValue(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->indicatorValue();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_indicatorFillRange(ScintillaEdit* self, intptr_t start, intptr_t lengthFill) {
|
|
self->indicatorFillRange(static_cast<sptr_t>(start), static_cast<sptr_t>(lengthFill));
|
|
}
|
|
|
|
void ScintillaEdit_indicatorClearRange(ScintillaEdit* self, intptr_t start, intptr_t lengthClear) {
|
|
self->indicatorClearRange(static_cast<sptr_t>(start), static_cast<sptr_t>(lengthClear));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicatorAllOnFor(ScintillaEdit* self, intptr_t pos) {
|
|
sptr_t _ret = self->indicatorAllOnFor(static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicatorValueAt(ScintillaEdit* self, intptr_t indicator, intptr_t pos) {
|
|
sptr_t _ret = self->indicatorValueAt(static_cast<sptr_t>(indicator), static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicatorStart(ScintillaEdit* self, intptr_t indicator, intptr_t pos) {
|
|
sptr_t _ret = self->indicatorStart(static_cast<sptr_t>(indicator), static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicatorEnd(ScintillaEdit* self, intptr_t indicator, intptr_t pos) {
|
|
sptr_t _ret = self->indicatorEnd(static_cast<sptr_t>(indicator), static_cast<sptr_t>(pos));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setPositionCache(ScintillaEdit* self, intptr_t size) {
|
|
self->setPositionCache(static_cast<sptr_t>(size));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_positionCache(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->positionCache();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setLayoutThreads(ScintillaEdit* self, intptr_t threads) {
|
|
self->setLayoutThreads(static_cast<sptr_t>(threads));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_layoutThreads(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->layoutThreads();
|
|
return static_cast<intptr_t>(_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<char*>(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<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_rangePointer(const ScintillaEdit* self, intptr_t start, intptr_t lengthRange) {
|
|
sptr_t _ret = self->rangePointer(static_cast<sptr_t>(start), static_cast<sptr_t>(lengthRange));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_gapPosition(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->gapPosition();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_indicSetAlpha(ScintillaEdit* self, intptr_t indicator, intptr_t alpha) {
|
|
self->indicSetAlpha(static_cast<sptr_t>(indicator), static_cast<sptr_t>(alpha));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicAlpha(const ScintillaEdit* self, intptr_t indicator) {
|
|
sptr_t _ret = self->indicAlpha(static_cast<sptr_t>(indicator));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_indicSetOutlineAlpha(ScintillaEdit* self, intptr_t indicator, intptr_t alpha) {
|
|
self->indicSetOutlineAlpha(static_cast<sptr_t>(indicator), static_cast<sptr_t>(alpha));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indicOutlineAlpha(const ScintillaEdit* self, intptr_t indicator) {
|
|
sptr_t _ret = self->indicOutlineAlpha(static_cast<sptr_t>(indicator));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setExtraAscent(ScintillaEdit* self, intptr_t extraAscent) {
|
|
self->setExtraAscent(static_cast<sptr_t>(extraAscent));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_extraAscent(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->extraAscent();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setExtraDescent(ScintillaEdit* self, intptr_t extraDescent) {
|
|
self->setExtraDescent(static_cast<sptr_t>(extraDescent));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_extraDescent(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->extraDescent();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_markerSymbolDefined(ScintillaEdit* self, intptr_t markerNumber) {
|
|
sptr_t _ret = self->markerSymbolDefined(static_cast<sptr_t>(markerNumber));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_marginSetText(ScintillaEdit* self, intptr_t line, const char* text) {
|
|
self->marginSetText(static_cast<sptr_t>(line), text);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_marginText(const ScintillaEdit* self, intptr_t line) {
|
|
QByteArray _qb = self->marginText(static_cast<sptr_t>(line));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(line), static_cast<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginStyle(const ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->marginStyle(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_marginSetStyles(ScintillaEdit* self, intptr_t line, const char* styles) {
|
|
self->marginSetStyles(static_cast<sptr_t>(line), styles);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_marginStyles(const ScintillaEdit* self, intptr_t line) {
|
|
QByteArray _qb = self->marginStyles(static_cast<sptr_t>(line));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginStyleOffset(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->marginStyleOffset();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setMarginOptions(ScintillaEdit* self, intptr_t marginOptions) {
|
|
self->setMarginOptions(static_cast<sptr_t>(marginOptions));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_marginOptions(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->marginOptions();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_annotationSetText(ScintillaEdit* self, intptr_t line, const char* text) {
|
|
self->annotationSetText(static_cast<sptr_t>(line), text);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_annotationText(const ScintillaEdit* self, intptr_t line) {
|
|
QByteArray _qb = self->annotationText(static_cast<sptr_t>(line));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(line), static_cast<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_annotationStyle(const ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->annotationStyle(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_annotationSetStyles(ScintillaEdit* self, intptr_t line, const char* styles) {
|
|
self->annotationSetStyles(static_cast<sptr_t>(line), styles);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_annotationStyles(const ScintillaEdit* self, intptr_t line) {
|
|
QByteArray _qb = self->annotationStyles(static_cast<sptr_t>(line));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_annotationClearAll(ScintillaEdit* self) {
|
|
self->annotationClearAll();
|
|
}
|
|
|
|
void ScintillaEdit_annotationSetVisible(ScintillaEdit* self, intptr_t visible) {
|
|
self->annotationSetVisible(static_cast<sptr_t>(visible));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_annotationVisible(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->annotationVisible();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_annotationSetStyleOffset(ScintillaEdit* self, intptr_t style) {
|
|
self->annotationSetStyleOffset(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_annotationStyleOffset(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->annotationStyleOffset();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_releaseAllExtendedStyles(ScintillaEdit* self) {
|
|
self->releaseAllExtendedStyles();
|
|
}
|
|
|
|
intptr_t ScintillaEdit_allocateExtendedStyles(ScintillaEdit* self, intptr_t numberStyles) {
|
|
sptr_t _ret = self->allocateExtendedStyles(static_cast<sptr_t>(numberStyles));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_addUndoAction(ScintillaEdit* self, intptr_t token, intptr_t flags) {
|
|
self->addUndoAction(static_cast<sptr_t>(token), static_cast<sptr_t>(flags));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_charPositionFromPoint(ScintillaEdit* self, intptr_t x, intptr_t y) {
|
|
sptr_t _ret = self->charPositionFromPoint(static_cast<sptr_t>(x), static_cast<sptr_t>(y));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_charPositionFromPointClose(ScintillaEdit* self, intptr_t x, intptr_t y) {
|
|
sptr_t _ret = self->charPositionFromPointClose(static_cast<sptr_t>(x), static_cast<sptr_t>(y));
|
|
return static_cast<intptr_t>(_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<intptr_t>(_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<sptr_t>(caret), static_cast<sptr_t>(anchor));
|
|
}
|
|
|
|
void ScintillaEdit_addSelection(ScintillaEdit* self, intptr_t caret, intptr_t anchor) {
|
|
self->addSelection(static_cast<sptr_t>(caret), static_cast<sptr_t>(anchor));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionFromPoint(ScintillaEdit* self, intptr_t x, intptr_t y) {
|
|
sptr_t _ret = self->selectionFromPoint(static_cast<sptr_t>(x), static_cast<sptr_t>(y));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_dropSelectionN(ScintillaEdit* self, intptr_t selection) {
|
|
self->dropSelectionN(static_cast<sptr_t>(selection));
|
|
}
|
|
|
|
void ScintillaEdit_setMainSelection(ScintillaEdit* self, intptr_t selection) {
|
|
self->setMainSelection(static_cast<sptr_t>(selection));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_mainSelection(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->mainSelection();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionNCaret(ScintillaEdit* self, intptr_t selection, intptr_t caret) {
|
|
self->setSelectionNCaret(static_cast<sptr_t>(selection), static_cast<sptr_t>(caret));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionNCaret(const ScintillaEdit* self, intptr_t selection) {
|
|
sptr_t _ret = self->selectionNCaret(static_cast<sptr_t>(selection));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionNAnchor(ScintillaEdit* self, intptr_t selection, intptr_t anchor) {
|
|
self->setSelectionNAnchor(static_cast<sptr_t>(selection), static_cast<sptr_t>(anchor));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionNAnchor(const ScintillaEdit* self, intptr_t selection) {
|
|
sptr_t _ret = self->selectionNAnchor(static_cast<sptr_t>(selection));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionNCaretVirtualSpace(ScintillaEdit* self, intptr_t selection, intptr_t space) {
|
|
self->setSelectionNCaretVirtualSpace(static_cast<sptr_t>(selection), static_cast<sptr_t>(space));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionNCaretVirtualSpace(const ScintillaEdit* self, intptr_t selection) {
|
|
sptr_t _ret = self->selectionNCaretVirtualSpace(static_cast<sptr_t>(selection));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionNAnchorVirtualSpace(ScintillaEdit* self, intptr_t selection, intptr_t space) {
|
|
self->setSelectionNAnchorVirtualSpace(static_cast<sptr_t>(selection), static_cast<sptr_t>(space));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionNAnchorVirtualSpace(const ScintillaEdit* self, intptr_t selection) {
|
|
sptr_t _ret = self->selectionNAnchorVirtualSpace(static_cast<sptr_t>(selection));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionNStart(ScintillaEdit* self, intptr_t selection, intptr_t anchor) {
|
|
self->setSelectionNStart(static_cast<sptr_t>(selection), static_cast<sptr_t>(anchor));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionNStart(const ScintillaEdit* self, intptr_t selection) {
|
|
sptr_t _ret = self->selectionNStart(static_cast<sptr_t>(selection));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionNStartVirtualSpace(const ScintillaEdit* self, intptr_t selection) {
|
|
sptr_t _ret = self->selectionNStartVirtualSpace(static_cast<sptr_t>(selection));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setSelectionNEnd(ScintillaEdit* self, intptr_t selection, intptr_t caret) {
|
|
self->setSelectionNEnd(static_cast<sptr_t>(selection), static_cast<sptr_t>(caret));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionNEndVirtualSpace(const ScintillaEdit* self, intptr_t selection) {
|
|
sptr_t _ret = self->selectionNEndVirtualSpace(static_cast<sptr_t>(selection));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_selectionNEnd(const ScintillaEdit* self, intptr_t selection) {
|
|
sptr_t _ret = self->selectionNEnd(static_cast<sptr_t>(selection));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setRectangularSelectionCaret(ScintillaEdit* self, intptr_t caret) {
|
|
self->setRectangularSelectionCaret(static_cast<sptr_t>(caret));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_rectangularSelectionCaret(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->rectangularSelectionCaret();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setRectangularSelectionAnchor(ScintillaEdit* self, intptr_t anchor) {
|
|
self->setRectangularSelectionAnchor(static_cast<sptr_t>(anchor));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_rectangularSelectionAnchor(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->rectangularSelectionAnchor();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setRectangularSelectionCaretVirtualSpace(ScintillaEdit* self, intptr_t space) {
|
|
self->setRectangularSelectionCaretVirtualSpace(static_cast<sptr_t>(space));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_rectangularSelectionCaretVirtualSpace(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->rectangularSelectionCaretVirtualSpace();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setRectangularSelectionAnchorVirtualSpace(ScintillaEdit* self, intptr_t space) {
|
|
self->setRectangularSelectionAnchorVirtualSpace(static_cast<sptr_t>(space));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_rectangularSelectionAnchorVirtualSpace(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->rectangularSelectionAnchorVirtualSpace();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setVirtualSpaceOptions(ScintillaEdit* self, intptr_t virtualSpaceOptions) {
|
|
self->setVirtualSpaceOptions(static_cast<sptr_t>(virtualSpaceOptions));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_virtualSpaceOptions(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->virtualSpaceOptions();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setRectangularSelectionModifier(ScintillaEdit* self, intptr_t modifier) {
|
|
self->setRectangularSelectionModifier(static_cast<sptr_t>(modifier));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_rectangularSelectionModifier(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->rectangularSelectionModifier();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setAdditionalSelFore(ScintillaEdit* self, intptr_t fore) {
|
|
self->setAdditionalSelFore(static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
void ScintillaEdit_setAdditionalSelBack(ScintillaEdit* self, intptr_t back) {
|
|
self->setAdditionalSelBack(static_cast<sptr_t>(back));
|
|
}
|
|
|
|
void ScintillaEdit_setAdditionalSelAlpha(ScintillaEdit* self, intptr_t alpha) {
|
|
self->setAdditionalSelAlpha(static_cast<sptr_t>(alpha));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_additionalSelAlpha(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->additionalSelAlpha();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setAdditionalCaretFore(ScintillaEdit* self, intptr_t fore) {
|
|
self->setAdditionalCaretFore(static_cast<sptr_t>(fore));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_additionalCaretFore(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->additionalCaretFore();
|
|
return static_cast<intptr_t>(_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<sptr_t>(start), static_cast<sptr_t>(end));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_contractedFoldNext(ScintillaEdit* self, intptr_t lineStart) {
|
|
sptr_t _ret = self->contractedFoldNext(static_cast<sptr_t>(lineStart));
|
|
return static_cast<intptr_t>(_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<sptr_t>(identifier));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_identifier(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->identifier();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_rGBAImageSetWidth(ScintillaEdit* self, intptr_t width) {
|
|
self->rGBAImageSetWidth(static_cast<sptr_t>(width));
|
|
}
|
|
|
|
void ScintillaEdit_rGBAImageSetHeight(ScintillaEdit* self, intptr_t height) {
|
|
self->rGBAImageSetHeight(static_cast<sptr_t>(height));
|
|
}
|
|
|
|
void ScintillaEdit_rGBAImageSetScale(ScintillaEdit* self, intptr_t scalePercent) {
|
|
self->rGBAImageSetScale(static_cast<sptr_t>(scalePercent));
|
|
}
|
|
|
|
void ScintillaEdit_markerDefineRGBAImage(ScintillaEdit* self, intptr_t markerNumber, const char* pixels) {
|
|
self->markerDefineRGBAImage(static_cast<sptr_t>(markerNumber), pixels);
|
|
}
|
|
|
|
void ScintillaEdit_registerRGBAImage(ScintillaEdit* self, intptr_t type, const char* pixels) {
|
|
self->registerRGBAImage(static_cast<sptr_t>(type), 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<sptr_t>(technology));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_technology(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->technology();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_createLoader(ScintillaEdit* self, intptr_t bytes, intptr_t documentOptions) {
|
|
sptr_t _ret = self->createLoader(static_cast<sptr_t>(bytes), static_cast<sptr_t>(documentOptions));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_findIndicatorShow(ScintillaEdit* self, intptr_t start, intptr_t end) {
|
|
self->findIndicatorShow(static_cast<sptr_t>(start), static_cast<sptr_t>(end));
|
|
}
|
|
|
|
void ScintillaEdit_findIndicatorFlash(ScintillaEdit* self, intptr_t start, intptr_t end) {
|
|
self->findIndicatorFlash(static_cast<sptr_t>(start), static_cast<sptr_t>(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<sptr_t>(lineEndBitSet));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lineEndTypesAllowed(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->lineEndTypesAllowed();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lineEndTypesActive(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->lineEndTypesActive();
|
|
return static_cast<intptr_t>(_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<char*>(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<sptr_t>(appearance));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_representationAppearance(const ScintillaEdit* self, const char* encodedCharacter) {
|
|
sptr_t _ret = self->representationAppearance(encodedCharacter);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setRepresentationColour(ScintillaEdit* self, const char* encodedCharacter, intptr_t colour) {
|
|
self->setRepresentationColour(encodedCharacter, static_cast<sptr_t>(colour));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_representationColour(const ScintillaEdit* self, const char* encodedCharacter) {
|
|
sptr_t _ret = self->representationColour(encodedCharacter);
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_eOLAnnotationSetText(ScintillaEdit* self, intptr_t line, const char* text) {
|
|
self->eOLAnnotationSetText(static_cast<sptr_t>(line), text);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_eOLAnnotationText(const ScintillaEdit* self, intptr_t line) {
|
|
QByteArray _qb = self->eOLAnnotationText(static_cast<sptr_t>(line));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(line), static_cast<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_eOLAnnotationStyle(const ScintillaEdit* self, intptr_t line) {
|
|
sptr_t _ret = self->eOLAnnotationStyle(static_cast<sptr_t>(line));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_eOLAnnotationClearAll(ScintillaEdit* self) {
|
|
self->eOLAnnotationClearAll();
|
|
}
|
|
|
|
void ScintillaEdit_eOLAnnotationSetVisible(ScintillaEdit* self, intptr_t visible) {
|
|
self->eOLAnnotationSetVisible(static_cast<sptr_t>(visible));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_eOLAnnotationVisible(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->eOLAnnotationVisible();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_eOLAnnotationSetStyleOffset(ScintillaEdit* self, intptr_t style) {
|
|
self->eOLAnnotationSetStyleOffset(static_cast<sptr_t>(style));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_eOLAnnotationStyleOffset(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->eOLAnnotationStyleOffset();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
bool ScintillaEdit_supportsFeature(const ScintillaEdit* self, intptr_t feature) {
|
|
return self->supportsFeature(static_cast<sptr_t>(feature));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lineCharacterIndex(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->lineCharacterIndex();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_allocateLineCharacterIndex(ScintillaEdit* self, intptr_t lineCharacterIndex) {
|
|
self->allocateLineCharacterIndex(static_cast<sptr_t>(lineCharacterIndex));
|
|
}
|
|
|
|
void ScintillaEdit_releaseLineCharacterIndex(ScintillaEdit* self, intptr_t lineCharacterIndex) {
|
|
self->releaseLineCharacterIndex(static_cast<sptr_t>(lineCharacterIndex));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_lineFromIndexPosition(ScintillaEdit* self, intptr_t pos, intptr_t lineCharacterIndex) {
|
|
sptr_t _ret = self->lineFromIndexPosition(static_cast<sptr_t>(pos), static_cast<sptr_t>(lineCharacterIndex));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_indexPositionFromLine(ScintillaEdit* self, intptr_t line, intptr_t lineCharacterIndex) {
|
|
sptr_t _ret = self->indexPositionFromLine(static_cast<sptr_t>(line), static_cast<sptr_t>(lineCharacterIndex));
|
|
return static_cast<intptr_t>(_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<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_colourise(ScintillaEdit* self, intptr_t start, intptr_t end) {
|
|
self->colourise(static_cast<sptr_t>(start), static_cast<sptr_t>(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<sptr_t>(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<char*>(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<char*>(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<sptr_t>(defaultValue));
|
|
return static_cast<intptr_t>(_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<char*>(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<sptr_t>(operation), static_cast<sptr_t>(pointer));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_propertyNames(ScintillaEdit* self) {
|
|
QByteArray _qb = self->propertyNames();
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<intptr_t>(_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<char*>(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<char*>(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<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_allocateSubStyles(ScintillaEdit* self, intptr_t styleBase, intptr_t numberStyles) {
|
|
sptr_t _ret = self->allocateSubStyles(static_cast<sptr_t>(styleBase), static_cast<sptr_t>(numberStyles));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_subStylesStart(const ScintillaEdit* self, intptr_t styleBase) {
|
|
sptr_t _ret = self->subStylesStart(static_cast<sptr_t>(styleBase));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_subStylesLength(const ScintillaEdit* self, intptr_t styleBase) {
|
|
sptr_t _ret = self->subStylesLength(static_cast<sptr_t>(styleBase));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_styleFromSubStyle(const ScintillaEdit* self, intptr_t subStyle) {
|
|
sptr_t _ret = self->styleFromSubStyle(static_cast<sptr_t>(subStyle));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_primaryStyleFromStyle(const ScintillaEdit* self, intptr_t style) {
|
|
sptr_t _ret = self->primaryStyleFromStyle(static_cast<sptr_t>(style));
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_freeSubStyles(ScintillaEdit* self) {
|
|
self->freeSubStyles();
|
|
}
|
|
|
|
void ScintillaEdit_setIdentifiers(ScintillaEdit* self, intptr_t style, const char* identifiers) {
|
|
self->setIdentifiers(static_cast<sptr_t>(style), identifiers);
|
|
}
|
|
|
|
intptr_t ScintillaEdit_distanceToSecondaryStyles(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->distanceToSecondaryStyles();
|
|
return static_cast<intptr_t>(_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<char*>(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<intptr_t>(_ret);
|
|
}
|
|
|
|
struct miqt_string ScintillaEdit_nameOfStyle(ScintillaEdit* self, intptr_t style) {
|
|
QByteArray _qb = self->nameOfStyle(static_cast<sptr_t>(style));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(style));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(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<sptr_t>(style));
|
|
struct miqt_string _ms;
|
|
_ms.len = _qb.length();
|
|
_ms.data = static_cast<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _qb.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
void ScintillaEdit_setILexer(ScintillaEdit* self, intptr_t ilexer) {
|
|
self->setILexer(static_cast<sptr_t>(ilexer));
|
|
}
|
|
|
|
intptr_t ScintillaEdit_bidirectional(const ScintillaEdit* self) {
|
|
sptr_t _ret = self->bidirectional();
|
|
return static_cast<intptr_t>(_ret);
|
|
}
|
|
|
|
void ScintillaEdit_setBidirectional(ScintillaEdit* self, intptr_t bidirectional) {
|
|
self->setBidirectional(static_cast<sptr_t>(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<char*>(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<int>(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<char*>(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<char*>(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<int>(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<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _b.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_send(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__send = slot;
|
|
return true;
|
|
}
|
|
|
|
intptr_t ScintillaEdit_virtualbase_send(const void* self, unsigned int iMessage, uintptr_t wParam, intptr_t lParam) {
|
|
|
|
sptr_t _ret = ( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::send(static_cast<unsigned int>(iMessage), static_cast<uptr_t>(wParam), static_cast<sptr_t>(lParam));
|
|
return static_cast<intptr_t>(_ret);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_sends(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__sends = slot;
|
|
return true;
|
|
}
|
|
|
|
intptr_t ScintillaEdit_virtualbase_sends(const void* self, unsigned int iMessage, uintptr_t wParam, const char* s) {
|
|
|
|
sptr_t _ret = ( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::sends(static_cast<unsigned int>(iMessage), static_cast<uptr_t>(wParam), s);
|
|
return static_cast<intptr_t>(_ret);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_event(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__event = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEdit_virtualbase_event(void* self, QEvent* event) {
|
|
|
|
return ( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::event(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_paintEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__paintEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_paintEvent(void* self, QPaintEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::paintEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_wheelEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__wheelEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_wheelEvent(void* self, QWheelEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::wheelEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_focusInEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__focusInEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_focusInEvent(void* self, QFocusEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::focusInEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_focusOutEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__focusOutEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_focusOutEvent(void* self, QFocusEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::focusOutEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_resizeEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__resizeEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_resizeEvent(void* self, QResizeEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::resizeEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_keyPressEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__keyPressEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_keyPressEvent(void* self, QKeyEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::keyPressEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_mousePressEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__mousePressEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_mousePressEvent(void* self, QMouseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::mousePressEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_mouseReleaseEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__mouseReleaseEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::mouseReleaseEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__mouseDoubleClickEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::mouseDoubleClickEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_mouseMoveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__mouseMoveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_mouseMoveEvent(void* self, QMouseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::mouseMoveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_contextMenuEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__contextMenuEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::contextMenuEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_dragEnterEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__dragEnterEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::dragEnterEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_dragLeaveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__dragLeaveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::dragLeaveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_dragMoveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__dragMoveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::dragMoveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_dropEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__dropEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_dropEvent(void* self, QDropEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::dropEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_inputMethodEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__inputMethodEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::inputMethodEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_inputMethodQuery(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__inputMethodQuery = slot;
|
|
return true;
|
|
}
|
|
|
|
QVariant* ScintillaEdit_virtualbase_inputMethodQuery(const void* self, int query) {
|
|
|
|
return new QVariant(( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_scrollContentsBy(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__scrollContentsBy = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_scrollContentsBy(void* self, int param1, int param2) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::scrollContentsBy(static_cast<int>(param1), static_cast<int>(param2));
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_minimumSizeHint(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__minimumSizeHint = slot;
|
|
return true;
|
|
}
|
|
|
|
QSize* ScintillaEdit_virtualbase_minimumSizeHint(const void* self) {
|
|
|
|
return new QSize(( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::minimumSizeHint());
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_sizeHint(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__sizeHint = slot;
|
|
return true;
|
|
}
|
|
|
|
QSize* ScintillaEdit_virtualbase_sizeHint(const void* self) {
|
|
|
|
return new QSize(( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::sizeHint());
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_setupViewport(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__setupViewport = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_setupViewport(void* self, QWidget* viewport) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::setupViewport(viewport);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_eventFilter(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__eventFilter = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEdit_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2) {
|
|
|
|
return ( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::eventFilter(param1, param2);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_viewportEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__viewportEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEdit_virtualbase_viewportEvent(void* self, QEvent* param1) {
|
|
|
|
return ( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::viewportEvent(param1);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_viewportSizeHint(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__viewportSizeHint = slot;
|
|
return true;
|
|
}
|
|
|
|
QSize* ScintillaEdit_virtualbase_viewportSizeHint(const void* self) {
|
|
|
|
return new QSize(( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::viewportSizeHint());
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_changeEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__changeEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_changeEvent(void* self, QEvent* param1) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::changeEvent(param1);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_devType(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__devType = slot;
|
|
return true;
|
|
}
|
|
|
|
int ScintillaEdit_virtualbase_devType(const void* self) {
|
|
|
|
return ( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::devType();
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_setVisible(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__setVisible = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_setVisible(void* self, bool visible) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::setVisible(visible);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_heightForWidth(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__heightForWidth = slot;
|
|
return true;
|
|
}
|
|
|
|
int ScintillaEdit_virtualbase_heightForWidth(const void* self, int param1) {
|
|
|
|
return ( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::heightForWidth(static_cast<int>(param1));
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_hasHeightForWidth(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__hasHeightForWidth = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEdit_virtualbase_hasHeightForWidth(const void* self) {
|
|
|
|
return ( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::hasHeightForWidth();
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_paintEngine(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__paintEngine = slot;
|
|
return true;
|
|
}
|
|
|
|
QPaintEngine* ScintillaEdit_virtualbase_paintEngine(const void* self) {
|
|
|
|
return ( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::paintEngine();
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_keyReleaseEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__keyReleaseEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::keyReleaseEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_enterEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__enterEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_enterEvent(void* self, QEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::enterEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_leaveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__leaveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_leaveEvent(void* self, QEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::leaveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_moveEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__moveEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_moveEvent(void* self, QMoveEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::moveEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_closeEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__closeEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_closeEvent(void* self, QCloseEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::closeEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_tabletEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__tabletEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_tabletEvent(void* self, QTabletEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::tabletEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_actionEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__actionEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_actionEvent(void* self, QActionEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::actionEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_showEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__showEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_showEvent(void* self, QShowEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::showEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_hideEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__hideEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_hideEvent(void* self, QHideEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::hideEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_nativeEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__nativeEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEdit_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, long* result) {
|
|
QByteArray eventType_QByteArray(eventType.data, eventType.len);
|
|
|
|
return ( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::nativeEvent(eventType_QByteArray, message, static_cast<long*>(result));
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_metric(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__metric = slot;
|
|
return true;
|
|
}
|
|
|
|
int ScintillaEdit_virtualbase_metric(const void* self, int param1) {
|
|
|
|
return ( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::metric(static_cast<MiqtVirtualScintillaEdit::PaintDeviceMetric>(param1));
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_initPainter(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__initPainter = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_initPainter(const void* self, QPainter* painter) {
|
|
|
|
( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::initPainter(painter);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_redirected(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__redirected = slot;
|
|
return true;
|
|
}
|
|
|
|
QPaintDevice* ScintillaEdit_virtualbase_redirected(const void* self, QPoint* offset) {
|
|
|
|
return ( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::redirected(offset);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_sharedPainter(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__sharedPainter = slot;
|
|
return true;
|
|
}
|
|
|
|
QPainter* ScintillaEdit_virtualbase_sharedPainter(const void* self) {
|
|
|
|
return ( (const MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::sharedPainter();
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_focusNextPrevChild(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__focusNextPrevChild = slot;
|
|
return true;
|
|
}
|
|
|
|
bool ScintillaEdit_virtualbase_focusNextPrevChild(void* self, bool next) {
|
|
|
|
return ( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::focusNextPrevChild(next);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_timerEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__timerEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_timerEvent(void* self, QTimerEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::timerEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_childEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__childEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_childEvent(void* self, QChildEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::childEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_customEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__customEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_customEvent(void* self, QEvent* event) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::customEvent(event);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_connectNotify(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__connectNotify = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::connectNotify(*signal);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_override_virtual_disconnectNotify(void* self, intptr_t slot) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__disconnectNotify = slot;
|
|
return true;
|
|
}
|
|
|
|
void ScintillaEdit_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
|
|
|
|
( (MiqtVirtualScintillaEdit*)(self) )->MiqtVirtualScintillaEdit::disconnectNotify(*signal);
|
|
|
|
}
|
|
|
|
void ScintillaEdit_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->setViewportMargins(static_cast<int>(left), static_cast<int>(top), static_cast<int>(right), static_cast<int>(bottom));
|
|
|
|
}
|
|
|
|
QMargins* ScintillaEdit_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return nullptr;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return new QMargins(self_cast->viewportMargins());
|
|
|
|
}
|
|
|
|
void ScintillaEdit_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->drawFrame(param1);
|
|
|
|
}
|
|
|
|
void ScintillaEdit_protectedbase_initStyleOption(bool* _dynamic_cast_ok, const void* self, QStyleOptionFrame* option) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->initStyleOption(option);
|
|
|
|
}
|
|
|
|
void ScintillaEdit_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->updateMicroFocus();
|
|
|
|
}
|
|
|
|
void ScintillaEdit_protectedbase_create(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->create();
|
|
|
|
}
|
|
|
|
void ScintillaEdit_protectedbase_destroy(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return ;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
self_cast->destroy();
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return false;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->focusNextChild();
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return false;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->focusPreviousChild();
|
|
|
|
}
|
|
|
|
QObject* ScintillaEdit_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return nullptr;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->sender();
|
|
|
|
}
|
|
|
|
int ScintillaEdit_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return 0;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->senderSignalIndex();
|
|
|
|
}
|
|
|
|
int ScintillaEdit_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return 0;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->receivers(signal);
|
|
|
|
}
|
|
|
|
bool ScintillaEdit_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
|
|
MiqtVirtualScintillaEdit* self_cast = dynamic_cast<MiqtVirtualScintillaEdit*>( (ScintillaEdit*)(self) );
|
|
if (self_cast == nullptr) {
|
|
*_dynamic_cast_ok = false;
|
|
return false;
|
|
}
|
|
|
|
*_dynamic_cast_ok = true;
|
|
|
|
return self_cast->isSignalConnected(*signal);
|
|
|
|
}
|
|
|
|
void ScintillaEdit_delete(ScintillaEdit* self) {
|
|
delete self;
|
|
}
|
|
|