ObjQt  Diff

@implementation QtWidget
+ (void)initialize
{
	if (self == [QtWidget class])
		[self inheritMethodsFromClass: [QtPaintDevice class]];
}

- initWithQObject: (QObject*)qObject
- initWithQObject: (QObject *)qObject
{
	OF_INVALID_INIT_METHOD
}

- initWithQWidget: (QWidget*)qWidget
- initWithQWidget: (QWidget *)qWidget
{
	return [super initWithQObject: qWidget];
}

- (QWidget*)qWidget
- (QWidget *)qWidget
{
	return qobject_cast<QWidget*>(_qObject);
	return qobject_cast<QWidget *>(_qObject);
}

- (bool)acceptDrops
{
	return toQt(self)->acceptDrops();
}

- (void)setAcceptDrops: (bool)acceptDrops
{
	toQt(self)->setAcceptDrops(acceptDrops);
}

- (OFString*)accessibleDescription
- (OFString *)accessibleDescription
{
	return toOF(toQt(self)->accessibleDescription());
}

- (void)setAccessibleDescription: (OFString*)accessibleDescription
- (void)setAccessibleDescription: (OFString *)accessibleDescription
{
	toQt(self)->setAccessibleDescription(toQt(accessibleDescription));
}

- (OFString*)accessibleName
- (OFString *)accessibleName
{
	return toOF(toQt(self)->accessibleName());
}

- (void)setAccessibleName: (OFString*)accessibleName
- (void)setAccessibleName: (OFString *)accessibleName
{
	toQt(self)->setAccessibleName(toQt(accessibleName));
}

- (bool)autoFillBackground
{
	return toQt(self)->autoFillBackground();

}

- (void)setFocusPolicy: (Qt::FocusPolicy)focusPolicy
{
	toQt(self)->setFocusPolicy(focusPolicy);
}

- (const QFont&)font
- (const QFont &)font
{
	return toQt(self)->font();
}

- (void)setFont: (const QFont&)font
- (void)setFont: (const QFont &)font
{
	toQt(self)->setFont(font);
}

- (of_rectangle_t)frameGeometry
{
	return toOF(toQt(self)->frameGeometry());

}

- (of_rectangle_t)normalGeometry
{
	return toOF(toQt(self)->normalGeometry());
}

- (const QPalette&)palette
- (const QPalette &)palette
{
	return toQt(self)->palette();
}

- (void)setPalette: (const QPalette&)palette
- (void)setPalette: (const QPalette &)palette
{
	toQt(self)->setPalette(palette);
}

- (of_point_t)pos
{
	return toOF(toQt(self)->pos());

}

- (void)setSizePolicy: (QSizePolicy)sizePolicy
{
	toQt(self)->setSizePolicy(sizePolicy);
}

- (OFString*)statusTip
- (OFString *)statusTip
{
	return toOF(toQt(self)->statusTip());
}

- (void)setStatusTip: (OFString*)statusTip
- (void)setStatusTip: (OFString *)statusTip
{
	toQt(self)->setStatusTip(toQt(statusTip));
}

- (OFString*)styleSheet
- (OFString *)styleSheet
{
	return toOF(toQt(self)->styleSheet());
}

- (void)setStyleSheet: (OFString*)styleSheet
- (void)setStyleSheet: (OFString *)styleSheet
{
	toQt(self)->setStyleSheet(toQt(styleSheet));
}

- (OFString*)toolTip
- (OFString *)toolTip
{
	return toOF(toQt(self)->toolTip());
}

- (void)setToolTip: (OFString*)toolTip
- (void)setToolTip: (OFString *)toolTip
{
	toQt(self)->setToolTip(toQt(toolTip));
}

- (int)toolTipDuration
{
	return toQt(self)->toolTipDuration();

}

- (void)setVisible: (bool)visible
{
	toQt(self)->setVisible(visible);
}

- (OFString*)whatsThis
- (OFString *)whatsThis
{
	return toOF(toQt(self)->whatsThis());
}

- (void)setWhatsThis: (OFString*)whatsThis
- (void)setWhatsThis: (OFString *)whatsThis
{
	toQt(self)->setWhatsThis(toQt(whatsThis));
}

- (int)width
{
	return toQt(self)->width();
}

- (OFString*)windowFilePath
- (OFString *)windowFilePath
{
	return toOF(toQt(self)->windowFilePath());
}

- (void)setWindowFilePath: (OFString*)windowFilePath
- (void)setWindowFilePath: (OFString *)windowFilePath
{
	toQt(self)->setWindowFilePath(toQt(windowFilePath));
}

- (Qt::WindowFlags)windowFlags
{
	return toQt(self)->windowFlags();

}

- (void)setWindowOpacity: (double)windowOpacity
{
	toQt(self)->setWindowOpacity(windowOpacity);
}

- (OFString*)windowTitle
- (OFString *)windowTitle
{
	return toOF(toQt(self)->windowTitle());
}

- (void)setWindowTitle: (OFString*)windowTitle
- (void)setWindowTitle: (OFString *)windowTitle
{
	toQt(self)->setWindowTitle(toQt(windowTitle));
}

- (int)x
{
	return toQt(self)->x();
}

- (int)y
{
	return toQt(self)->y();
}

- (OFArray OF_GENERIC(QtAction*)*)actions
- (OFArray OF_GENERIC(QtAction *) *)actions
{
	const QList<QAction*> &actions = toQt(self)->actions();
	const QList<QAction *> &actions = toQt(self)->actions();
	OFMutableArray *ret =
	    [OFMutableArray arrayWithCapacity: actions.count()];
	void *pool = objc_autoreleasePoolPush();

	for (QAction *action: actions)
		[ret addObject: toOF(action)];

	[ret makeImmutable];

	objc_autoreleasePoolPop(pool);

	return ret;
}

- (void)activateWindow
{
	toQt(self)->activateWindow();
}

- (void)addAction: (QtAction*)action
- (void)addAction: (QtAction *)action
{
	toQt(self)->addAction(toQt(action));
}

- (void)addActions: (OFArray OF_GENERIC(QtAction*)*)actions
- (void)addActions: (OFArray OF_GENERIC(QtAction *) *)actions
{
	QList<QAction*> list;
	QList<QAction *> list;

	for (QtAction *action in actions)
		list.append(toQt(action));

	toQt(self)->addActions(list);
}

- (void)adjustSize
{
	toQt(self)->adjustSize();
}

- (QPalette::ColorRole)backgroundRole
{
	return toQt(self)->backgroundRole();
}

- (QBackingStore*)backingStore
- (QBackingStore *)backingStore
{
	return toQt(self)->backingStore();
}

- (QtWidget*)childAt: (of_point_t)point
- (QtWidget *)childAt: (of_point_t)point
{
	return toOF(toQt(self)->childAt(toQt(point)));
}

- (void)clearFocus
{
	return toQt(self)->clearFocus();

}

- (void)ensurePolished
{
	toQt(self)->ensurePolished();
}

- (QtWidget*)focusProxy
- (QtWidget *)focusProxy
{
	return toOF(toQt(self)->focusProxy());
}

- (QtWidget*)focusWidget
- (QtWidget *)focusWidget
{
	return toOF(toQt(self)->focusWidget());
}

- (QFontInfo)fontInfo
{
	return toQt(self)->fontInfo();

}

- (void)grabMouse
{
	toQt(self)->grabMouse();
}

- (void)grabMouseWithCursor: (const QCursor&)cursor
- (void)grabMouseWithCursor: (const QCursor &)cursor
{
	toQt(self)->grabMouse(cursor);
}

- (int)grabShortcutWithKey: (const QKeySequence&)key
- (int)grabShortcutWithKey: (const QKeySequence &)key
{
	return toQt(self)->grabShortcut(key);
}

- (int)grabShortcutWithKey: (const QKeySequence&)key
- (int)grabShortcutWithKey: (const QKeySequence &)key
		   context: (Qt::ShortcutContext)context
{
	return toQt(self)->grabShortcut(key, context);
}

- (QGraphicsEffect*)graphicsEffect
- (QGraphicsEffect *)graphicsEffect
{
	return toQt(self)->graphicsEffect();
}

- (QGraphicsProxyWidget*)graphicsProxyWidget
- (QGraphicsProxyWidget *)graphicsProxyWidget
{
	return toQt(self)->graphicsProxyWidget();
}

#ifdef QT_KEYPAD_NAVIGATION
- (bool)hasEditFocus
{

}

- (QVariant)queryInputMethod: (Qt::InputMethodQuery)query
{
	return toQt(self)->inputMethodQuery(query);
}

- (void)insertAction: (QtAction*)action
	      before: (QtAction*)before
- (void)insertAction: (QtAction *)action
	      before: (QtAction *)before
{
	toQt(self)->insertAction(toQt(before), toQt(action));
}

- (void)insertActions: (OFArray OF_GENERIC(QtAction*)*)actions
	       before: (QtAction*)before
- (void)insertActions: (OFArray OF_GENERIC(QtAction *) *)actions
	       before: (QtAction *)before
{
	QList<QAction*> list;
	QList<QAction *> list;

	for (QtAction *action in actions)
		list.append(toQt(action));

	toQt(self)->insertActions(toQt(before), list);
}

- (bool)isAncestorOf: (QtWidget*)child
- (bool)isAncestorOf: (QtWidget *)child
{
	return toQt(self)->isAncestorOf(toQt(child));
}

- (bool)isEnabledTo: (QtWidget*)ancestor
- (bool)isEnabledTo: (QtWidget *)ancestor
{
	return toQt(self)->isEnabledTo(toQt(ancestor));
}

- (bool)isHidden
{
	return toQt(self)->isHidden();
}

- (bool)isVisibleTo: (QtWidget*)ancestor
- (bool)isVisibleTo: (QtWidget *)ancestor
{
	return toQt(self)->isVisibleTo(toQt(ancestor));
}

- (bool)isWindow
{
	return toQt(self)->isWindow();
}

- (of_point_t)mapPosition: (of_point_t)pos
		     from: (QtWidget*)parent
		     from: (QtWidget *)parent
{
	return toOF(toQt(self)->mapFrom(toQt(parent), toQt(pos)));
}

- (of_point_t)mapPositionFromGlobal: (of_point_t)pos
{
	return toOF(toQt(self)->mapFromGlobal(toQt(pos)));
}

- (of_point_t)mapPositionFromParent: (of_point_t)pos
{
	return toOF(toQt(self)->mapFromParent(toQt(pos)));
}

- (of_point_t)mapPosition: (of_point_t)pos
		       to: (QtWidget*)parent
		       to: (QtWidget *)parent
{
	return toOF(toQt(self)->mapTo(toQt(parent), toQt(pos)));
}

- (of_point_t)mapPositionToGlobal: (of_point_t)pos
{
	return toOF(toQt(self)->mapToGlobal(toQt(pos)));
}

- (of_point_t)mapPositionToParent: (of_point_t)pos
{
	return toOF(toQt(self)->mapToParent(toQt(pos)));
}

- (QRegion)mask
{
	return toQt(self)->mask();
}

- (QtWidget*)nativeParentWidget
- (QtWidget *)nativeParentWidget
{
	return toOF(toQt(self)->nativeParentWidget());
}

- (QtWidget*)nextInFocusChain
- (QtWidget *)nextInFocusChain
{
	return toOF(toQt(self)->nextInFocusChain());
}

- (void)overrideWindowFlags: (Qt::WindowFlags)flags
{
	toQt(self)->overrideWindowFlags(flags);
}

- (QtWidget*)parentWidget
- (QtWidget *)parentWidget
{
	return toOF(toQt(self)->parentWidget());
}

- (QtWidget*)previousInFocusChain
- (QtWidget *)previousInFocusChain
{
	return toOF(toQt(self)->previousInFocusChain());
}

- (void)releaseKeyboard
{
	toQt(self)->releaseKeyboard();
}

- (void)releaseMouse
{
	toQt(self)->releaseMouse();
}

- (void)releaseShortcut: (int)ID
{
	toQt(self)->releaseShortcut(ID);
}

- (void)removeAction: (QtAction*)action
- (void)removeAction: (QtAction *)action
{
	toQt(self)->removeAction(toQt(action));
}

- (void)renderIntoPaintDevice: (QtObject <QtPaintDevice>*)target
- (void)renderIntoPaintDevice: (QtObject <QtPaintDevice> *)target
		 targetOffset: (of_point_t)targetOffset
		 sourceRegion: (QRegion)sourceRegion
{
	toQt(self)->render([target qPaintDevice], toQt(targetOffset),
	    sourceRegion);
}

- (void)renderIntoPaintDevice: (QtObject <QtPaintDevice>*)target
- (void)renderIntoPaintDevice: (QtObject <QtPaintDevice> *)target
		 targetOffset: (of_point_t)targetOffset
		 sourceRegion: (QRegion)sourceRegion
			flags: (QWidget::RenderFlags)renderFlags
{
	toQt(self)->render([target qPaintDevice], toQt(targetOffset),
	    sourceRegion, renderFlags);
}

- (void)renderIntoPainter: (QPainter*)target
- (void)renderIntoPainter: (QPainter *)target
	     targetOffset: (of_point_t)targetOffset
	     sourceRegion: (QRegion)sourceRegion
{
	toQt(self)->render(target, toQt(targetOffset), sourceRegion);
}

- (void)renderIntoPainter: (QPainter*)target
- (void)renderIntoPainter: (QPainter *)target
	     targetOffset: (of_point_t)targetOffset
	     sourceRegion: (QRegion)sourceRegion
		    flags: (QWidget::RenderFlags)renderFlags
{
	toQt(self)->render(target, toQt(targetOffset), sourceRegion,
	    renderFlags);
}

- (void)repaintInRectangle: (of_rectangle_t)rect
{
	toQt(self)->repaint(toQt(rect));
}

- (void)repaintInRegion: (const QRegion&)region
- (void)repaintInRegion: (const QRegion &)region
{
	toQt(self)->repaint(region);
}

- (bool)restoreGeometry: (OFDataArray*)geometry
- (bool)restoreGeometry: (OFDataArray *)geometry
{
	return toQt(self)->restoreGeometry(toQt(geometry));
}

- (OFDataArray*)saveGeometry
- (OFDataArray *)saveGeometry
{
	return toOF(toQt(self)->saveGeometry());
}

- (void)scrollRight: (int)dx
	       down: (int)dy
{

}

- (void)setFocus: (Qt::FocusReason)reason
{
	toQt(self)->setFocus(reason);
}

- (void)setFocusProxy: (QtWidget*)widget
- (void)setFocusProxy: (QtWidget *)widget
{
	toQt(self)->setFocusProxy(toQt(widget));
}

- (void)setForegroundRole: (QPalette::ColorRole)role
{
	toQt(self)->setForegroundRole(role);
}

- (void)setGraphicsEffect: (QGraphicsEffect*)effect
- (void)setGraphicsEffect: (QGraphicsEffect *)effect
{
	toQt(self)->setGraphicsEffect(effect);
}

- (void)setLayout: (QLayout*)layout
- (void)setLayout: (QLayout *)layout
{
	toQt(self)->setLayout(layout);
}

- (void)setMaskFromBitmap: (const QBitmap&)bitmap
- (void)setMaskFromBitmap: (const QBitmap &)bitmap
{
	toQt(self)->setMask(bitmap);
}

- (void)setMask: (const QRegion&)region
- (void)setMask: (const QRegion &)region
{
	toQt(self)->setMask(region);
}

- (void)setParent: (QtWidget*)parent
- (void)setParent: (QtWidget *)parent
{
	toQt(self)->setParent(toQt(parent));
}

- (void)setParent: (QtWidget*)parent
- (void)setParent: (QtWidget *)parent
	    flags: (Qt::WindowFlags)flags
{
	toQt(self)->setParent(toQt(parent), flags);
}

- (void)setAutoRepeat: (bool)enable
	  forShortcut: (int)ID
{
	toQt(self)->setShortcutAutoRepeat(ID, enable);
}

- (void)setEnabled: (bool)enable
       forShortcut: (int)ID
{
	toQt(self)->setShortcutEnabled(ID, enable);
}

- (void)setStyle: (QStyle*)style
- (void)setStyle: (QStyle *)style
{
	toQt(self)->setStyle(style);
}

- (void)setWindowRole: (OFString*)role
- (void)setWindowRole: (OFString *)role
{
	toQt(self)->setWindowRole(toQt(role));
}

- (void)setWindowState: (Qt::WindowStates)windowState
{
	toQt(self)->setWindowState(windowState);
}

- (void)stackUnder: (QtWidget*)widget
- (void)stackUnder: (QtWidget *)widget
{
	toQt(self)->stackUnder(toQt(widget));
}

- (QStyle*)style
- (QStyle *)style
{
	return toQt(self)->style();
}

- (bool)testAttribute: (Qt::WidgetAttribute)attribute
{
	return toQt(self)->testAttribute(attribute);

}

- (void)updateInRectangle: (of_rectangle_t)rect
{
	toQt(self)->update(toQt(rect));
}

- (void)updateInRegion: (const QRegion&)region
- (void)updateInRegion: (const QRegion &)region
{
	toQt(self)->update(region);
}

- (void)updateGeometry
{
	toQt(self)->updateGeometry();
}

- (QRegion)visibleRegion
{
	return toQt(self)->visibleRegion();
}

- (WId)winID
{
	return toQt(self)->winId();
}

- (QtWidget*)window
- (QtWidget *)window
{
	return toOF(toQt(self)->window());
}

- (QWindow*)windowHandle
- (QWindow *)windowHandle
{
	return toQt(self)->windowHandle();
}

- (OFString*)windowRole
- (OFString *)windowRole
{
	return toOF(toQt(self)->windowRole());
}

- (Qt::WindowStates)windowState
{
	return toQt(self)->windowState();