AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor and cleanup QGtk(2)Painter

Browse Source 
Move all the GTK2 specific function resolving and painting routines
to QGtk2Painter. A GTK3 specific and Cairo based QGtk3Painter will
be introduced later, and it will be QGtkStyle's job to choose
between the two.

Change-Id: I2c8a85de0cf8187468798cf5faff0006da4b9623
Reviewed-by: Jens Bache-Wiig <jens.bache-wiig@digia.com>
This commit is contained in:
J-P Nurmi 2012-11-07 12:54:53 +01:00 committed by The Qt Project
parent 22c6d13a64
commit 8ba6f75fa6
9 changed files with 1213 additions and 979 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

705
src/widgets/styles/qgtk2painter.cpp Normal file
View File

@ -0,0 +1,705 @@
/****************************************************************************
**
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qgtk2painter_p.h"
#include <QtCore/qglobal.h>
#if !defined(QT_NO_STYLE_GTK)
// This class is primarily a wrapper around the gtk painter functions
// and takes care of converting all such calls into cached Qt pixmaps.
#include <private/qgtkstyle_p.h>
#include <private/qhexstring_p.h>
#include <QtWidgets/QWidget>
#include <QtGui/QPixmapCache>
#include <QtCore/QLibrary>
QT_BEGIN_NAMESPACE
typedef GdkPixbuf* (*Ptr_gdk_pixbuf_get_from_drawable) (GdkPixbuf *, GdkDrawable *, GdkColormap *, int, int, int, int, int, int);
typedef GdkPixmap* (*Ptr_gdk_pixmap_new) (GdkDrawable *, gint, gint, gint);
typedef void (*Ptr_gdk_draw_rectangle) (GdkDrawable *, GdkGC *, gboolean, gint, gint, gint, gint);
typedef void (*Ptr_gdk_drawable_unref)(GdkDrawable *);
typedef void (*Ptr_gtk_paint_check) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_box) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_box_gap) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint , gint, GtkPositionType, gint, gint);
typedef void (*Ptr_gtk_paint_resize_grip) (GtkStyle *, GdkWindow *, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, GdkWindowEdge, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_focus) (GtkStyle *, GdkWindow *, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_shadow) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_slider) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint, GtkOrientation);
typedef void (*Ptr_gtk_paint_expander) (GtkStyle *, GdkWindow *, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , GtkExpanderStyle );
typedef void (*Ptr_gtk_paint_handle) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint, GtkOrientation);
typedef void (*Ptr_gtk_paint_arrow) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, GtkArrowType, gboolean, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_option) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_flat_box) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_extension) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint, gint, GtkPositionType);
typedef void (*Ptr_gtk_paint_hline) (GtkStyle *, GdkWindow *, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint y);
typedef void (*Ptr_gtk_paint_vline) (GtkStyle *, GdkWindow *, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint);
namespace QGtk2PainterPrivate {
static Ptr_gdk_pixmap_new gdk_pixmap_new = 0;
static Ptr_gdk_pixbuf_get_from_drawable gdk_pixbuf_get_from_drawable = 0;
static Ptr_gdk_draw_rectangle gdk_draw_rectangle = 0;
static Ptr_gdk_drawable_unref gdk_drawable_unref = 0;
static Ptr_gtk_paint_check gtk_paint_check = 0;
static Ptr_gtk_paint_box gtk_paint_box = 0;
static Ptr_gtk_paint_box_gap gtk_paint_box_gap = 0;
static Ptr_gtk_paint_flat_box gtk_paint_flat_box = 0;
static Ptr_gtk_paint_option gtk_paint_option = 0;
static Ptr_gtk_paint_extension gtk_paint_extension = 0;
static Ptr_gtk_paint_slider gtk_paint_slider = 0;
static Ptr_gtk_paint_shadow gtk_paint_shadow = 0;
static Ptr_gtk_paint_resize_grip gtk_paint_resize_grip = 0;
static Ptr_gtk_paint_focus gtk_paint_focus = 0;
static Ptr_gtk_paint_arrow gtk_paint_arrow = 0;
static Ptr_gtk_paint_handle gtk_paint_handle = 0;
static Ptr_gtk_paint_expander gtk_paint_expander = 0;
static Ptr_gtk_paint_vline gtk_paint_vline = 0;
static Ptr_gtk_paint_hline gtk_paint_hline = 0;
}
static void initGtk()
{
static bool initialized = false;
if (!initialized) {
// enforce the "0" suffix, so we'll open libgtk-x11-2.0.so.0
QLibrary libgtk(QLS("gtk-x11-2.0"), 0, 0);
QGtk2PainterPrivate::gdk_pixmap_new = (Ptr_gdk_pixmap_new)libgtk.resolve("gdk_pixmap_new");
QGtk2PainterPrivate::gdk_pixbuf_get_from_drawable = (Ptr_gdk_pixbuf_get_from_drawable)libgtk.resolve("gdk_pixbuf_get_from_drawable");
QGtk2PainterPrivate::gdk_draw_rectangle = (Ptr_gdk_draw_rectangle)libgtk.resolve("gdk_draw_rectangle");
QGtk2PainterPrivate::gdk_drawable_unref = (Ptr_gdk_drawable_unref)libgtk.resolve("gdk_drawable_unref");
QGtk2PainterPrivate::gtk_paint_check = (Ptr_gtk_paint_check)libgtk.resolve("gtk_paint_check");
QGtk2PainterPrivate::gtk_paint_box = (Ptr_gtk_paint_box)libgtk.resolve("gtk_paint_box");
QGtk2PainterPrivate::gtk_paint_flat_box = (Ptr_gtk_paint_flat_box)libgtk.resolve("gtk_paint_flat_box");
QGtk2PainterPrivate::gtk_paint_check = (Ptr_gtk_paint_check)libgtk.resolve("gtk_paint_check");
QGtk2PainterPrivate::gtk_paint_box = (Ptr_gtk_paint_box)libgtk.resolve("gtk_paint_box");
QGtk2PainterPrivate::gtk_paint_resize_grip = (Ptr_gtk_paint_resize_grip)libgtk.resolve("gtk_paint_resize_grip");
QGtk2PainterPrivate::gtk_paint_focus = (Ptr_gtk_paint_focus)libgtk.resolve("gtk_paint_focus");
QGtk2PainterPrivate::gtk_paint_shadow = (Ptr_gtk_paint_shadow)libgtk.resolve("gtk_paint_shadow");
QGtk2PainterPrivate::gtk_paint_slider = (Ptr_gtk_paint_slider)libgtk.resolve("gtk_paint_slider");
QGtk2PainterPrivate::gtk_paint_expander = (Ptr_gtk_paint_expander)libgtk.resolve("gtk_paint_expander");
QGtk2PainterPrivate::gtk_paint_handle = (Ptr_gtk_paint_handle)libgtk.resolve("gtk_paint_handle");
QGtk2PainterPrivate::gtk_paint_option = (Ptr_gtk_paint_option)libgtk.resolve("gtk_paint_option");
QGtk2PainterPrivate::gtk_paint_arrow = (Ptr_gtk_paint_arrow)libgtk.resolve("gtk_paint_arrow");
QGtk2PainterPrivate::gtk_paint_box_gap = (Ptr_gtk_paint_box_gap)libgtk.resolve("gtk_paint_box_gap");
QGtk2PainterPrivate::gtk_paint_extension = (Ptr_gtk_paint_extension)libgtk.resolve("gtk_paint_extension");
QGtk2PainterPrivate::gtk_paint_hline = (Ptr_gtk_paint_hline)libgtk.resolve("gtk_paint_hline");
QGtk2PainterPrivate::gtk_paint_vline = (Ptr_gtk_paint_vline)libgtk.resolve("gtk_paint_vline");
initialized = true;
}
}
// To recover alpha we apply the gtk painting function two times to
// white, and black window backgrounds. This can be used to
// recover the premultiplied alpha channel
QPixmap QGtk2Painter::renderTheme(uchar *bdata, uchar *wdata, const QRect &rect) const
{
const int bytecount = rect.width() * rect.height() * 4;
for (int index = 0; index < bytecount ; index += 4) {
uchar val = bdata[index + GTK_BLUE];
if (m_alpha) {
int alphaval = qMax(bdata[index + GTK_BLUE] - wdata[index + GTK_BLUE],
bdata[index + GTK_GREEN] - wdata[index + GTK_GREEN]);
alphaval = qMax(alphaval, bdata[index + GTK_RED] - wdata[index + GTK_RED]) + 255;
bdata[index + QT_ALPHA] = alphaval;
}
bdata[index + QT_RED] = bdata[index + GTK_RED];
bdata[index + QT_GREEN] = bdata[index + GTK_GREEN];
bdata[index + QT_BLUE] = val;
}
QImage converted((const uchar*)bdata, rect.width(), rect.height(), m_alpha ?
QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32);
if (m_hflipped || m_vflipped) {
return QPixmap::fromImage(converted.mirrored(m_hflipped, m_vflipped));
} else {
// on raster graphicssystem we need to do a copy here, because
// we intend to deallocate the qimage bits shortly after...
return QPixmap::fromImage(converted.copy());
}
}
// This macro is responsible for painting any GtkStyle painting function onto a QPixmap
#define DRAW_TO_CACHE(draw_func) \
if (rect.width() > QWIDGETSIZE_MAX || rect.height() > QWIDGETSIZE_MAX) \
return; \
QRect pixmapRect(0, 0, rect.width(), rect.height()); \
{ \
GdkPixmap *pixmap = QGtk2PainterPrivate::gdk_pixmap_new((GdkDrawable*)(m_window->window), \
rect.width(), rect.height(), -1); \
if (!pixmap) \
return; \
style = QGtkStylePrivate::gtk_style_attach (style, m_window->window); \
QGtk2PainterPrivate::gdk_draw_rectangle(pixmap, m_alpha ? style->black_gc : *style->bg_gc, \
true, 0, 0, rect.width(), rect.height()); \
draw_func; \
GdkPixbuf *imgb = QGtkStylePrivate::gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, \
rect.width(), rect.height()); \
if (!imgb) \
return; \
imgb = QGtk2PainterPrivate::gdk_pixbuf_get_from_drawable(imgb, pixmap, NULL, 0, 0, 0, 0, \
rect.width(), rect.height()); \
uchar* bdata = (uchar*)QGtkStylePrivate::gdk_pixbuf_get_pixels(imgb); \
if (m_alpha) { \
QGtk2PainterPrivate::gdk_draw_rectangle(pixmap, style->white_gc, true, 0, 0, \
rect.width(), rect.height()); \
draw_func; \
GdkPixbuf *imgw = QGtkStylePrivate::gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, \
rect.width(), rect.height()); \
if (!imgw) \
return; \
imgw = QGtk2PainterPrivate::gdk_pixbuf_get_from_drawable(imgw, pixmap, NULL, 0, 0, 0, 0,\
rect.width(), rect.height()); \
uchar* wdata = (uchar*)QGtkStylePrivate::gdk_pixbuf_get_pixels(imgw); \
cache = renderTheme(bdata, wdata, rect); \
QGtkStylePrivate::gdk_pixbuf_unref(imgw); \
} else { \
cache = renderTheme(bdata, 0, rect); \
} \
QGtk2PainterPrivate::gdk_drawable_unref(pixmap); \
QGtkStylePrivate::gdk_pixbuf_unref(imgb); \
}
QGtk2Painter::QGtk2Painter() : QGtkPainter(), m_window(QGtkStylePrivate::gtkWidget("GtkWindow"))
{
initGtk();
}
// Note currently painted without alpha for performance reasons
void QGtk2Painter::paintBoxGap(GtkWidget *gtkWidget, const gchar* part,
const QRect &paintRect, GtkStateType state,
GtkShadowType shadow, GtkPositionType gap_side,
gint x, gint width,
GtkStyle *style)
{
if (!paintRect.isValid())
return;
QPixmap cache;
QRect rect = paintRect;
// To avoid exhausting cache on large tabframes we cheat a bit by
// tiling the center part.
const int maxHeight = 256;
const int border = 16;
if (rect.height() > maxHeight && (gap_side == GTK_POS_TOP || gap_side == GTK_POS_BOTTOM))
rect.setHeight(2 * border + 1);
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget)
% HexString<uchar>(gap_side)
% HexString<gint>(width)
% HexString<gint>(x);
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_box_gap (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
(gchar*)part,
0, 0,
rect.width(),
rect.height(),
gap_side,
x,
width));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
if (rect.size() != paintRect.size()) {
// We assume we can stretch the middle tab part
// Note: the side effect of this is that pinstripe patterns will get fuzzy
const QSize size = cache.size();
// top part
m_painter->drawPixmap(QRect(paintRect.left(), paintRect.top(),
paintRect.width(), border), cache,
QRect(0, 0, size.width(), border));
// tiled center part
QPixmap tilePart(cache.width(), 1);
QPainter scanLinePainter(&tilePart);
scanLinePainter.drawPixmap(QRect(0, 0, tilePart.width(), tilePart.height()), cache, QRect(0, border, size.width(), 1));
scanLinePainter.end();
m_painter->drawTiledPixmap(QRect(paintRect.left(), paintRect.top() + border,
paintRect.width(), paintRect.height() - 2*border), tilePart);
// bottom part
m_painter->drawPixmap(QRect(paintRect.left(), paintRect.top() + paintRect.height() - border,
paintRect.width(), border), cache,
QRect(0, size.height() - border, size.width(), border));
} else
m_painter->drawPixmap(paintRect.topLeft(), cache);
}
void QGtk2Painter::paintBox(GtkWidget *gtkWidget, const gchar* part,
const QRect &paintRect, GtkStateType state,
GtkShadowType shadow, GtkStyle *style,
const QString &pmKey)
{
if (!paintRect.isValid())
return;
QPixmap cache;
QRect rect = paintRect;
// To avoid exhausting cache on large tabframes we cheat a bit by
// tiling the center part.
const int maxHeight = 256;
const int maxArea = 256*512;
const int border = 32;
if (rect.height() > maxHeight && (rect.width()*rect.height() > maxArea))
rect.setHeight(2 * border + 1);
QString pixmapName = uniqueName(QLS(part), state, shadow,
rect.size(), gtkWidget) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_box (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
part,
0, 0,
rect.width(),
rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
if (rect.size() != paintRect.size()) {
// We assume we can stretch the middle tab part
// Note: the side effect of this is that pinstripe patterns will get fuzzy
const QSize size = cache.size();
// top part
m_painter->drawPixmap(QRect(paintRect.left(), paintRect.top(),
paintRect.width(), border), cache,
QRect(0, 0, size.width(), border));
// tiled center part
QPixmap tilePart(cache.width(), 1);
QPainter scanLinePainter(&tilePart);
scanLinePainter.drawPixmap(QRect(0, 0, tilePart.width(), tilePart.height()), cache, QRect(0, border, size.width(), 1));
scanLinePainter.end();
m_painter->drawTiledPixmap(QRect(paintRect.left(), paintRect.top() + border,
paintRect.width(), paintRect.height() - 2*border), tilePart);
// bottom part
m_painter->drawPixmap(QRect(paintRect.left(), paintRect.top() + paintRect.height() - border,
paintRect.width(), border), cache,
QRect(0, size.height() - border, size.width(), border));
} else
m_painter->drawPixmap(paintRect.topLeft(), cache);
}
void QGtk2Painter::paintHline(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkStyle *style, int x1, int x2, int y,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
% HexString<int>(x1)
% HexString<int>(x2)
% HexString<int>(y)
% pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_hline (style,
pixmap,
state,
NULL,
gtkWidget,
part,
x1, x2, y));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintVline(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkStyle *style, int y1, int y2, int x,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
% HexString<int>(y1)
% HexString<int>(y2)
% HexString<int>(x)
% pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_vline (style,
pixmap,
state,
NULL,
gtkWidget,
part,
y1, y2,
x));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintExpander(GtkWidget *gtkWidget,
const gchar* part, const QRect &rect,
GtkStateType state, GtkExpanderStyle expander_state,
GtkStyle *style, const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
% HexString<uchar>(expander_state)
% pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_expander (style, pixmap,
state, NULL,
gtkWidget, part,
rect.width()/2,
rect.height()/2,
expander_state));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintFocus(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkStyle *style, const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_focus (style, pixmap, state, NULL,
gtkWidget,
part,
0, 0,
rect.width(),
rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintResizeGrip(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkShadowType shadow, GdkWindowEdge edge,
GtkStyle *style, const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_resize_grip (style, pixmap, state,
NULL, gtkWidget,
part, edge, 0, 0,
rect.width(),
rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintArrow(GtkWidget *gtkWidget, const gchar* part,
const QRect &arrowrect, GtkArrowType arrow_type,
GtkStateType state, GtkShadowType shadow,
gboolean fill, GtkStyle *style, const QString &pmKey)
{
QRect rect = m_cliprect.isValid() ? m_cliprect : arrowrect;
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size())
% HexString<uchar>(arrow_type)
% pmKey;
GdkRectangle gtkCliprect = {0, 0, rect.width(), rect.height()};
int xOffset = m_cliprect.isValid() ? arrowrect.x() - m_cliprect.x() : 0;
int yOffset = m_cliprect.isValid() ? arrowrect.y() - m_cliprect.y() : 0;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_arrow (style, pixmap, state, shadow,
&gtkCliprect,
gtkWidget,
part,
arrow_type, fill,
xOffset, yOffset,
arrowrect.width(),
arrowrect.height()))
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintHandle(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow,
GtkOrientation orientation, GtkStyle *style)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size())
% HexString<uchar>(orientation);
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_handle (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
part, 0, 0,
rect.width(),
rect.height(),
orientation));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintSlider(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow,
GtkStyle *style, GtkOrientation orientation,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_slider (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
part,
0, 0,
rect.width(),
rect.height(),
orientation));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintShadow(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkShadowType shadow, GtkStyle *style,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_shadow(style, pixmap, state, shadow, NULL,
gtkWidget, part, 0, 0, rect.width(), rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintFlatBox(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkShadowType shadow, GtkStyle *style,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_flat_box (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
part, 0, 0,
rect.width(),
rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintExtention(GtkWidget *gtkWidget,
const gchar *part, const QRect &rect,
GtkStateType state, GtkShadowType shadow,
GtkPositionType gap_pos, GtkStyle *style)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget)
% HexString<uchar>(gap_pos);
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_extension (style, pixmap, state, shadow,
NULL, gtkWidget,
(gchar*)part, 0, 0,
rect.width(),
rect.height(),
gap_pos));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintOption(GtkWidget *gtkWidget, const QRect &radiorect,
GtkStateType state, GtkShadowType shadow,
GtkStyle *style, const QString &detail)
{
QRect rect = m_cliprect.isValid() ? m_cliprect : radiorect;
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(detail, state, shadow, rect.size());
GdkRectangle gtkCliprect = {0, 0, rect.width(), rect.height()};
int xOffset = m_cliprect.isValid() ? radiorect.x() - m_cliprect.x() : 0;
int yOffset = m_cliprect.isValid() ? radiorect.y() - m_cliprect.y() : 0;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_option(style, pixmap,
state, shadow,
&gtkCliprect,
gtkWidget,
detail.toLatin1(),
xOffset, yOffset,
radiorect.width(),
radiorect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtk2Painter::paintCheckbox(GtkWidget *gtkWidget, const QRect &checkrect,
GtkStateType state, GtkShadowType shadow,
GtkStyle *style, const QString &detail)
{
QRect rect = m_cliprect.isValid() ? m_cliprect : checkrect;
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(detail, state, shadow, rect.size());
GdkRectangle gtkCliprect = {0, 0, rect.width(), rect.height()};
int xOffset = m_cliprect.isValid() ? checkrect.x() - m_cliprect.x() : 0;
int yOffset = m_cliprect.isValid() ? checkrect.y() - m_cliprect.y() : 0;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtk2PainterPrivate::gtk_paint_check (style,
pixmap,
state,
shadow,
&gtkCliprect,
gtkWidget,
detail.toLatin1(),
xOffset, yOffset,
checkrect.width(),
checkrect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
QT_END_NAMESPACE
#endif //!defined(QT_NO_STYLE_GTK)

108
src/widgets/styles/qgtk2painter_p.h Normal file
View File

@ -0,0 +1,108 @@
/****************************************************************************
**
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QGTK2PAINTER_P_H
#define QGTK2PAINTER_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtCore/qglobal.h>
#if !defined(QT_NO_STYLE_GTK)
#include <private/qgtkpainter_p.h>
QT_BEGIN_NAMESPACE
class QGtk2Painter : public QGtkPainter
{
public:
QGtk2Painter();
void paintBoxGap(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow, GtkPositionType gap_side, gint x,
gint width, GtkStyle *style);
void paintBox(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style,
const QString &pmKey = QString());
void paintHline(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkStyle *style,
int x1, int x2, int y, const QString &pmKey = QString());
void paintVline(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkStyle *style,
int y1, int y2, int x, const QString &pmKey = QString());
void paintExpander(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state,
GtkExpanderStyle expander_state, GtkStyle *style, const QString &pmKey = QString());
void paintFocus(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkStyle *style,
const QString &pmKey = QString());
void paintResizeGrip(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GdkWindowEdge edge, GtkStyle *style, const QString &pmKey = QString());
void paintArrow(GtkWidget *gtkWidget, const gchar* part, const QRect &arrowrect, GtkArrowType arrow_type, GtkStateType state, GtkShadowType shadow,
gboolean fill, GtkStyle *style, const QString &pmKey = QString());
void paintHandle(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow, GtkOrientation orientation, GtkStyle *style);
void paintSlider(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GtkStyle *style, GtkOrientation orientation, const QString &pmKey = QString());
void paintShadow(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GtkStyle *style, const QString &pmKey = QString());
void paintFlatBox(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style, const QString & = QString());
void paintExtention(GtkWidget *gtkWidget, const gchar *part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GtkPositionType gap_pos, GtkStyle *style);
void paintOption(GtkWidget *gtkWidget, const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style, const QString &detail);
void paintCheckbox(GtkWidget *gtkWidget, const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style, const QString &detail);
private:
QPixmap renderTheme(uchar *bdata, uchar *wdata, const QRect &rect) const;
GtkWidget *m_window;
};
QT_END_NAMESPACE
#endif //!defined(QT_NO_STYLE_QGTK)
#endif // QGTK2PAINTER_P_H

90
src/widgets/styles/qgtkglobal_p.h Normal file
View File

@ -0,0 +1,90 @@
/****************************************************************************
**
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QGTKGLOBAL_P_H
#define QGTKGLOBAL_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtCore/qglobal.h>
#if !defined(QT_NO_STYLE_GTK)
#undef signals // Collides with GTK symbols
#include <gtk/gtk.h>
typedef unsigned long XID;
#undef GTK_OBJECT_FLAGS
#define GTK_OBJECT_FLAGS(obj)(((GtkObject*)(obj))->flags)
#define QLS(x) QLatin1String(x)
QT_BEGIN_NAMESPACE
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
# define QT_RED 3
# define QT_GREEN 2
# define QT_BLUE 1
# define QT_ALPHA 0
#else
# define QT_RED 0
# define QT_GREEN 1
# define QT_BLUE 2
# define QT_ALPHA 3
#endif
# define GTK_RED 2
# define GTK_GREEN 1
# define GTK_BLUE 0
# define GTK_ALPHA 3
QT_END_NAMESPACE
#endif // !QT_NO_STYLE_GTK
#endif // QGTKGLOBAL_P_H

665
src/widgets/styles/qgtkpainter.cpp
View File

@ -41,119 +41,32 @@
#include "qgtkpainter_p.h"
#include <QtCore/qglobal.h>
#if !defined(QT_NO_STYLE_GTK)
// This class is primarily a wrapper around the gtk painter functions
// and takes care of converting all such calls into cached Qt pixmaps.
#include <private/qstylehelper_p.h>
#include <QtWidgets/QWidget>
#include <QtWidgets/QStyleOption>
#include <QtGui/QPixmapCache>
#include <private/qhexstring_p.h>
QT_BEGIN_NAMESPACE
#undef GTK_OBJECT_FLAGS
#define GTK_OBJECT_FLAGS(obj)(((GtkObject*)(obj))->flags)
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
# define QT_RED 3
# define QT_GREEN 2
# define QT_BLUE 1
# define QT_ALPHA 0
#else
# define QT_RED 0
# define QT_GREEN 1
# define QT_BLUE 2
# define QT_ALPHA 3
#endif
# define GTK_RED 2
# define GTK_GREEN 1
# define GTK_BLUE 0
# define GTK_ALPHA 3
// To recover alpha we apply the gtk painting function two times to
// white, and black window backgrounds. This can be used to
// recover the premultiplied alpha channel
QPixmap QGtkPainter::renderTheme(uchar *bdata, uchar *wdata, const QRect &rect)
QGtkPainter::QGtkPainter()
{
const int bytecount = rect.width() * rect.height() * 4;
for (int index = 0; index < bytecount ; index += 4) {
uchar val = bdata[index + GTK_BLUE];
if (m_alpha) {
int alphaval = qMax(bdata[index + GTK_BLUE] - wdata[index + GTK_BLUE],
bdata[index + GTK_GREEN] - wdata[index + GTK_GREEN]);
alphaval = qMax(alphaval, bdata[index + GTK_RED] - wdata[index + GTK_RED]) + 255;
bdata[index + QT_ALPHA] = alphaval;
}
bdata[index + QT_RED] = bdata[index + GTK_RED];
bdata[index + QT_GREEN] = bdata[index + GTK_GREEN];
bdata[index + QT_BLUE] = val;
}
QImage converted((const uchar*)bdata, rect.width(), rect.height(), m_alpha ?
QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32);
if (m_hflipped || m_vflipped) {
return QPixmap::fromImage(converted.mirrored(m_hflipped, m_vflipped));
} else {
// on raster graphicssystem we need to do a copy here, because
// we intend to deallocate the qimage bits shortly after...
return QPixmap::fromImage(converted.copy());
}
reset(0);
}
// This macro is responsible for painting any GtkStyle painting function onto a QPixmap
#define DRAW_TO_CACHE(draw_func) \
if (rect.width() > QWIDGETSIZE_MAX || rect.height() > QWIDGETSIZE_MAX) \
return; \
QRect pixmapRect(0, 0, rect.width(), rect.height()); \
{ \
GdkPixmap *pixmap = QGtkStylePrivate::gdk_pixmap_new((GdkDrawable*)(m_window->window), \
rect.width(), rect.height(), -1); \
if (!pixmap) \
return; \
style = QGtkStylePrivate::gtk_style_attach (style, m_window->window); \
QGtkStylePrivate::gdk_draw_rectangle(pixmap, m_alpha ? style->black_gc : *style->bg_gc, true, \
0, 0, rect.width(), rect.height()); \
draw_func; \
GdkPixbuf *imgb = QGtkStylePrivate::gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, rect.width(), rect.height());\
if (!imgb) \
return; \
imgb = QGtkStylePrivate::gdk_pixbuf_get_from_drawable(imgb, pixmap, NULL, 0, 0, 0, 0, \
rect.width(), rect.height()); \
uchar* bdata = (uchar*)QGtkStylePrivate::gdk_pixbuf_get_pixels(imgb); \
if (m_alpha) { \
QGtkStylePrivate::gdk_draw_rectangle(pixmap, style->white_gc, true, 0, 0, rect.width(), rect.height()); \
draw_func; \
GdkPixbuf *imgw = QGtkStylePrivate::gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, rect. \
width(), rect.height()); \
if (!imgw) \
return; \
imgw = QGtkStylePrivate::gdk_pixbuf_get_from_drawable(imgw, pixmap, NULL, 0, 0, 0, 0, \
rect.width(), rect.height()); \
uchar* wdata = (uchar*)QGtkStylePrivate::gdk_pixbuf_get_pixels(imgw); \
cache = renderTheme(bdata, wdata, rect); \
QGtkStylePrivate::gdk_pixbuf_unref(imgw); \
} else { \
cache = renderTheme(bdata, 0, rect); \
} \
QGtkStylePrivate::gdk_drawable_unref(pixmap); \
QGtkStylePrivate::gdk_pixbuf_unref(imgb); \
}
QGtkPainter::~QGtkPainter()
{
}
QGtkPainter::QGtkPainter(QPainter *_painter)
: m_window(QGtkStylePrivate::gtkWidget("GtkWindow"))
, m_painter(_painter)
, m_alpha(true)
, m_hflipped(false)
, m_vflipped(false)
, m_usePixmapCache(true)
{}
void QGtkPainter::reset(QPainter *painter)
{
m_painter = painter;
m_alpha = true;
m_hflipped = false;
m_vflipped = false;
m_usePixmapCache = true;
}
static QString uniqueName(const QString &key, GtkStateType state, GtkShadowType shadow,
const QSize &size, GtkWidget *widget = 0)
QString QGtkPainter::uniqueName(const QString &key, GtkStateType state, GtkShadowType shadow,
const QSize &size, GtkWidget *widget)
{
// Note the widget arg should ideally use the widget path, though would compromise performance
QString tmp = key
@ -165,552 +78,6 @@ static QString uniqueName(const QString &key, GtkStateType state, GtkShadowType
return tmp;
}
GtkStateType QGtkPainter::gtkState(const QStyleOption *option)
{
GtkStateType state = GTK_STATE_NORMAL;
if (!(option->state & QStyle::State_Enabled))
state = GTK_STATE_INSENSITIVE;
else if (option->state & QStyle::State_MouseOver)
state = GTK_STATE_PRELIGHT;
return state;
}
GtkStyle* QGtkPainter::getStyle(GtkWidget *gtkWidget)
{
Q_ASSERT(gtkWidget);
GtkStyle* style = QGtkStylePrivate::gtk_widget_get_style(gtkWidget);
Q_ASSERT(style);
return style;
}
QPixmap QGtkPainter::getIcon(const char* iconName, GtkIconSize size)
{
GtkStyle *style = QGtkStylePrivate::gtkStyle();
GtkIconSet* iconSet = QGtkStylePrivate::gtk_icon_factory_lookup_default (iconName);
GdkPixbuf* icon = QGtkStylePrivate::gtk_icon_set_render_icon(iconSet,
style,
GTK_TEXT_DIR_LTR,
GTK_STATE_NORMAL,
size,
NULL,
"button");
uchar* data = (uchar*)QGtkStylePrivate::gdk_pixbuf_get_pixels(icon);
int width = QGtkStylePrivate::gdk_pixbuf_get_width(icon);
int height = QGtkStylePrivate::gdk_pixbuf_get_height(icon);
QImage converted(width, height, QImage::Format_ARGB32);
uchar* tdata = (uchar*)converted.bits();
for ( int index = 0 ; index < height * width*4 ; index +=4 ) {
//int index = y * rowstride + x;
tdata[index + QT_RED] = data[index + GTK_RED];
tdata[index + QT_GREEN] = data[index + GTK_GREEN];
tdata[index + QT_BLUE] = data[index + GTK_BLUE];
tdata[index + QT_ALPHA] = data[index + GTK_ALPHA];
}
QGtkStylePrivate::gdk_pixbuf_unref(icon);
// should we free iconset?
return QPixmap::fromImage(converted);
}
// Note currently painted without alpha for performance reasons
void QGtkPainter::paintBoxGap(GtkWidget *gtkWidget, const gchar* part,
const QRect &paintRect, GtkStateType state,
GtkShadowType shadow, GtkPositionType gap_side,
gint x, gint width,
GtkStyle *style)
{
if (!paintRect.isValid())
return;
QPixmap cache;
QRect rect = paintRect;
// To avoid exhausting cache on large tabframes we cheat a bit by
// tiling the center part.
const int maxHeight = 256;
const int border = 16;
if (rect.height() > maxHeight && (gap_side == GTK_POS_TOP || gap_side == GTK_POS_BOTTOM))
rect.setHeight(2 * border + 1);
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget)
% HexString<uchar>(gap_side)
% HexString<gint>(width)
% HexString<gint>(x);
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_box_gap (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
(gchar*)part,
0, 0,
rect.width(),
rect.height(),
gap_side,
x,
width));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
if (rect.size() != paintRect.size()) {
// We assume we can stretch the middle tab part
// Note: the side effect of this is that pinstripe patterns will get fuzzy
const QSize size = cache.size();
// top part
m_painter->drawPixmap(QRect(paintRect.left(), paintRect.top(),
paintRect.width(), border), cache,
QRect(0, 0, size.width(), border));
// tiled center part
QPixmap tilePart(cache.width(), 1);
QPainter scanLinePainter(&tilePart);
scanLinePainter.drawPixmap(QRect(0, 0, tilePart.width(), tilePart.height()), cache, QRect(0, border, size.width(), 1));
scanLinePainter.end();
m_painter->drawTiledPixmap(QRect(paintRect.left(), paintRect.top() + border,
paintRect.width(), paintRect.height() - 2*border), tilePart);
// bottom part
m_painter->drawPixmap(QRect(paintRect.left(), paintRect.top() + paintRect.height() - border,
paintRect.width(), border), cache,
QRect(0, size.height() - border, size.width(), border));
} else
m_painter->drawPixmap(paintRect.topLeft(), cache);
}
void QGtkPainter::paintBox(GtkWidget *gtkWidget, const gchar* part,
const QRect &paintRect, GtkStateType state,
GtkShadowType shadow, GtkStyle *style,
const QString &pmKey)
{
if (!paintRect.isValid())
return;
QPixmap cache;
QRect rect = paintRect;
// To avoid exhausting cache on large tabframes we cheat a bit by
// tiling the center part.
const int maxHeight = 256;
const int maxArea = 256*512;
const int border = 32;
if (rect.height() > maxHeight && (rect.width()*rect.height() > maxArea))
rect.setHeight(2 * border + 1);
QString pixmapName = uniqueName(QLS(part), state, shadow,
rect.size(), gtkWidget) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_box (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
part,
0, 0,
rect.width(),
rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
if (rect.size() != paintRect.size()) {
// We assume we can stretch the middle tab part
// Note: the side effect of this is that pinstripe patterns will get fuzzy
const QSize size = cache.size();
// top part
m_painter->drawPixmap(QRect(paintRect.left(), paintRect.top(),
paintRect.width(), border), cache,
QRect(0, 0, size.width(), border));
// tiled center part
QPixmap tilePart(cache.width(), 1);
QPainter scanLinePainter(&tilePart);
scanLinePainter.drawPixmap(QRect(0, 0, tilePart.width(), tilePart.height()), cache, QRect(0, border, size.width(), 1));
scanLinePainter.end();
m_painter->drawTiledPixmap(QRect(paintRect.left(), paintRect.top() + border,
paintRect.width(), paintRect.height() - 2*border), tilePart);
// bottom part
m_painter->drawPixmap(QRect(paintRect.left(), paintRect.top() + paintRect.height() - border,
paintRect.width(), border), cache,
QRect(0, size.height() - border, size.width(), border));
} else
m_painter->drawPixmap(paintRect.topLeft(), cache);
}
void QGtkPainter::paintHline(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkStyle *style, int x1, int x2, int y,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
% HexString<int>(x1)
% HexString<int>(x2)
% HexString<int>(y)
% pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_hline (style,
pixmap,
state,
NULL,
gtkWidget,
part,
x1, x2, y));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintVline(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkStyle *style, int y1, int y2, int x,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
% HexString<int>(y1)
% HexString<int>(y2)
% HexString<int>(x)
% pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_vline (style,
pixmap,
state,
NULL,
gtkWidget,
part,
y1, y2,
x));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintExpander(GtkWidget *gtkWidget,
const gchar* part, const QRect &rect,
GtkStateType state, GtkExpanderStyle expander_state,
GtkStyle *style, const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
% HexString<uchar>(expander_state)
% pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_expander (style, pixmap,
state, NULL,
gtkWidget, part,
rect.width()/2,
rect.height()/2,
expander_state));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintFocus(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkStyle *style, const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_focus (style, pixmap, state, NULL,
gtkWidget,
part,
0, 0,
rect.width(),
rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintResizeGrip(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkShadowType shadow, GdkWindowEdge edge,
GtkStyle *style, const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_resize_grip (style, pixmap, state,
NULL, gtkWidget,
part, edge, 0, 0,
rect.width(),
rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintArrow(GtkWidget *gtkWidget, const gchar* part,
const QRect &arrowrect, GtkArrowType arrow_type,
GtkStateType state, GtkShadowType shadow,
gboolean fill, GtkStyle *style, const QString &pmKey)
{
QRect rect = m_cliprect.isValid() ? m_cliprect : arrowrect;
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size())
% HexString<uchar>(arrow_type)
% pmKey;
GdkRectangle gtkCliprect = {0, 0, rect.width(), rect.height()};
int xOffset = m_cliprect.isValid() ? arrowrect.x() - m_cliprect.x() : 0;
int yOffset = m_cliprect.isValid() ? arrowrect.y() - m_cliprect.y() : 0;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_arrow (style, pixmap, state, shadow,
&gtkCliprect,
gtkWidget,
part,
arrow_type, fill,
xOffset, yOffset,
arrowrect.width(),
arrowrect.height()))
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintHandle(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow,
GtkOrientation orientation, GtkStyle *style)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size())
% HexString<uchar>(orientation);
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_handle (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
part, 0, 0,
rect.width(),
rect.height(),
orientation));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintSlider(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow,
GtkStyle *style, GtkOrientation orientation,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_slider (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
part,
0, 0,
rect.width(),
rect.height(),
orientation));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintShadow(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkShadowType shadow, GtkStyle *style,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_shadow(style, pixmap, state, shadow, NULL,
gtkWidget, part, 0, 0, rect.width(), rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintFlatBox(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state,
GtkShadowType shadow, GtkStyle *style,
const QString &pmKey)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) % pmKey;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_flat_box (style,
pixmap,
state,
shadow,
NULL,
gtkWidget,
part, 0, 0,
rect.width(),
rect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintExtention(GtkWidget *gtkWidget,
const gchar *part, const QRect &rect,
GtkStateType state, GtkShadowType shadow,
GtkPositionType gap_pos, GtkStyle *style)
{
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget)
% HexString<uchar>(gap_pos);
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_extension (style, pixmap, state, shadow,
NULL, gtkWidget,
(gchar*)part, 0, 0,
rect.width(),
rect.height(),
gap_pos));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintOption(GtkWidget *gtkWidget, const QRect &radiorect,
GtkStateType state, GtkShadowType shadow,
GtkStyle *style, const QString &detail)
{
QRect rect = m_cliprect.isValid() ? m_cliprect : radiorect;
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(detail, state, shadow, rect.size());
GdkRectangle gtkCliprect = {0, 0, rect.width(), rect.height()};
int xOffset = m_cliprect.isValid() ? radiorect.x() - m_cliprect.x() : 0;
int yOffset = m_cliprect.isValid() ? radiorect.y() - m_cliprect.y() : 0;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_option(style, pixmap,
state, shadow,
&gtkCliprect,
gtkWidget,
detail.toLatin1(),
xOffset, yOffset,
radiorect.width(),
radiorect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
void QGtkPainter::paintCheckbox(GtkWidget *gtkWidget, const QRect &checkrect,
GtkStateType state, GtkShadowType shadow,
GtkStyle *style, const QString &detail)
{
QRect rect = m_cliprect.isValid() ? m_cliprect : checkrect;
if (!rect.isValid())
return;
QPixmap cache;
QString pixmapName = uniqueName(detail, state, shadow, rect.size());
GdkRectangle gtkCliprect = {0, 0, rect.width(), rect.height()};
int xOffset = m_cliprect.isValid() ? checkrect.x() - m_cliprect.x() : 0;
int yOffset = m_cliprect.isValid() ? checkrect.y() - m_cliprect.y() : 0;
if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_check (style,
pixmap,
state,
shadow,
&gtkCliprect,
gtkWidget,
detail.toLatin1(),
xOffset, yOffset,
checkrect.width(),
checkrect.height()));
if (m_usePixmapCache)
QPixmapCache::insert(pixmapName, cache);
}
m_painter->drawPixmap(rect.topLeft(), cache);
}
QT_END_NAMESPACE
#endif //!defined(QT_NO_STYLE_GTK)

83
src/widgets/styles/qgtkpainter_p.h
View File

@ -56,20 +56,22 @@
#include <QtCore/qglobal.h>
#if !defined(QT_NO_STYLE_GTK)
#include <QtGui/QPainter>
#include <QtGui/QPalette>
#include <QtGui/QFont>
#include <private/qgtkstyle_p.h>
#include <private/qgtkglobal_p.h>
#include <QtCore/qsize.h>
#include <QtCore/qrect.h>
#include <QtCore/qpoint.h>
#include <QtGui/qpixmap.h>
#include <QtGui/qpainter.h>
QT_BEGIN_NAMESPACE
class QGtkPainter
{
public:
QGtkPainter(QPainter *painter);
GtkStyle *getStyle(GtkWidget *gtkWidget);
GtkStateType gtkState(const QStyleOption *option);
QGtkPainter();
virtual ~QGtkPainter();
void reset(QPainter *painter = 0);
void setAlphaSupport(bool value) { m_alpha = value; }
void setClipRect(const QRect &rect) { m_cliprect = rect; }
@ -77,48 +79,45 @@ public:
void setFlipVertical(bool value) { m_vflipped = value; }
void setUsePixmapCache(bool value) { m_usePixmapCache = value; }
void paintBoxGap(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow, GtkPositionType gap_side, gint x,
gint width, GtkStyle *style);
void paintBox(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style,
const QString &pmKey = QString());
void paintHline(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkStyle *style,
int x1, int x2, int y, const QString &pmKey = QString());
void paintVline(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkStyle *style,
int y1, int y2, int x, const QString &pmKey = QString());
void paintExpander(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state,
GtkExpanderStyle expander_state, GtkStyle *style, const QString &pmKey = QString());
void paintFocus(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkStyle *style,
const QString &pmKey = QString());
void paintResizeGrip(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GdkWindowEdge edge, GtkStyle *style, const QString &pmKey = QString());
void paintArrow(GtkWidget *gtkWidget, const gchar* part, const QRect &arrowrect, GtkArrowType arrow_type, GtkStateType state, GtkShadowType shadow,
gboolean fill, GtkStyle *style, const QString &pmKey = QString());
void paintHandle(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow, GtkOrientation orientation, GtkStyle *style);
void paintSlider(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GtkStyle *style, GtkOrientation orientation, const QString &pmKey = QString());
void paintShadow(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GtkStyle *style, const QString &pmKey = QString());
void paintFlatBox(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style, const QString & = QString());
void paintExtention(GtkWidget *gtkWidget, const gchar *part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GtkPositionType gap_pos, GtkStyle *style);
void paintOption(GtkWidget *gtkWidget, const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style, const QString &detail);
void paintCheckbox(GtkWidget *gtkWidget, const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style, const QString &detail);
virtual void paintBoxGap(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow, GtkPositionType gap_side, gint x,
gint width, GtkStyle *style) = 0;
virtual void paintBox(GtkWidget *gtkWidget, const gchar* part,
const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style,
const QString &pmKey = QString()) = 0;
virtual void paintHline(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkStyle *style,
int x1, int x2, int y, const QString &pmKey = QString()) = 0;
virtual void paintVline(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkStyle *style,
int y1, int y2, int x, const QString &pmKey = QString()) = 0;
virtual void paintExpander(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state,
GtkExpanderStyle expander_state, GtkStyle *style, const QString &pmKey = QString()) = 0;
virtual void paintFocus(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkStyle *style,
const QString &pmKey = QString()) = 0;
virtual void paintResizeGrip(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GdkWindowEdge edge, GtkStyle *style, const QString &pmKey = QString()) = 0;
virtual void paintArrow(GtkWidget *gtkWidget, const gchar* part, const QRect &arrowrect, GtkArrowType arrow_type, GtkStateType state, GtkShadowType shadow,
gboolean fill, GtkStyle *style, const QString &pmKey = QString()) = 0;
virtual void paintHandle(GtkWidget *gtkWidget, const gchar* part, const QRect &rect,
GtkStateType state, GtkShadowType shadow, GtkOrientation orientation, GtkStyle *style) = 0;
virtual void paintSlider(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GtkStyle *style, GtkOrientation orientation, const QString &pmKey = QString()) = 0;
virtual void paintShadow(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GtkStyle *style, const QString &pmKey = QString()) = 0;
virtual void paintFlatBox(GtkWidget *gtkWidget, const gchar* part, const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style, const QString & = QString()) = 0;
virtual void paintExtention(GtkWidget *gtkWidget, const gchar *part, const QRect &rect, GtkStateType state, GtkShadowType shadow,
GtkPositionType gap_pos, GtkStyle *style) = 0;
virtual void paintOption(GtkWidget *gtkWidget, const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style, const QString &detail) = 0;
virtual void paintCheckbox(GtkWidget *gtkWidget, const QRect &rect, GtkStateType state, GtkShadowType shadow, GtkStyle *style, const QString &detail) = 0;
static QPixmap getIcon(const char* iconName, GtkIconSize size = GTK_ICON_SIZE_BUTTON);
private:
QPixmap renderTheme(uchar *bdata, uchar *wdata, const QRect&);
protected:
static QString uniqueName(const QString &key, GtkStateType state, GtkShadowType shadow, const QSize &size, GtkWidget *widget = 0);
GtkWidget *m_window;
QPainter *m_painter;
bool m_alpha;
bool m_hflipped;
bool m_vflipped;
bool m_usePixmapCache;
QRect m_cliprect;
};
QT_END_NAMESPACE

431
src/widgets/styles/qgtkstyle.cpp
View File

File diff suppressed because it is too large Load Diff

49
src/widgets/styles/qgtkstyle_p.cpp
View File

@ -62,6 +62,7 @@
#include <QtCore/QLibrary>
#include <QtCore/QDebug>
#include <private/qgtk2painter_p.h>
#include <private/qapplication_p.h>
#include <private/qiconloader_p.h>
@ -146,23 +147,8 @@ Ptr_gtk_fixed_new QGtkStylePrivate::gtk_fixed_new = 0;
Ptr_gtk_tree_view_column_new QGtkStylePrivate::gtk_tree_view_column_new = 0;
Ptr_gtk_tree_view_get_column QGtkStylePrivate::gtk_tree_view_get_column = 0;
Ptr_gtk_tree_view_append_column QGtkStylePrivate::gtk_tree_view_append_column = 0;
Ptr_gtk_paint_check QGtkStylePrivate::gtk_paint_check = 0;
Ptr_gtk_paint_box QGtkStylePrivate::gtk_paint_box = 0;
Ptr_gtk_paint_box_gap QGtkStylePrivate::gtk_paint_box_gap = 0;
Ptr_gtk_paint_flat_box QGtkStylePrivate::gtk_paint_flat_box = 0;
Ptr_gtk_paint_option QGtkStylePrivate::gtk_paint_option = 0;
Ptr_gtk_paint_extension QGtkStylePrivate::gtk_paint_extension = 0;
Ptr_gtk_paint_slider QGtkStylePrivate::gtk_paint_slider = 0;
Ptr_gtk_paint_shadow QGtkStylePrivate::gtk_paint_shadow = 0;
Ptr_gtk_paint_resize_grip QGtkStylePrivate::gtk_paint_resize_grip = 0;
Ptr_gtk_paint_focus QGtkStylePrivate::gtk_paint_focus = 0;
Ptr_gtk_paint_arrow QGtkStylePrivate::gtk_paint_arrow = 0;
Ptr_gtk_paint_handle QGtkStylePrivate::gtk_paint_handle = 0;
Ptr_gtk_paint_expander QGtkStylePrivate::gtk_paint_expander = 0;
Ptr_gtk_adjustment_configure QGtkStylePrivate::gtk_adjustment_configure = 0;
Ptr_gtk_adjustment_new QGtkStylePrivate::gtk_adjustment_new = 0;
Ptr_gtk_paint_hline QGtkStylePrivate::gtk_paint_hline = 0;
Ptr_gtk_paint_vline QGtkStylePrivate::gtk_paint_vline = 0;
Ptr_gtk_menu_item_set_submenu QGtkStylePrivate::gtk_menu_item_set_submenu = 0;
Ptr_gtk_settings_get_default QGtkStylePrivate::gtk_settings_get_default = 0;
Ptr_gtk_separator_menu_item_new QGtkStylePrivate::gtk_separator_menu_item_new = 0;
@ -210,12 +196,8 @@ Ptr_gtk_file_chooser_set_filename QGtkStylePrivate::gtk_file_chooser_set_filenam
Ptr_gdk_pixbuf_get_pixels QGtkStylePrivate::gdk_pixbuf_get_pixels = 0;
Ptr_gdk_pixbuf_get_width QGtkStylePrivate::gdk_pixbuf_get_width = 0;
Ptr_gdk_pixbuf_get_height QGtkStylePrivate::gdk_pixbuf_get_height = 0;
Ptr_gdk_pixmap_new QGtkStylePrivate::gdk_pixmap_new = 0;
Ptr_gdk_pixbuf_new QGtkStylePrivate::gdk_pixbuf_new = 0;
Ptr_gdk_pixbuf_get_from_drawable QGtkStylePrivate::gdk_pixbuf_get_from_drawable = 0;
Ptr_gdk_draw_rectangle QGtkStylePrivate::gdk_draw_rectangle = 0;
Ptr_gdk_pixbuf_unref QGtkStylePrivate::gdk_pixbuf_unref = 0;
Ptr_gdk_drawable_unref QGtkStylePrivate::gdk_drawable_unref = 0;
Ptr_gdk_color_free QGtkStylePrivate::gdk_color_free = 0;
Ptr_gdk_x11_window_set_user_time QGtkStylePrivate::gdk_x11_window_set_user_time = 0;
Ptr_gdk_x11_drawable_get_xid QGtkStylePrivate::gdk_x11_drawable_get_xid = 0;
@ -314,6 +296,14 @@ void QGtkStylePrivate::init()
initGtkWidgets();
}
QGtkPainter* QGtkStylePrivate::gtkPainter(QPainter *painter)
{
// TODO: choose between gtk2 and gtk3
static QGtk2Painter instance;
instance.reset(painter);
return &instance;
}
GtkWidget* QGtkStylePrivate::gtkWidget(const QHashableLatin1Literal &path)
{
GtkWidget *widget = gtkWidgetMap()->value(path);
@ -381,12 +371,8 @@ void QGtkStylePrivate::resolveGtk() const
gdk_pixbuf_get_pixels = (Ptr_gdk_pixbuf_get_pixels)libgtk.resolve("gdk_pixbuf_get_pixels");
gdk_pixbuf_get_width = (Ptr_gdk_pixbuf_get_width)libgtk.resolve("gdk_pixbuf_get_width");
gdk_pixbuf_get_height = (Ptr_gdk_pixbuf_get_height)libgtk.resolve("gdk_pixbuf_get_height");
gdk_pixmap_new = (Ptr_gdk_pixmap_new)libgtk.resolve("gdk_pixmap_new");
gdk_pixbuf_new = (Ptr_gdk_pixbuf_new)libgtk.resolve("gdk_pixbuf_new");
gdk_pixbuf_get_from_drawable = (Ptr_gdk_pixbuf_get_from_drawable)libgtk.resolve("gdk_pixbuf_get_from_drawable");
gdk_draw_rectangle = (Ptr_gdk_draw_rectangle)libgtk.resolve("gdk_draw_rectangle");
gdk_pixbuf_unref = (Ptr_gdk_pixbuf_unref)libgtk.resolve("gdk_pixbuf_unref");
gdk_drawable_unref = (Ptr_gdk_drawable_unref)libgtk.resolve("gdk_drawable_unref");
gdk_color_free = (Ptr_gdk_color_free)libgtk.resolve("gdk_color_free");
gdk_x11_window_set_user_time = (Ptr_gdk_x11_window_set_user_time)libgtk.resolve("gdk_x11_window_set_user_time");
gdk_x11_drawable_get_xid = (Ptr_gdk_x11_drawable_get_xid)libgtk.resolve("gdk_x11_drawable_get_xid");
@ -435,23 +421,6 @@ void QGtkStylePrivate::resolveGtk() const
gtk_tree_view_column_new = (Ptr_gtk_tree_view_column_new)libgtk.resolve("gtk_tree_view_column_new");
gtk_tree_view_append_column= (Ptr_gtk_tree_view_append_column )libgtk.resolve("gtk_tree_view_append_column");
gtk_tree_view_get_column = (Ptr_gtk_tree_view_get_column )libgtk.resolve("gtk_tree_view_get_column");
gtk_paint_check = (Ptr_gtk_paint_check)libgtk.resolve("gtk_paint_check");
gtk_paint_box = (Ptr_gtk_paint_box)libgtk.resolve("gtk_paint_box");
gtk_paint_flat_box = (Ptr_gtk_paint_flat_box)libgtk.resolve("gtk_paint_flat_box");
gtk_paint_check = (Ptr_gtk_paint_check)libgtk.resolve("gtk_paint_check");
gtk_paint_box = (Ptr_gtk_paint_box)libgtk.resolve("gtk_paint_box");
gtk_paint_resize_grip = (Ptr_gtk_paint_resize_grip)libgtk.resolve("gtk_paint_resize_grip");
gtk_paint_focus = (Ptr_gtk_paint_focus)libgtk.resolve("gtk_paint_focus");
gtk_paint_shadow = (Ptr_gtk_paint_shadow)libgtk.resolve("gtk_paint_shadow");
gtk_paint_slider = (Ptr_gtk_paint_slider)libgtk.resolve("gtk_paint_slider");
gtk_paint_expander = (Ptr_gtk_paint_expander)libgtk.resolve("gtk_paint_expander");
gtk_paint_handle = (Ptr_gtk_paint_handle)libgtk.resolve("gtk_paint_handle");
gtk_paint_option = (Ptr_gtk_paint_option)libgtk.resolve("gtk_paint_option");
gtk_paint_arrow = (Ptr_gtk_paint_arrow)libgtk.resolve("gtk_paint_arrow");
gtk_paint_box_gap = (Ptr_gtk_paint_box_gap)libgtk.resolve("gtk_paint_box_gap");
gtk_paint_extension = (Ptr_gtk_paint_extension)libgtk.resolve("gtk_paint_extension");
gtk_paint_hline = (Ptr_gtk_paint_hline)libgtk.resolve("gtk_paint_hline");
gtk_paint_vline = (Ptr_gtk_paint_vline)libgtk.resolve("gtk_paint_vline");
gtk_adjustment_configure = (Ptr_gtk_adjustment_configure)libgtk.resolve("gtk_adjustment_configure");
gtk_adjustment_new = (Ptr_gtk_adjustment_new)libgtk.resolve("gtk_adjustment_new");
gtk_menu_item_set_submenu = (Ptr_gtk_menu_item_set_submenu)libgtk.resolve("gtk_menu_item_set_submenu");

58
src/widgets/styles/qgtkstyle_p.h
View File

@ -64,20 +64,10 @@
#include <QtWidgets/QGtkStyle>
#include <private/qcommonstyle_p.h>
#include <private/qgtkglobal_p.h>
#undef signals // Collides with GTK symbols
#include <gtk/gtk.h>
typedef unsigned long XID;
#undef GTK_OBJECT_FLAGS
#define GTK_OBJECT_FLAGS(obj)(((GtkObject*)(obj))->flags)
#define Q_GTK_IS_WIDGET(widget) widget && G_TYPE_CHECK_INSTANCE_TYPE ((widget), QGtkStylePrivate::gtk_widget_get_type())
#define QLS(x) QLatin1String(x)
QT_BEGIN_NAMESPACE
class QHashableLatin1Literal
{
public:
@ -187,23 +177,8 @@ typedef GtkTreeViewColumn* (*Ptr_gtk_tree_view_column_new)(void);
typedef GtkWidget* (*Ptr_gtk_fixed_new)(void);
typedef GdkPixbuf* (*Ptr_gtk_icon_set_render_icon)(GtkIconSet *, GtkStyle *, GtkTextDirection, GtkStateType, GtkIconSize, GtkWidget *,const char *);
typedef void (*Ptr_gtk_tree_view_append_column) (GtkTreeView*, GtkTreeViewColumn*);
typedef void (*Ptr_gtk_paint_check) (GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_box) (GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_box_gap) (GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint , gint, GtkPositionType, gint gap_x, gint gap_width);
typedef void (*Ptr_gtk_paint_resize_grip) (GtkStyle*,GdkWindow*, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, GdkWindowEdge, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_focus) (GtkStyle*,GdkWindow*, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_shadow) (GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_slider) (GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint, GtkOrientation);
typedef void (*Ptr_gtk_paint_expander) (GtkStyle*,GdkWindow*, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , GtkExpanderStyle );
typedef void (*Ptr_gtk_paint_handle) (GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint, GtkOrientation);
typedef void (*Ptr_gtk_paint_arrow) (GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, GtkArrowType, gboolean, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_option) (GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_flat_box) (GtkStyle*,GdkWindow*, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint , gint , gint , gint);
typedef void (*Ptr_gtk_paint_extension) (GtkStyle *, GdkWindow *, GtkStateType, GtkShadowType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint, gint, GtkPositionType);
typedef void (*Ptr_gtk_adjustment_configure) (GtkAdjustment *, double, double, double, double, double, double);
typedef GtkAdjustment* (*Ptr_gtk_adjustment_new) (double, double, double, double, double, double);
typedef void (*Ptr_gtk_paint_hline) (GtkStyle *, GdkWindow *, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint y);
typedef void (*Ptr_gtk_paint_vline) (GtkStyle *, GdkWindow *, GtkStateType, const GdkRectangle *, GtkWidget *, const gchar *, gint, gint, gint);
typedef void (*Ptr_gtk_menu_item_set_submenu) (GtkMenuItem *, GtkWidget *);
typedef void (*Ptr_gtk_container_forall) (GtkContainer *, GtkCallback, gpointer);
typedef void (*Ptr_gtk_widget_size_allocate) (GtkWidget *, GtkAllocation*);
@ -256,17 +231,9 @@ typedef guchar* (*Ptr_gdk_pixbuf_get_pixels) (const GdkPixbuf *pixbuf);
typedef int (*Ptr_gdk_pixbuf_get_width) (const GdkPixbuf *pixbuf);
typedef void (*Ptr_gdk_color_free) (const GdkColor *);
typedef int (*Ptr_gdk_pixbuf_get_height) (const GdkPixbuf *pixbuf);
typedef GdkPixbuf* (*Ptr_gdk_pixbuf_get_from_drawable) (GdkPixbuf *dest, GdkDrawable *src,
GdkColormap *cmap, int src_x,
int src_y, int dest_x, int dest_y,
int width, int height);
typedef GdkPixmap* (*Ptr_gdk_pixmap_new) (GdkDrawable *drawable, gint width, gint height, gint depth);
typedef GdkPixbuf* (*Ptr_gdk_pixbuf_new) (GdkColorspace colorspace, gboolean has_alpha,
int bits_per_sample, int width, int height);
typedef void (*Ptr_gdk_draw_rectangle) (GdkDrawable *drawable, GdkGC *gc,
gboolean filled, gint x, gint y, gint width, gint height);
int bits_per_sample, int width, int height);
typedef void (*Ptr_gdk_pixbuf_unref)(GdkPixbuf *);
typedef void (*Ptr_gdk_drawable_unref)(GdkDrawable *);
typedef void (*Ptr_gdk_x11_window_set_user_time) (GdkWindow *window, guint32);
typedef XID (*Ptr_gdk_x11_drawable_get_xid) (GdkDrawable *);
typedef Display* (*Ptr_gdk_x11_drawable_get_xdisplay) ( GdkDrawable *);
@ -290,6 +257,7 @@ extern Q_WIDGETS_EXPORT _qt_filedialog_save_filename_hook qt_filedialog_save_fil
extern Q_WIDGETS_EXPORT _qt_filedialog_existing_directory_hook qt_filedialog_existing_directory_hook;
#endif //!QT_NO_FILEDIALOG
class QGtkPainter;
class QGtkStylePrivate;
class QGtkStyleFilter : public QObject
@ -334,6 +302,7 @@ public:
QGtkStyleFilter filter;
static QGtkPainter* gtkPainter(QPainter *painter = 0);
static GtkWidget* gtkWidget(const QHashableLatin1Literal &path);
static GtkStyle* gtkStyle(const QHashableLatin1Literal &path = QHashableLatin1Literal("GtkWindow"));
static void gtkWidgetSetFocus(GtkWidget *widget, bool focus);
@ -424,23 +393,8 @@ public:
static Ptr_gtk_fixed_new gtk_fixed_new;
static Ptr_gtk_tree_view_column_new gtk_tree_view_column_new;
static Ptr_gtk_tree_view_append_column gtk_tree_view_append_column;
static Ptr_gtk_paint_check gtk_paint_check;
static Ptr_gtk_paint_box gtk_paint_box;
static Ptr_gtk_paint_box_gap gtk_paint_box_gap;
static Ptr_gtk_paint_flat_box gtk_paint_flat_box;
static Ptr_gtk_paint_option gtk_paint_option;
static Ptr_gtk_paint_extension gtk_paint_extension;
static Ptr_gtk_paint_slider gtk_paint_slider;
static Ptr_gtk_paint_shadow gtk_paint_shadow;
static Ptr_gtk_paint_resize_grip gtk_paint_resize_grip;
static Ptr_gtk_paint_focus gtk_paint_focus;
static Ptr_gtk_paint_arrow gtk_paint_arrow;
static Ptr_gtk_paint_handle gtk_paint_handle;
static Ptr_gtk_paint_expander gtk_paint_expander;
static Ptr_gtk_adjustment_configure gtk_adjustment_configure;
static Ptr_gtk_adjustment_new gtk_adjustment_new;
static Ptr_gtk_paint_vline gtk_paint_vline;
static Ptr_gtk_paint_hline gtk_paint_hline;
static Ptr_gtk_menu_item_set_submenu gtk_menu_item_set_submenu;
static Ptr_gtk_settings_get_default gtk_settings_get_default;
static Ptr_gtk_separator_menu_item_new gtk_separator_menu_item_new;
@ -488,12 +442,8 @@ public:
static Ptr_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels;
static Ptr_gdk_pixbuf_get_width gdk_pixbuf_get_width;
static Ptr_gdk_pixbuf_get_height gdk_pixbuf_get_height;
static Ptr_gdk_pixmap_new gdk_pixmap_new;
static Ptr_gdk_pixbuf_new gdk_pixbuf_new;
static Ptr_gdk_pixbuf_get_from_drawable gdk_pixbuf_get_from_drawable;
static Ptr_gdk_draw_rectangle gdk_draw_rectangle;
static Ptr_gdk_pixbuf_unref gdk_pixbuf_unref;
static Ptr_gdk_drawable_unref gdk_drawable_unref;
static Ptr_gdk_color_free gdk_color_free;
static Ptr_gdk_x11_window_set_user_time gdk_x11_window_set_user_time;
static Ptr_gdk_x11_drawable_get_xid gdk_x11_drawable_get_xid;

3
src/widgets/styles/styles.pri
View File

@ -99,11 +99,14 @@ contains( styles, windowsxp ) {
}
contains( styles, gtk ) {
HEADERS += styles/qgtkglobal_p.h
HEADERS += styles/qgtkstyle.h
HEADERS += styles/qgtkpainter_p.h
HEADERS += styles/qgtk2painter_p.h
HEADERS += styles/qgtkstyle_p.h
SOURCES += styles/qgtkstyle.cpp
SOURCES += styles/qgtkpainter.cpp
SOURCES += styles/qgtk2painter.cpp
SOURCES += styles/qgtkstyle_p.cpp
} else {
DEFINES += QT_NO_STYLE_GTK