ObjQt  Diff

}

- (void)setAutoFillBackground: (bool)autoFillBackground
{
	toQt(self)->setAutoFillBackground(autoFillBackground);
}

- (of_dimension_t)baseSize
{
	return toOF(toQt(self)->baseSize());
}

- (void)setBaseSize: (of_dimension_t)baseSize
{
	toQt(self)->setBaseSize(toQt(baseSize).toSize());
}

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

- (QRegion)childrenRegion
{
	return toQt(self)->childrenRegion();

}

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

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

- (of_dimension_t)frameSize
{
	return toOF(toQt(self)->frameSize());
}

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

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

- (void)setGeometry: (of_rectangle_t)geometry
{
	toQt(self)->setGeometry(toQt(geometry).toRect());
}

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

}

- (void)setMaximumHeight: (int)maximumHeight
{
	toQt(self)->setMaximumHeight(maximumHeight);
}

- (of_dimension_t)maximumSize
{
	return toOF(toQt(self)->maximumSize());
}

- (void)setMaximumSize: (of_dimension_t)maximumSize
{
	toQt(self)->setMaximumSize(toQt(maximumSize).toSize());
}

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

}

- (void)setMinimumHeight: (int)minimumHeight
{
	toQt(self)->setMinimumHeight(minimumHeight);
}

- (of_dimension_t)minimumSize
{
	return toOF(toQt(self)->minimumSize());
}

- (void)setMinimumSize: (of_dimension_t)minimumSize
{
	toQt(self)->setMinimumSize(toQt(minimumSize).toSize());
}

- (of_dimension_t)minimumSizeHint
{
	return toOF(toQt(self)->minimumSizeHint());
}

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

}

- (void)setMouseTracking: (bool)mouseTracking
{
	toQt(self)->setMouseTracking(mouseTracking);
}

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

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

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

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

- (void)moveToPosition: (of_point_t)pos
{
	toQt(self)->move(toQt(pos));
}

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

- (of_dimension_t)size
{
	return toOF(toQt(self)->size());
}

- (void)resizeTo: (of_dimension_t)size
{
	toQt(self)->resize(toQt(size).toSize());
}

- (of_dimension_t)sizeHint
{
	return toOF(toQt(self)->sizeHint());
}

- (of_dimension_t)sizeIncrement
{
	return toOF(toQt(self)->sizeIncrement());
}

- (void)setSizeIncrement: (of_dimension_t)sizeIncrement
{
	toQt(self)->setSizeIncrement(toQt(sizeIncrement).toSize());
}

- (QSizePolicy)sizePolicy
{
	return toQt(self)->sizePolicy();

}

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

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

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

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

- (QMargins)contentsMargins
{
	return toQt(self)->contentsMargins();
}

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

- (WId)effectiveWinID
{
	return toQt(self)->effectiveWinId();

}

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

- (QPixmap)grabRectangle: (of_rectangle_t)rectangle
{
	return toQt(self)->grab(toQt(rectangle).toRect());
}

- (void)grabGesture: (Qt::GestureType)gesture
{
	toQt(self)->grabGesture(gesture);

}

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

- (of_point_t)mapPosition: (of_point_t)pos
		     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
{
	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();

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

- (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
		 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
	     targetOffset: (of_point_t)targetOffset
	     sourceRegion: (QRegion)sourceRegion
{
	toQt(self)->render(target, toQt(targetOffset), sourceRegion);
}

- (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).toRect());
}

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

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

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

- (void)scrollRight: (int)dx
	       down: (int)dy
{
	toQt(self)->scroll(dx, dy);
}

- (void)scrollRight: (int)dx
	       down: (int)dy
	inRectangle: (of_rectangle_t)rect
{
	toQt(self)->scroll(dx, dy, toQt(rect).toRect());
}

- (void)setAttribute: (Qt::WidgetAttribute)attribute
		  to: (bool)on
{
	toQt(self)->setAttribute(attribute, on);
}

#ifdef QT_KEYPAD_NAVIGATION
- (void)setEditFocus: (bool)enable
{
	toQt(self)->setEditFocus(enable);
}
#endif

- (void)setFixedHeight: (int)height
{
	toQt(self)->setFixedHeight(height);
}

- (void)setFixedSize: (of_dimension_t)size
{
	toQt(self)->setFixedSize(toQt(size).toSize());
}

- (void)setFixedWidth: (int)width
{
	toQt(self)->setFixedWidth(width);

}

- (void)ungrabGesture: (Qt::GestureType)gesture
{
	toQt(self)->ungrabGesture(gesture);
}

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

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