//Auto-generated by kalyptus. DO NOT EDIT.
namespace Qyoto {
    using System;
    using System.Collections.Generic;
    /// <remarks> See <see cref="IQWidgetSignals"></see> for signals emitted by QWidget
    /// </remarks>
    [SmokeClass("QWidget")]
    public class QWidget : QObject, IQPaintDevice, IDisposable {
        protected QWidget(Type dummy) : base((Type) null) {}
        protected new void CreateProxy() {
            interceptor = new SmokeInvocation(typeof(QWidget), this);
        }
        private static SmokeInvocation staticInterceptor = null;
        static QWidget() {
            staticInterceptor = new SmokeInvocation(typeof(QWidget), null);
        }
        public enum RenderFlag {
            DrawWindowBackground = 0x1,
            DrawChildren = 0x2,
            IgnoreMask = 0x4,
        }
        [Q_PROPERTY("bool", "modal")]
        public bool Modal {
            get { return (bool) interceptor.Invoke("isModal", "isModal()", typeof(bool)); }
        }
        [Q_PROPERTY("Qt::WindowModality", "windowModality")]
        public new Qt.WindowModality WindowModality {
            get { return (Qt.WindowModality) interceptor.Invoke("windowModality", "windowModality()", typeof(Qt.WindowModality)); }
            set { interceptor.Invoke("setWindowModality$", "setWindowModality(Qt::WindowModality)", typeof(void), typeof(Qt.WindowModality), value); }
        }
        [Q_PROPERTY("bool", "enabled")]
        public bool Enabled {
            get { return (bool) interceptor.Invoke("isEnabled", "isEnabled()", typeof(bool)); }
            set { interceptor.Invoke("setEnabled$", "setEnabled(bool)", typeof(void), typeof(bool), value); }
        }
        [Q_PROPERTY("QRect", "geometry")]
        public QRect Geometry {
            get { return (QRect) interceptor.Invoke("geometry", "geometry()", typeof(QRect)); }
            set { interceptor.Invoke("setGeometry#", "setGeometry(QRect)", typeof(void), typeof(QRect), value); }
        }
        [Q_PROPERTY("QRect", "frameGeometry")]
        public QRect FrameGeometry {
            get { return (QRect) interceptor.Invoke("frameGeometry", "frameGeometry()", typeof(QRect)); }
        }
        [Q_PROPERTY("QRect", "normalGeometry")]
        public QRect NormalGeometry {
            get { return (QRect) interceptor.Invoke("normalGeometry", "normalGeometry()", typeof(QRect)); }
        }
        [Q_PROPERTY("int", "x")]
        public int X {
            get { return (int) interceptor.Invoke("x", "x()", typeof(int)); }
        }
        [Q_PROPERTY("int", "y")]
        public int Y {
            get { return (int) interceptor.Invoke("y", "y()", typeof(int)); }
        }
        [Q_PROPERTY("QPoint", "pos")]
        public QPoint Pos {
            get { return (QPoint) interceptor.Invoke("pos", "pos()", typeof(QPoint)); }
            set { interceptor.Invoke("move#", "move(QPoint)", typeof(void), typeof(QPoint), value); }
        }
        [Q_PROPERTY("QSize", "frameSize")]
        public QSize FrameSize {
            get { return (QSize) interceptor.Invoke("frameSize", "frameSize()", typeof(QSize)); }
        }
        [Q_PROPERTY("QSize", "size")]
        public QSize Size {
            get { return (QSize) interceptor.Invoke("size", "size()", typeof(QSize)); }
            set { interceptor.Invoke("resize#", "resize(QSize)", typeof(void), typeof(QSize), value); }
        }
        [Q_PROPERTY("QRect", "rect")]
        public QRect Rect {
            get { return (QRect) interceptor.Invoke("rect", "rect()", typeof(QRect)); }
        }
        [Q_PROPERTY("QRect", "childrenRect")]
        public QRect ChildrenRect {
            get { return (QRect) interceptor.Invoke("childrenRect", "childrenRect()", typeof(QRect)); }
        }
        [Q_PROPERTY("QRegion", "childrenRegion")]
        public QRegion ChildrenRegion {
            get { return (QRegion) interceptor.Invoke("childrenRegion", "childrenRegion()", typeof(QRegion)); }
        }
        [Q_PROPERTY("QSizePolicy", "sizePolicy")]
        public QSizePolicy SizePolicy {
            get { return (QSizePolicy) interceptor.Invoke("sizePolicy", "sizePolicy()", typeof(QSizePolicy)); }
            set { interceptor.Invoke("setSizePolicy#", "setSizePolicy(QSizePolicy)", typeof(void), typeof(QSizePolicy), value); }
        }
        [Q_PROPERTY("QSize", "minimumSize")]
        public QSize MinimumSize {
            get { return (QSize) interceptor.Invoke("minimumSize", "minimumSize()", typeof(QSize)); }
            set { interceptor.Invoke("setMinimumSize#", "setMinimumSize(QSize)", typeof(void), typeof(QSize), value); }
        }
        [Q_PROPERTY("QSize", "maximumSize")]
        public QSize MaximumSize {
            get { return (QSize) interceptor.Invoke("maximumSize", "maximumSize()", typeof(QSize)); }
            set { interceptor.Invoke("setMaximumSize#", "setMaximumSize(QSize)", typeof(void), typeof(QSize), value); }
        }
        [Q_PROPERTY("int", "minimumWidth")]
        public int MinimumWidth {
            get { return (int) interceptor.Invoke("minimumWidth", "minimumWidth()", typeof(int)); }
            set { interceptor.Invoke("setMinimumWidth$", "setMinimumWidth(int)", typeof(void), typeof(int), value); }
        }
        [Q_PROPERTY("int", "minimumHeight")]
        public int MinimumHeight {
            get { return (int) interceptor.Invoke("minimumHeight", "minimumHeight()", typeof(int)); }
            set { interceptor.Invoke("setMinimumHeight$", "setMinimumHeight(int)", typeof(void), typeof(int), value); }
        }
        [Q_PROPERTY("int", "maximumWidth")]
        public int MaximumWidth {
            get { return (int) interceptor.Invoke("maximumWidth", "maximumWidth()", typeof(int)); }
            set { interceptor.Invoke("setMaximumWidth$", "setMaximumWidth(int)", typeof(void), typeof(int), value); }
        }
        [Q_PROPERTY("int", "maximumHeight")]
        public int MaximumHeight {
            get { return (int) interceptor.Invoke("maximumHeight", "maximumHeight()", typeof(int)); }
            set { interceptor.Invoke("setMaximumHeight$", "setMaximumHeight(int)", typeof(void), typeof(int), value); }
        }
        [Q_PROPERTY("QSize", "sizeIncrement")]
        public QSize SizeIncrement {
            get { return (QSize) interceptor.Invoke("sizeIncrement", "sizeIncrement()", typeof(QSize)); }
            set { interceptor.Invoke("setSizeIncrement#", "setSizeIncrement(QSize)", typeof(void), typeof(QSize), value); }
        }
        [Q_PROPERTY("QSize", "baseSize")]
        public QSize BaseSize {
            get { return (QSize) interceptor.Invoke("baseSize", "baseSize()", typeof(QSize)); }
            set { interceptor.Invoke("setBaseSize#", "setBaseSize(QSize)", typeof(void), typeof(QSize), value); }
        }
        [Q_PROPERTY("QPalette", "palette")]
        public QPalette Palette {
            get { return (QPalette) interceptor.Invoke("palette", "palette()", typeof(QPalette)); }
            set { interceptor.Invoke("setPalette#", "setPalette(QPalette)", typeof(void), typeof(QPalette), value); }
        }
        [Q_PROPERTY("QFont", "font")]
        public QFont Font {
            get { return (QFont) interceptor.Invoke("font", "font()", typeof(QFont)); }
            set { interceptor.Invoke("setFont#", "setFont(QFont)", typeof(void), typeof(QFont), value); }
        }
        [Q_PROPERTY("QCursor", "cursor")]
        public QCursor Cursor {
            get { return (QCursor) interceptor.Invoke("cursor", "cursor()", typeof(QCursor)); }
            set { interceptor.Invoke("setCursor#", "setCursor(QCursor)", typeof(void), typeof(QCursor), value); }
        }
        [Q_PROPERTY("bool", "mouseTracking")]
        public bool MouseTracking {
            get { return (bool) interceptor.Invoke("hasMouseTracking", "hasMouseTracking()", typeof(bool)); }
            set { interceptor.Invoke("setMouseTracking$", "setMouseTracking(bool)", typeof(void), typeof(bool), value); }
        }
        [Q_PROPERTY("bool", "isActiveWindow")]
        public bool IsActiveWindow {
            get { return (bool) interceptor.Invoke("isActiveWindow", "isActiveWindow()", typeof(bool)); }
        }
        [Q_PROPERTY("Qt::FocusPolicy", "focusPolicy")]
        public new Qt.FocusPolicy FocusPolicy {
            get { return (Qt.FocusPolicy) interceptor.Invoke("focusPolicy", "focusPolicy()", typeof(Qt.FocusPolicy)); }
            set { interceptor.Invoke("setFocusPolicy$", "setFocusPolicy(Qt::FocusPolicy)", typeof(void), typeof(Qt.FocusPolicy), value); }
        }
        [Q_PROPERTY("bool", "focus")]
        public bool Focus {
            get { return (bool) interceptor.Invoke("hasFocus", "hasFocus()", typeof(bool)); }
        }
        [Q_PROPERTY("Qt::ContextMenuPolicy", "contextMenuPolicy")]
        public new Qt.ContextMenuPolicy ContextMenuPolicy {
            get { return (Qt.ContextMenuPolicy) interceptor.Invoke("contextMenuPolicy", "contextMenuPolicy()", typeof(Qt.ContextMenuPolicy)); }
            set { interceptor.Invoke("setContextMenuPolicy$", "setContextMenuPolicy(Qt::ContextMenuPolicy)", typeof(void), typeof(Qt.ContextMenuPolicy), value); }
        }
        [Q_PROPERTY("bool", "updatesEnabled")]
        public bool UpdatesEnabled {
            get { return (bool) interceptor.Invoke("updatesEnabled", "updatesEnabled()", typeof(bool)); }
            set { interceptor.Invoke("setUpdatesEnabled$", "setUpdatesEnabled(bool)", typeof(void), typeof(bool), value); }
        }
        [Q_PROPERTY("bool", "minimized")]
        public bool Minimized {
            get { return (bool) interceptor.Invoke("isMinimized", "isMinimized()", typeof(bool)); }
        }
        [Q_PROPERTY("bool", "maximized")]
        public bool Maximized {
            get { return (bool) interceptor.Invoke("isMaximized", "isMaximized()", typeof(bool)); }
        }
        [Q_PROPERTY("bool", "fullScreen")]
        public bool FullScreen {
            get { return (bool) interceptor.Invoke("isFullScreen", "isFullScreen()", typeof(bool)); }
        }
        [Q_PROPERTY("bool", "acceptDrops")]
        public bool AcceptDrops {
            get { return (bool) interceptor.Invoke("acceptDrops", "acceptDrops()", typeof(bool)); }
            set { interceptor.Invoke("setAcceptDrops$", "setAcceptDrops(bool)", typeof(void), typeof(bool), value); }
        }
        [Q_PROPERTY("QString", "windowTitle")]
        public string WindowTitle {
            get { return (string) interceptor.Invoke("windowTitle", "windowTitle()", typeof(string)); }
            set { interceptor.Invoke("setWindowTitle$", "setWindowTitle(QString)", typeof(void), typeof(string), value); }
        }
        [Q_PROPERTY("QIcon", "windowIcon")]
        public QIcon WindowIcon {
            get { return (QIcon) interceptor.Invoke("windowIcon", "windowIcon()", typeof(QIcon)); }
            set { interceptor.Invoke("setWindowIcon#", "setWindowIcon(QIcon)", typeof(void), typeof(QIcon), value); }
        }
        [Q_PROPERTY("QString", "windowIconText")]
        public string WindowIconText {
            get { return (string) interceptor.Invoke("windowIconText", "windowIconText()", typeof(string)); }
            set { interceptor.Invoke("setWindowIconText$", "setWindowIconText(QString)", typeof(void), typeof(string), value); }
        }
        [Q_PROPERTY("double", "windowOpacity")]
        public double WindowOpacity {
            get { return (double) interceptor.Invoke("windowOpacity", "windowOpacity()", typeof(double)); }
            set { interceptor.Invoke("setWindowOpacity$", "setWindowOpacity(double)", typeof(void), typeof(double), value); }
        }
        [Q_PROPERTY("bool", "windowModified")]
        public bool WindowModified {
            get { return (bool) interceptor.Invoke("isWindowModified", "isWindowModified()", typeof(bool)); }
            set { interceptor.Invoke("setWindowModified$", "setWindowModified(bool)", typeof(void), typeof(bool), value); }
        }
        [Q_PROPERTY("QString", "toolTip")]
        public string ToolTip {
            get { return (string) interceptor.Invoke("toolTip", "toolTip()", typeof(string)); }
            set { interceptor.Invoke("setToolTip$", "setToolTip(QString)", typeof(void), typeof(string), value); }
        }
        [Q_PROPERTY("QString", "statusTip")]
        public string StatusTip {
            get { return (string) interceptor.Invoke("statusTip", "statusTip()", typeof(string)); }
            set { interceptor.Invoke("setStatusTip$", "setStatusTip(QString)", typeof(void), typeof(string), value); }
        }
        [Q_PROPERTY("QString", "whatsThis")]
        public string WhatsThis {
            get { return (string) interceptor.Invoke("whatsThis", "whatsThis()", typeof(string)); }
            set { interceptor.Invoke("setWhatsThis$", "setWhatsThis(QString)", typeof(void), typeof(string), value); }
        }
        [Q_PROPERTY("QString", "accessibleName")]
        public string AccessibleName {
            get { return (string) interceptor.Invoke("accessibleName", "accessibleName()", typeof(string)); }
            set { interceptor.Invoke("setAccessibleName$", "setAccessibleName(QString)", typeof(void), typeof(string), value); }
        }
        [Q_PROPERTY("QString", "accessibleDescription")]
        public string AccessibleDescription {
            get { return (string) interceptor.Invoke("accessibleDescription", "accessibleDescription()", typeof(string)); }
            set { interceptor.Invoke("setAccessibleDescription$", "setAccessibleDescription(QString)", typeof(void), typeof(string), value); }
        }
        [Q_PROPERTY("Qt::LayoutDirection", "layoutDirection")]
        public new Qt.LayoutDirection LayoutDirection {
            get { return (Qt.LayoutDirection) interceptor.Invoke("layoutDirection", "layoutDirection()", typeof(Qt.LayoutDirection)); }
            set { interceptor.Invoke("setLayoutDirection$", "setLayoutDirection(Qt::LayoutDirection)", typeof(void), typeof(Qt.LayoutDirection), value); }
        }
        [Q_PROPERTY("Qt::WindowFlags", "windowFlags")]
        public uint WindowFlags {
            get { return (uint) interceptor.Invoke("windowFlags", "windowFlags()", typeof(uint)); }
            set { interceptor.Invoke("setWindowFlags$", "setWindowFlags(Qt::WindowFlags)", typeof(void), typeof(uint), value); }
        }
        [Q_PROPERTY("bool", "autoFillBackground")]
        public bool AutoFillBackground {
            get { return (bool) interceptor.Invoke("autoFillBackground", "autoFillBackground()", typeof(bool)); }
            set { interceptor.Invoke("setAutoFillBackground$", "setAutoFillBackground(bool)", typeof(void), typeof(bool), value); }
        }
        [Q_PROPERTY("QString", "styleSheet")]
        public string StyleSheet {
            get { return (string) interceptor.Invoke("styleSheet", "styleSheet()", typeof(string)); }
            set { interceptor.Invoke("setStyleSheet$", "setStyleSheet(QString)", typeof(void), typeof(string), value); }
        }
        [Q_PROPERTY("QLocale", "locale")]
        public QLocale Locale {
            get { return (QLocale) interceptor.Invoke("locale", "locale()", typeof(QLocale)); }
            set { interceptor.Invoke("setLocale#", "setLocale(QLocale)", typeof(void), typeof(QLocale), value); }
        }
        [Q_PROPERTY("QString", "windowFilePath")]
        public string WindowFilePath {
            get { return (string) interceptor.Invoke("windowFilePath", "windowFilePath()", typeof(string)); }
            set { interceptor.Invoke("setWindowFilePath$", "setWindowFilePath(QString)", typeof(void), typeof(string), value); }
        }
        // void setWindowSurface(QWindowSurface* arg1); >>>> NOT CONVERTED
        // QWindowSurface* windowSurface(); >>>> NOT CONVERTED
        // QWidget* QWidget(QWidgetPrivate& arg1,QWidget* arg2,Qt::WindowFlags arg3); >>>> NOT CONVERTED
        public QWidget(QWidget parent, uint f) : this((Type) null) {
            CreateProxy();
            interceptor.Invoke("QWidget#$", "QWidget(QWidget*, Qt::WindowFlags)", typeof(void), typeof(QWidget), parent, typeof(uint), f);
        }
        public QWidget(QWidget parent) : this((Type) null) {
            CreateProxy();
            interceptor.Invoke("QWidget#", "QWidget(QWidget*)", typeof(void), typeof(QWidget), parent);
        }
        public QWidget() : this((Type) null) {
            CreateProxy();
            interceptor.Invoke("QWidget", "QWidget()", typeof(void));
        }
        [SmokeMethod("devType() const")]
        public virtual int DevType() {
            return (int) interceptor.Invoke("devType", "devType() const", typeof(int));
        }
        public uint WinId() {
            return (uint) interceptor.Invoke("winId", "winId() const", typeof(uint));
        }
        public void CreateWinId() {
            interceptor.Invoke("createWinId", "createWinId()", typeof(void));
        }
        public uint InternalWinId() {
            return (uint) interceptor.Invoke("internalWinId", "internalWinId() const", typeof(uint));
        }
        public uint EffectiveWinId() {
            return (uint) interceptor.Invoke("effectiveWinId", "effectiveWinId() const", typeof(uint));
        }
        public QStyle Style() {
            return (QStyle) interceptor.Invoke("style", "style() const", typeof(QStyle));
        }
        public void SetStyle(QStyle arg1) {
            interceptor.Invoke("setStyle#", "setStyle(QStyle*)", typeof(void), typeof(QStyle), arg1);
        }
        public bool IsTopLevel() {
            return (bool) interceptor.Invoke("isTopLevel", "isTopLevel() const", typeof(bool));
        }
        public bool IsWindow() {
            return (bool) interceptor.Invoke("isWindow", "isWindow() const", typeof(bool));
        }
        public bool IsEnabledTo(QWidget arg1) {
            return (bool) interceptor.Invoke("isEnabledTo#", "isEnabledTo(QWidget*) const", typeof(bool), typeof(QWidget), arg1);
        }
        public bool IsEnabledToTLW() {
            return (bool) interceptor.Invoke("isEnabledToTLW", "isEnabledToTLW() const", typeof(bool));
        }
        public int Width() {
            return (int) interceptor.Invoke("width", "width() const", typeof(int));
        }
        public int Height() {
            return (int) interceptor.Invoke("height", "height() const", typeof(int));
        }
        public void SetMinimumSize(int minw, int minh) {
            interceptor.Invoke("setMinimumSize$$", "setMinimumSize(int, int)", typeof(void), typeof(int), minw, typeof(int), minh);
        }
        public void SetMaximumSize(int maxw, int maxh) {
            interceptor.Invoke("setMaximumSize$$", "setMaximumSize(int, int)", typeof(void), typeof(int), maxw, typeof(int), maxh);
        }
        public void SetSizeIncrement(int w, int h) {
            interceptor.Invoke("setSizeIncrement$$", "setSizeIncrement(int, int)", typeof(void), typeof(int), w, typeof(int), h);
        }
        public void SetBaseSize(int basew, int baseh) {
            interceptor.Invoke("setBaseSize$$", "setBaseSize(int, int)", typeof(void), typeof(int), basew, typeof(int), baseh);
        }
        public void SetFixedSize(QSize arg1) {
            interceptor.Invoke("setFixedSize#", "setFixedSize(const QSize&)", typeof(void), typeof(QSize), arg1);
        }
        public void SetFixedSize(int w, int h) {
            interceptor.Invoke("setFixedSize$$", "setFixedSize(int, int)", typeof(void), typeof(int), w, typeof(int), h);
        }
        public void SetFixedWidth(int w) {
            interceptor.Invoke("setFixedWidth$", "setFixedWidth(int)", typeof(void), typeof(int), w);
        }
        public void SetFixedHeight(int h) {
            interceptor.Invoke("setFixedHeight$", "setFixedHeight(int)", typeof(void), typeof(int), h);
        }
        public QPoint MapToGlobal(QPoint arg1) {
            return (QPoint) interceptor.Invoke("mapToGlobal#", "mapToGlobal(const QPoint&) const", typeof(QPoint), typeof(QPoint), arg1);
        }
        public QPoint MapFromGlobal(QPoint arg1) {
            return (QPoint) interceptor.Invoke("mapFromGlobal#", "mapFromGlobal(const QPoint&) const", typeof(QPoint), typeof(QPoint), arg1);
        }
        public QPoint MapToParent(QPoint arg1) {
            return (QPoint) interceptor.Invoke("mapToParent#", "mapToParent(const QPoint&) const", typeof(QPoint), typeof(QPoint), arg1);
        }
        public QPoint MapFromParent(QPoint arg1) {
            return (QPoint) interceptor.Invoke("mapFromParent#", "mapFromParent(const QPoint&) const", typeof(QPoint), typeof(QPoint), arg1);
        }
        public QPoint MapTo(QWidget arg1, QPoint arg2) {
            return (QPoint) interceptor.Invoke("mapTo##", "mapTo(QWidget*, const QPoint&) const", typeof(QPoint), typeof(QWidget), arg1, typeof(QPoint), arg2);
        }
        public QPoint MapFrom(QWidget arg1, QPoint arg2) {
            return (QPoint) interceptor.Invoke("mapFrom##", "mapFrom(QWidget*, const QPoint&) const", typeof(QPoint), typeof(QWidget), arg1, typeof(QPoint), arg2);
        }
        public QWidget Window() {
            return (QWidget) interceptor.Invoke("window", "window() const", typeof(QWidget));
        }
        public QWidget NativeParentWidget() {
            return (QWidget) interceptor.Invoke("nativeParentWidget", "nativeParentWidget() const", typeof(QWidget));
        }
        public QWidget TopLevelWidget() {
            return (QWidget) interceptor.Invoke("topLevelWidget", "topLevelWidget() const", typeof(QWidget));
        }
        public void SetBackgroundRole(QPalette.ColorRole arg1) {
            interceptor.Invoke("setBackgroundRole$", "setBackgroundRole(QPalette::ColorRole)", typeof(void), typeof(QPalette.ColorRole), arg1);
        }
        public QPalette.ColorRole BackgroundRole() {
            return (QPalette.ColorRole) interceptor.Invoke("backgroundRole", "backgroundRole() const", typeof(QPalette.ColorRole));
        }
        public void SetForegroundRole(QPalette.ColorRole arg1) {
            interceptor.Invoke("setForegroundRole$", "setForegroundRole(QPalette::ColorRole)", typeof(void), typeof(QPalette.ColorRole), arg1);
        }
        public QPalette.ColorRole ForegroundRole() {
            return (QPalette.ColorRole) interceptor.Invoke("foregroundRole", "foregroundRole() const", typeof(QPalette.ColorRole));
        }
        public QFontMetrics FontMetrics() {
            return (QFontMetrics) interceptor.Invoke("fontMetrics", "fontMetrics() const", typeof(QFontMetrics));
        }
        public QFontInfo FontInfo() {
            return (QFontInfo) interceptor.Invoke("fontInfo", "fontInfo() const", typeof(QFontInfo));
        }
        public void UnsetCursor() {
            interceptor.Invoke("unsetCursor", "unsetCursor()", typeof(void));
        }
        public bool UnderMouse() {
            return (bool) interceptor.Invoke("underMouse", "underMouse() const", typeof(bool));
        }
        public void SetMask(QBitmap arg1) {
            interceptor.Invoke("setMask#", "setMask(const QBitmap&)", typeof(void), typeof(QBitmap), arg1);
        }
        public void SetMask(QRegion arg1) {
            interceptor.Invoke("setMask#", "setMask(const QRegion&)", typeof(void), typeof(QRegion), arg1);
        }
        public QRegion Mask() {
            return (QRegion) interceptor.Invoke("mask", "mask() const", typeof(QRegion));
        }
        public void ClearMask() {
            interceptor.Invoke("clearMask", "clearMask()", typeof(void));
        }
        public void Render(IQPaintDevice target, QPoint targetOffset, QRegion sourceRegion, uint renderFlags) {
            interceptor.Invoke("render###$", "render(QPaintDevice*, const QPoint&, const QRegion&, QWidget::RenderFlags)", typeof(void), typeof(IQPaintDevice), target, typeof(QPoint), targetOffset, typeof(QRegion), sourceRegion, typeof(uint), renderFlags);
        }
        public void Render(IQPaintDevice target, QPoint targetOffset, QRegion sourceRegion) {
            interceptor.Invoke("render###", "render(QPaintDevice*, const QPoint&, const QRegion&)", typeof(void), typeof(IQPaintDevice), target, typeof(QPoint), targetOffset, typeof(QRegion), sourceRegion);
        }
        public void Render(IQPaintDevice target, QPoint targetOffset) {
            interceptor.Invoke("render##", "render(QPaintDevice*, const QPoint&)", typeof(void), typeof(IQPaintDevice), target, typeof(QPoint), targetOffset);
        }
        public void Render(IQPaintDevice target) {
            interceptor.Invoke("render#", "render(QPaintDevice*)", typeof(void), typeof(IQPaintDevice), target);
        }
        public void Render(QPainter painter, QPoint targetOffset, QRegion sourceRegion, uint renderFlags) {
            interceptor.Invoke("render###$", "render(QPainter*, const QPoint&, const QRegion&, QWidget::RenderFlags)", typeof(void), typeof(QPainter), painter, typeof(QPoint), targetOffset, typeof(QRegion), sourceRegion, typeof(uint), renderFlags);
        }
        public void Render(QPainter painter, QPoint targetOffset, QRegion sourceRegion) {
            interceptor.Invoke("render###", "render(QPainter*, const QPoint&, const QRegion&)", typeof(void), typeof(QPainter), painter, typeof(QPoint), targetOffset, typeof(QRegion), sourceRegion);
        }
        public void Render(QPainter painter, QPoint targetOffset) {
            interceptor.Invoke("render##", "render(QPainter*, const QPoint&)", typeof(void), typeof(QPainter), painter, typeof(QPoint), targetOffset);
        }
        public void Render(QPainter painter) {
            interceptor.Invoke("render#", "render(QPainter*)", typeof(void), typeof(QPainter), painter);
        }
        public void SetWindowRole(string arg1) {
            interceptor.Invoke("setWindowRole$", "setWindowRole(const QString&)", typeof(void), typeof(string), arg1);
        }
        public string WindowRole() {
            return (string) interceptor.Invoke("windowRole", "windowRole() const", typeof(string));
        }
        public void UnsetLayoutDirection() {
            interceptor.Invoke("unsetLayoutDirection", "unsetLayoutDirection()", typeof(void));
        }
        public void UnsetLocale() {
            interceptor.Invoke("unsetLocale", "unsetLocale()", typeof(void));
        }
        public bool IsRightToLeft() {
            return (bool) interceptor.Invoke("isRightToLeft", "isRightToLeft() const", typeof(bool));
        }
        public bool IsLeftToRight() {
            return (bool) interceptor.Invoke("isLeftToRight", "isLeftToRight() const", typeof(bool));
        }
        public void ActivateWindow() {
            interceptor.Invoke("activateWindow", "activateWindow()", typeof(void));
        }
        public void ClearFocus() {
            interceptor.Invoke("clearFocus", "clearFocus()", typeof(void));
        }
        public void SetFocusProxy(QWidget arg1) {
            interceptor.Invoke("setFocusProxy#", "setFocusProxy(QWidget*)", typeof(void), typeof(QWidget), arg1);
        }
        public QWidget FocusProxy() {
            return (QWidget) interceptor.Invoke("focusProxy", "focusProxy() const", typeof(QWidget));
        }
        public void GrabMouse() {
            interceptor.Invoke("grabMouse", "grabMouse()", typeof(void));
        }
        public void GrabMouse(QCursor arg1) {
            interceptor.Invoke("grabMouse#", "grabMouse(const QCursor&)", typeof(void), typeof(QCursor), arg1);
        }
        public void ReleaseMouse() {
            interceptor.Invoke("releaseMouse", "releaseMouse()", typeof(void));
        }
        public void GrabKeyboard() {
            interceptor.Invoke("grabKeyboard", "grabKeyboard()", typeof(void));
        }
        public void ReleaseKeyboard() {
            interceptor.Invoke("releaseKeyboard", "releaseKeyboard()", typeof(void));
        }
        public int GrabShortcut(QKeySequence key, Qt.ShortcutContext context) {
            return (int) interceptor.Invoke("grabShortcut#$", "grabShortcut(const QKeySequence&, Qt::ShortcutContext)", typeof(int), typeof(QKeySequence), key, typeof(Qt.ShortcutContext), context);
        }
        public int GrabShortcut(QKeySequence key) {
            return (int) interceptor.Invoke("grabShortcut#", "grabShortcut(const QKeySequence&)", typeof(int), typeof(QKeySequence), key);
        }
        public void ReleaseShortcut(int id) {
            interceptor.Invoke("releaseShortcut$", "releaseShortcut(int)", typeof(void), typeof(int), id);
        }
        public void SetShortcutEnabled(int id, bool enable) {
            interceptor.Invoke("setShortcutEnabled$$", "setShortcutEnabled(int, bool)", typeof(void), typeof(int), id, typeof(bool), enable);
        }
        public void SetShortcutEnabled(int id) {
            interceptor.Invoke("setShortcutEnabled$", "setShortcutEnabled(int)", typeof(void), typeof(int), id);
        }
        public void SetShortcutAutoRepeat(int id, bool enable) {
            interceptor.Invoke("setShortcutAutoRepeat$$", "setShortcutAutoRepeat(int, bool)", typeof(void), typeof(int), id, typeof(bool), enable);
        }
        public void SetShortcutAutoRepeat(int id) {
            interceptor.Invoke("setShortcutAutoRepeat$", "setShortcutAutoRepeat(int)", typeof(void), typeof(int), id);
        }
        public void Update(int x, int y, int w, int h) {
            interceptor.Invoke("update$$$$", "update(int, int, int, int)", typeof(void), typeof(int), x, typeof(int), y, typeof(int), w, typeof(int), h);
        }
        public void Update(QRect arg1) {
            interceptor.Invoke("update#", "update(const QRect&)", typeof(void), typeof(QRect), arg1);
        }
        public void Update(QRegion arg1) {
            interceptor.Invoke("update#", "update(const QRegion&)", typeof(void), typeof(QRegion), arg1);
        }
        public void Repaint(int x, int y, int w, int h) {
            interceptor.Invoke("repaint$$$$", "repaint(int, int, int, int)", typeof(void), typeof(int), x, typeof(int), y, typeof(int), w, typeof(int), h);
        }
        public void Repaint(QRect arg1) {
            interceptor.Invoke("repaint#", "repaint(const QRect&)", typeof(void), typeof(QRect), arg1);
        }
        public void Repaint(QRegion arg1) {
            interceptor.Invoke("repaint#", "repaint(const QRegion&)", typeof(void), typeof(QRegion), arg1);
        }
        public void StackUnder(QWidget arg1) {
            interceptor.Invoke("stackUnder#", "stackUnder(QWidget*)", typeof(void), typeof(QWidget), arg1);
        }
        public void Move(int x, int y) {
            interceptor.Invoke("move$$", "move(int, int)", typeof(void), typeof(int), x, typeof(int), y);
        }
        public void Resize(int w, int h) {
            interceptor.Invoke("resize$$", "resize(int, int)", typeof(void), typeof(int), w, typeof(int), h);
        }
        public void SetGeometry(int x, int y, int w, int h) {
            interceptor.Invoke("setGeometry$$$$", "setGeometry(int, int, int, int)", typeof(void), typeof(int), x, typeof(int), y, typeof(int), w, typeof(int), h);
        }
        public QByteArray SaveGeometry() {
            return (QByteArray) interceptor.Invoke("saveGeometry", "saveGeometry() const", typeof(QByteArray));
        }
        public bool RestoreGeometry(QByteArray geometry) {
            return (bool) interceptor.Invoke("restoreGeometry#", "restoreGeometry(const QByteArray&)", typeof(bool), typeof(QByteArray), geometry);
        }
        public void AdjustSize() {
            interceptor.Invoke("adjustSize", "adjustSize()", typeof(void));
        }
        public bool IsVisible() {
            return (bool) interceptor.Invoke("isVisible", "isVisible() const", typeof(bool));
        }
        public bool IsVisibleTo(QWidget arg1) {
            return (bool) interceptor.Invoke("isVisibleTo#", "isVisibleTo(QWidget*) const", typeof(bool), typeof(QWidget), arg1);
        }
        public bool IsHidden() {
            return (bool) interceptor.Invoke("isHidden", "isHidden() const", typeof(bool));
        }
        public new uint WindowState() {
            return (uint) interceptor.Invoke("windowState", "windowState() const", typeof(uint));
        }
        public void SetWindowState(uint state) {
            interceptor.Invoke("setWindowState$", "setWindowState(Qt::WindowStates)", typeof(void), typeof(uint), state);
        }
        public void OverrideWindowState(uint state) {
            interceptor.Invoke("overrideWindowState$", "overrideWindowState(Qt::WindowStates)", typeof(void), typeof(uint), state);
        }
        [SmokeMethod("sizeHint() const")]
        public new virtual QSize SizeHint() {
            return (QSize) interceptor.Invoke("sizeHint", "sizeHint() const", typeof(QSize));
        }
        [SmokeMethod("minimumSizeHint() const")]
        public virtual QSize MinimumSizeHint() {
            return (QSize) interceptor.Invoke("minimumSizeHint", "minimumSizeHint() const", typeof(QSize));
        }
        public void SetSizePolicy(QSizePolicy.Policy horizontal, QSizePolicy.Policy vertical) {
            interceptor.Invoke("setSizePolicy$$", "setSizePolicy(QSizePolicy::Policy, QSizePolicy::Policy)", typeof(void), typeof(QSizePolicy.Policy), horizontal, typeof(QSizePolicy.Policy), vertical);
        }
        [SmokeMethod("heightForWidth(int) const")]
        public virtual int HeightForWidth(int arg1) {
            return (int) interceptor.Invoke("heightForWidth$", "heightForWidth(int) const", typeof(int), typeof(int), arg1);
        }
        public QRegion VisibleRegion() {
            return (QRegion) interceptor.Invoke("visibleRegion", "visibleRegion() const", typeof(QRegion));
        }
        public void SetContentsMargins(int left, int top, int right, int bottom) {
            interceptor.Invoke("setContentsMargins$$$$", "setContentsMargins(int, int, int, int)", typeof(void), typeof(int), left, typeof(int), top, typeof(int), right, typeof(int), bottom);
        }
        public void GetContentsMargins(ref int left, ref int top, ref int right, ref int bottom) {
            StackItem[] stack = new StackItem[5];
            stack[1].s_int = left;
            stack[2].s_int = top;
            stack[3].s_int = right;
            stack[4].s_int = bottom;
            interceptor.Invoke("getContentsMargins$$$$", "getContentsMargins(int*, int*, int*, int*) const", stack);
            left = stack[1].s_int;
            top = stack[2].s_int;
            right = stack[3].s_int;
            bottom = stack[4].s_int;
            return;
        }
        public QRect ContentsRect() {
            return (QRect) interceptor.Invoke("contentsRect", "contentsRect() const", typeof(QRect));
        }
        public QLayout Layout() {
            return (QLayout) interceptor.Invoke("layout", "layout() const", typeof(QLayout));
        }
        public void SetLayout(QLayout arg1) {
            interceptor.Invoke("setLayout#", "setLayout(QLayout*)", typeof(void), typeof(QLayout), arg1);
        }
        public void UpdateGeometry() {
            interceptor.Invoke("updateGeometry", "updateGeometry()", typeof(void));
        }
        public void SetParent(QWidget parent) {
            interceptor.Invoke("setParent#", "setParent(QWidget*)", typeof(void), typeof(QWidget), parent);
        }
        public void SetParent(QWidget parent, uint f) {
            interceptor.Invoke("setParent#$", "setParent(QWidget*, Qt::WindowFlags)", typeof(void), typeof(QWidget), parent, typeof(uint), f);
        }
        public void Scroll(int dx, int dy) {
            interceptor.Invoke("scroll$$", "scroll(int, int)", typeof(void), typeof(int), dx, typeof(int), dy);
        }
        public void Scroll(int dx, int dy, QRect arg3) {
            interceptor.Invoke("scroll$$#", "scroll(int, int, const QRect&)", typeof(void), typeof(int), dx, typeof(int), dy, typeof(QRect), arg3);
        }
        public QWidget FocusWidget() {
            return (QWidget) interceptor.Invoke("focusWidget", "focusWidget() const", typeof(QWidget));
        }
        public QWidget NextInFocusChain() {
            return (QWidget) interceptor.Invoke("nextInFocusChain", "nextInFocusChain() const", typeof(QWidget));
        }
        public void AddAction(QAction action) {
            interceptor.Invoke("addAction#", "addAction(QAction*)", typeof(void), typeof(QAction), action);
        }
        public void AddActions(List<QAction> actions) {
            interceptor.Invoke("addActions?", "addActions(QList<QAction*>)", typeof(void), typeof(List<QAction>), actions);
        }
        public void InsertAction(QAction before, QAction action) {
            interceptor.Invoke("insertAction##", "insertAction(QAction*, QAction*)", typeof(void), typeof(QAction), before, typeof(QAction), action);
        }
        public void InsertActions(QAction before, List<QAction> actions) {
            interceptor.Invoke("insertActions#?", "insertActions(QAction*, QList<QAction*>)", typeof(void), typeof(QAction), before, typeof(List<QAction>), actions);
        }
        public void RemoveAction(QAction action) {
            interceptor.Invoke("removeAction#", "removeAction(QAction*)", typeof(void), typeof(QAction), action);
        }
        public List<QAction> Actions() {
            return (List<QAction>) interceptor.Invoke("actions", "actions() const", typeof(List<QAction>));
        }
        public QWidget ParentWidget() {
            return (QWidget) interceptor.Invoke("parentWidget", "parentWidget() const", typeof(QWidget));
        }
        public void OverrideWindowFlags(uint type) {
            interceptor.Invoke("overrideWindowFlags$", "overrideWindowFlags(Qt::WindowFlags)", typeof(void), typeof(uint), type);
        }
        public new Qt.WindowType WindowType() {
            return (Qt.WindowType) interceptor.Invoke("windowType", "windowType() const", typeof(Qt.WindowType));
        }
        public QWidget ChildAt(int x, int y) {
            return (QWidget) interceptor.Invoke("childAt$$", "childAt(int, int) const", typeof(QWidget), typeof(int), x, typeof(int), y);
        }
        public QWidget ChildAt(QPoint p) {
            return (QWidget) interceptor.Invoke("childAt#", "childAt(const QPoint&) const", typeof(QWidget), typeof(QPoint), p);
        }
        public void SetAttribute(Qt.WidgetAttribute arg1, bool on) {
            interceptor.Invoke("setAttribute$$", "setAttribute(Qt::WidgetAttribute, bool)", typeof(void), typeof(Qt.WidgetAttribute), arg1, typeof(bool), on);
        }
        public void SetAttribute(Qt.WidgetAttribute arg1) {
            interceptor.Invoke("setAttribute$", "setAttribute(Qt::WidgetAttribute)", typeof(void), typeof(Qt.WidgetAttribute), arg1);
        }
        public bool TestAttribute(Qt.WidgetAttribute arg1) {
            return (bool) interceptor.Invoke("testAttribute$", "testAttribute(Qt::WidgetAttribute) const", typeof(bool), typeof(Qt.WidgetAttribute), arg1);
        }
        [SmokeMethod("paintEngine() const")]
        public virtual QPaintEngine PaintEngine() {
            return (QPaintEngine) interceptor.Invoke("paintEngine", "paintEngine() const", typeof(QPaintEngine));
        }
        public void EnsurePolished() {
            interceptor.Invoke("ensurePolished", "ensurePolished() const", typeof(void));
        }
        public QInputContext InputContext() {
            return (QInputContext) interceptor.Invoke("inputContext", "inputContext()", typeof(QInputContext));
        }
        public void SetInputContext(QInputContext arg1) {
            interceptor.Invoke("setInputContext#", "setInputContext(QInputContext*)", typeof(void), typeof(QInputContext), arg1);
        }
        public bool IsAncestorOf(QWidget child) {
            return (bool) interceptor.Invoke("isAncestorOf#", "isAncestorOf(const QWidget*) const", typeof(bool), typeof(QWidget), child);
        }
        [SmokeMethod("inputMethodQuery(Qt::InputMethodQuery) const")]
        public new virtual QVariant InputMethodQuery(Qt.InputMethodQuery arg1) {
            return (QVariant) interceptor.Invoke("inputMethodQuery$", "inputMethodQuery(Qt::InputMethodQuery) const", typeof(QVariant), typeof(Qt.InputMethodQuery), arg1);
        }
        [Q_SLOT("void setEnabled(bool)")]
        public void SetEnabled(bool arg1) {
            interceptor.Invoke("setEnabled$", "setEnabled(bool)", typeof(void), typeof(bool), arg1);
        }
        [Q_SLOT("void setDisabled(bool)")]
        public void SetDisabled(bool arg1) {
            interceptor.Invoke("setDisabled$", "setDisabled(bool)", typeof(void), typeof(bool), arg1);
        }
        [Q_SLOT("void setWindowModified(bool)")]
        public void SetWindowModified(bool arg1) {
            interceptor.Invoke("setWindowModified$", "setWindowModified(bool)", typeof(void), typeof(bool), arg1);
        }
        [Q_SLOT("void setWindowTitle(QString)")]
        public void SetWindowTitle(string arg1) {
            interceptor.Invoke("setWindowTitle$", "setWindowTitle(const QString&)", typeof(void), typeof(string), arg1);
        }
        [Q_SLOT("void setStyleSheet(QString)")]
        public void SetStyleSheet(string styleSheet) {
            interceptor.Invoke("setStyleSheet$", "setStyleSheet(const QString&)", typeof(void), typeof(string), styleSheet);
        }
        [Q_SLOT("void setFocus()")]
        public void SetFocus() {
            interceptor.Invoke("setFocus", "setFocus()", typeof(void));
        }
        [Q_SLOT("void update()")]
        public void Update() {
            interceptor.Invoke("update", "update()", typeof(void));
        }
        [Q_SLOT("void repaint()")]
        public void Repaint() {
            interceptor.Invoke("repaint", "repaint()", typeof(void));
        }
        [Q_SLOT("void setVisible(bool)")]
        [SmokeMethod("setVisible(bool)")]
        public virtual void SetVisible(bool visible) {
            interceptor.Invoke("setVisible$", "setVisible(bool)", typeof(void), typeof(bool), visible);
        }
        [Q_SLOT("void setHidden(bool)")]
        public void SetHidden(bool hidden) {
            interceptor.Invoke("setHidden$", "setHidden(bool)", typeof(void), typeof(bool), hidden);
        }
        [Q_SLOT("void show()")]
        public void Show() {
            interceptor.Invoke("show", "show()", typeof(void));
        }
        [Q_SLOT("void hide()")]
        public void Hide() {
            interceptor.Invoke("hide", "hide()", typeof(void));
        }
        [Q_SLOT("void setShown(bool)")]
        public void SetShown(bool shown) {
            interceptor.Invoke("setShown$", "setShown(bool)", typeof(void), typeof(bool), shown);
        }
        [Q_SLOT("void showMinimized()")]
        public void ShowMinimized() {
            interceptor.Invoke("showMinimized", "showMinimized()", typeof(void));
        }
        [Q_SLOT("void showMaximized()")]
        public void ShowMaximized() {
            interceptor.Invoke("showMaximized", "showMaximized()", typeof(void));
        }
        [Q_SLOT("void showFullScreen()")]
        public void ShowFullScreen() {
            interceptor.Invoke("showFullScreen", "showFullScreen()", typeof(void));
        }
        [Q_SLOT("void showNormal()")]
        public void ShowNormal() {
            interceptor.Invoke("showNormal", "showNormal()", typeof(void));
        }
        [Q_SLOT("bool close()")]
        public bool Close() {
            return (bool) interceptor.Invoke("close", "close()", typeof(bool));
        }
        [Q_SLOT("void raise()")]
        public void Raise() {
            interceptor.Invoke("raise", "raise()", typeof(void));
        }
        [Q_SLOT("void lower()")]
        public void Lower() {
            interceptor.Invoke("lower", "lower()", typeof(void));
        }
        [SmokeMethod("event(QEvent*)")]
        protected new virtual bool Event(QEvent arg1) {
            return (bool) interceptor.Invoke("event#", "event(QEvent*)", typeof(bool), typeof(QEvent), arg1);
        }
        [SmokeMethod("mousePressEvent(QMouseEvent*)")]
        protected virtual void MousePressEvent(QMouseEvent arg1) {
            interceptor.Invoke("mousePressEvent#", "mousePressEvent(QMouseEvent*)", typeof(void), typeof(QMouseEvent), arg1);
        }
        [SmokeMethod("mouseReleaseEvent(QMouseEvent*)")]
        protected virtual void MouseReleaseEvent(QMouseEvent arg1) {
            interceptor.Invoke("mouseReleaseEvent#", "mouseReleaseEvent(QMouseEvent*)", typeof(void), typeof(QMouseEvent), arg1);
        }
        [SmokeMethod("mouseDoubleClickEvent(QMouseEvent*)")]
        protected virtual void MouseDoubleClickEvent(QMouseEvent arg1) {
            interceptor.Invoke("mouseDoubleClickEvent#", "mouseDoubleClickEvent(QMouseEvent*)", typeof(void), typeof(QMouseEvent), arg1);
        }
        [SmokeMethod("mouseMoveEvent(QMouseEvent*)")]
        protected virtual void MouseMoveEvent(QMouseEvent arg1) {
            interceptor.Invoke("mouseMoveEvent#", "mouseMoveEvent(QMouseEvent*)", typeof(void), typeof(QMouseEvent), arg1);
        }
        [SmokeMethod("wheelEvent(QWheelEvent*)")]
        protected virtual void WheelEvent(QWheelEvent arg1) {
            interceptor.Invoke("wheelEvent#", "wheelEvent(QWheelEvent*)", typeof(void), typeof(QWheelEvent), arg1);
        }
        [SmokeMethod("keyPressEvent(QKeyEvent*)")]
        protected virtual void KeyPressEvent(QKeyEvent arg1) {
            interceptor.Invoke("keyPressEvent#", "keyPressEvent(QKeyEvent*)", typeof(void), typeof(QKeyEvent), arg1);
        }
        [SmokeMethod("keyReleaseEvent(QKeyEvent*)")]
        protected virtual void KeyReleaseEvent(QKeyEvent arg1) {
            interceptor.Invoke("keyReleaseEvent#", "keyReleaseEvent(QKeyEvent*)", typeof(void), typeof(QKeyEvent), arg1);
        }
        [SmokeMethod("focusInEvent(QFocusEvent*)")]
        protected virtual void FocusInEvent(QFocusEvent arg1) {
            interceptor.Invoke("focusInEvent#", "focusInEvent(QFocusEvent*)", typeof(void), typeof(QFocusEvent), arg1);
        }
        [SmokeMethod("focusOutEvent(QFocusEvent*)")]
        protected virtual void FocusOutEvent(QFocusEvent arg1) {
            interceptor.Invoke("focusOutEvent#", "focusOutEvent(QFocusEvent*)", typeof(void), typeof(QFocusEvent), arg1);
        }
        [SmokeMethod("enterEvent(QEvent*)")]
        protected virtual void EnterEvent(QEvent arg1) {
            interceptor.Invoke("enterEvent#", "enterEvent(QEvent*)", typeof(void), typeof(QEvent), arg1);
        }
        [SmokeMethod("leaveEvent(QEvent*)")]
        protected virtual void LeaveEvent(QEvent arg1) {
            interceptor.Invoke("leaveEvent#", "leaveEvent(QEvent*)", typeof(void), typeof(QEvent), arg1);
        }
        [SmokeMethod("paintEvent(QPaintEvent*)")]
        protected virtual void PaintEvent(QPaintEvent arg1) {
            interceptor.Invoke("paintEvent#", "paintEvent(QPaintEvent*)", typeof(void), typeof(QPaintEvent), arg1);
        }
        [SmokeMethod("moveEvent(QMoveEvent*)")]
        protected virtual void MoveEvent(QMoveEvent arg1) {
            interceptor.Invoke("moveEvent#", "moveEvent(QMoveEvent*)", typeof(void), typeof(QMoveEvent), arg1);
        }
        [SmokeMethod("resizeEvent(QResizeEvent*)")]
        protected virtual void ResizeEvent(QResizeEvent arg1) {
            interceptor.Invoke("resizeEvent#", "resizeEvent(QResizeEvent*)", typeof(void), typeof(QResizeEvent), arg1);
        }
        [SmokeMethod("closeEvent(QCloseEvent*)")]
        protected virtual void CloseEvent(QCloseEvent arg1) {
            interceptor.Invoke("closeEvent#", "closeEvent(QCloseEvent*)", typeof(void), typeof(QCloseEvent), arg1);
        }
        [SmokeMethod("contextMenuEvent(QContextMenuEvent*)")]
        protected virtual void ContextMenuEvent(QContextMenuEvent arg1) {
            interceptor.Invoke("contextMenuEvent#", "contextMenuEvent(QContextMenuEvent*)", typeof(void), typeof(QContextMenuEvent), arg1);
        }
        [SmokeMethod("tabletEvent(QTabletEvent*)")]
        protected virtual void TabletEvent(QTabletEvent arg1) {
            interceptor.Invoke("tabletEvent#", "tabletEvent(QTabletEvent*)", typeof(void), typeof(QTabletEvent), arg1);
        }
        [SmokeMethod("actionEvent(QActionEvent*)")]
        protected virtual void ActionEvent(QActionEvent arg1) {
            interceptor.Invoke("actionEvent#", "actionEvent(QActionEvent*)", typeof(void), typeof(QActionEvent), arg1);
        }
        [SmokeMethod("dragEnterEvent(QDragEnterEvent*)")]
        protected virtual void DragEnterEvent(QDragEnterEvent arg1) {
            interceptor.Invoke("dragEnterEvent#", "dragEnterEvent(QDragEnterEvent*)", typeof(void), typeof(QDragEnterEvent), arg1);
        }
        [SmokeMethod("dragMoveEvent(QDragMoveEvent*)")]
        protected virtual void DragMoveEvent(QDragMoveEvent arg1) {
            interceptor.Invoke("dragMoveEvent#", "dragMoveEvent(QDragMoveEvent*)", typeof(void), typeof(QDragMoveEvent), arg1);
        }
        [SmokeMethod("dragLeaveEvent(QDragLeaveEvent*)")]
        protected virtual void DragLeaveEvent(QDragLeaveEvent arg1) {
            interceptor.Invoke("dragLeaveEvent#", "dragLeaveEvent(QDragLeaveEvent*)", typeof(void), typeof(QDragLeaveEvent), arg1);
        }
        [SmokeMethod("dropEvent(QDropEvent*)")]
        protected virtual void DropEvent(QDropEvent arg1) {
            interceptor.Invoke("dropEvent#", "dropEvent(QDropEvent*)", typeof(void), typeof(QDropEvent), arg1);
        }
        [SmokeMethod("showEvent(QShowEvent*)")]
        protected virtual void ShowEvent(QShowEvent arg1) {
            interceptor.Invoke("showEvent#", "showEvent(QShowEvent*)", typeof(void), typeof(QShowEvent), arg1);
        }
        [SmokeMethod("hideEvent(QHideEvent*)")]
        protected virtual void HideEvent(QHideEvent arg1) {
            interceptor.Invoke("hideEvent#", "hideEvent(QHideEvent*)", typeof(void), typeof(QHideEvent), arg1);
        }
        [SmokeMethod("changeEvent(QEvent*)")]
        protected virtual void ChangeEvent(QEvent arg1) {
            interceptor.Invoke("changeEvent#", "changeEvent(QEvent*)", typeof(void), typeof(QEvent), arg1);
        }
        [SmokeMethod("metric(QPaintDevice::PaintDeviceMetric) const")]
        protected virtual int Metric(QPaintDevice.PaintDeviceMetric arg1) {
            return (int) interceptor.Invoke("metric$", "metric(QPaintDevice::PaintDeviceMetric) const", typeof(int), typeof(QPaintDevice.PaintDeviceMetric), arg1);
        }
        [SmokeMethod("inputMethodEvent(QInputMethodEvent*)")]
        protected virtual void InputMethodEvent(QInputMethodEvent arg1) {
            interceptor.Invoke("inputMethodEvent#", "inputMethodEvent(QInputMethodEvent*)", typeof(void), typeof(QInputMethodEvent), arg1);
        }
        protected void ResetInputContext() {
            interceptor.Invoke("resetInputContext", "resetInputContext()", typeof(void));
        }
        protected void Create(uint arg1, bool initializeWindow, bool destroyOldWindow) {
            interceptor.Invoke("create$$$", "create(WId, bool, bool)", typeof(void), typeof(uint), arg1, typeof(bool), initializeWindow, typeof(bool), destroyOldWindow);
        }
        protected void Create(uint arg1, bool initializeWindow) {
            interceptor.Invoke("create$$", "create(WId, bool)", typeof(void), typeof(uint), arg1, typeof(bool), initializeWindow);
        }
        protected void Create(uint arg1) {
            interceptor.Invoke("create$", "create(WId)", typeof(void), typeof(uint), arg1);
        }
        protected void Create() {
            interceptor.Invoke("create", "create()", typeof(void));
        }
        protected void Destroy(bool destroyWindow, bool destroySubWindows) {
            interceptor.Invoke("destroy$$", "destroy(bool, bool)", typeof(void), typeof(bool), destroyWindow, typeof(bool), destroySubWindows);
        }
        protected void Destroy(bool destroyWindow) {
            interceptor.Invoke("destroy$", "destroy(bool)", typeof(void), typeof(bool), destroyWindow);
        }
        protected void Destroy() {
            interceptor.Invoke("destroy", "destroy()", typeof(void));
        }
        [SmokeMethod("focusNextPrevChild(bool)")]
        protected virtual bool FocusNextPrevChild(bool next) {
            return (bool) interceptor.Invoke("focusNextPrevChild$", "focusNextPrevChild(bool)", typeof(bool), typeof(bool), next);
        }
        protected bool FocusNextChild() {
            return (bool) interceptor.Invoke("focusNextChild", "focusNextChild()", typeof(bool));
        }
        protected bool FocusPreviousChild() {
            return (bool) interceptor.Invoke("focusPreviousChild", "focusPreviousChild()", typeof(bool));
        }
        [SmokeMethod("styleChange(QStyle&)")]
        protected virtual void StyleChange(QStyle arg1) {
            interceptor.Invoke("styleChange#", "styleChange(QStyle&)", typeof(void), typeof(QStyle), arg1);
        }
        [SmokeMethod("enabledChange(bool)")]
        protected virtual void EnabledChange(bool arg1) {
            interceptor.Invoke("enabledChange$", "enabledChange(bool)", typeof(void), typeof(bool), arg1);
        }
        [SmokeMethod("paletteChange(const QPalette&)")]
        protected virtual void PaletteChange(QPalette arg1) {
            interceptor.Invoke("paletteChange#", "paletteChange(const QPalette&)", typeof(void), typeof(QPalette), arg1);
        }
        [SmokeMethod("fontChange(const QFont&)")]
        protected virtual void FontChange(QFont arg1) {
            interceptor.Invoke("fontChange#", "fontChange(const QFont&)", typeof(void), typeof(QFont), arg1);
        }
        [SmokeMethod("windowActivationChange(bool)")]
        protected virtual void WindowActivationChange(bool arg1) {
            interceptor.Invoke("windowActivationChange$", "windowActivationChange(bool)", typeof(void), typeof(bool), arg1);
        }
        [SmokeMethod("languageChange()")]
        protected virtual void LanguageChange() {
            interceptor.Invoke("languageChange", "languageChange()", typeof(void));
        }
        [Q_SLOT("void updateMicroFocus()")]
        protected void UpdateMicroFocus() {
            interceptor.Invoke("updateMicroFocus", "updateMicroFocus()", typeof(void));
        }
        ~QWidget() {
            interceptor.Invoke("~QWidget", "~QWidget()", typeof(void));
        }
        public new void Dispose() {
            interceptor.Invoke("~QWidget", "~QWidget()", typeof(void));
        }
        public bool PaintingActive() {
            return (bool) interceptor.Invoke("paintingActive", "paintingActive() const", typeof(bool));
        }
        public int WidthMM() {
            return (int) interceptor.Invoke("widthMM", "widthMM() const", typeof(int));
        }
        public int HeightMM() {
            return (int) interceptor.Invoke("heightMM", "heightMM() const", typeof(int));
        }
        public int LogicalDpiX() {
            return (int) interceptor.Invoke("logicalDpiX", "logicalDpiX() const", typeof(int));
        }
        public int LogicalDpiY() {
            return (int) interceptor.Invoke("logicalDpiY", "logicalDpiY() const", typeof(int));
        }
        public int PhysicalDpiX() {
            return (int) interceptor.Invoke("physicalDpiX", "physicalDpiX() const", typeof(int));
        }
        public int PhysicalDpiY() {
            return (int) interceptor.Invoke("physicalDpiY", "physicalDpiY() const", typeof(int));
        }
        public int NumColors() {
            return (int) interceptor.Invoke("numColors", "numColors() const", typeof(int));
        }
        public int Depth() {
            return (int) interceptor.Invoke("depth", "depth() const", typeof(int));
        }
        public static new string Tr(string s, string c) {
            return (string) staticInterceptor.Invoke("tr$$", "tr(const char*, const char*)", typeof(string), typeof(string), s, typeof(string), c);
        }
        public static new string Tr(string s) {
            return (string) staticInterceptor.Invoke("tr$", "tr(const char*)", typeof(string), typeof(string), s);
        }
        public static void SetTabOrder(QWidget arg1, QWidget arg2) {
            staticInterceptor.Invoke("setTabOrder##", "setTabOrder(QWidget*, QWidget*)", typeof(void), typeof(QWidget), arg1, typeof(QWidget), arg2);
        }
        public static QWidget MouseGrabber() {
            return (QWidget) staticInterceptor.Invoke("mouseGrabber", "mouseGrabber()", typeof(QWidget));
        }
        public static QWidget KeyboardGrabber() {
            return (QWidget) staticInterceptor.Invoke("keyboardGrabber", "keyboardGrabber()", typeof(QWidget));
        }
        public static QWidget Find(uint arg1) {
            return (QWidget) staticInterceptor.Invoke("find$", "find(WId)", typeof(QWidget), typeof(uint), arg1);
        }
        protected new IQWidgetSignals Emit {
            get { return (IQWidgetSignals) Q_EMIT; }
        }
    }

    public interface IQWidgetSignals : IQObjectSignals {
        [Q_SIGNAL("void customContextMenuRequested(QPoint)")]
        void CustomContextMenuRequested(QPoint pos);
    }
}
