From 91064f3b1d93fb0449e588f70552f050b4033e9f Mon Sep 17 00:00:00 2001 From: tpearson Date: Thu, 5 May 2011 17:16:35 +0000 Subject: Port gtk-qt-engine to TQt4 This enables compilation under both Qt3 and Qt4 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/gtk-qt-engine@1230499 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- src/qt_main.c | 6 +- src/qt_qt_wrapper.cpp | 1036 ++++++++++++++++++++++++------------------------- src/qt_qt_wrapper.h | 20 +- src/qt_rc_style.c | 22 +- src/qt_rc_style.h | 24 +- src/qt_style.h | 24 +- src/qt_theme_draw.c | 198 +++++----- 7 files changed, 665 insertions(+), 665 deletions(-) (limited to 'src') diff --git a/src/qt_main.c b/src/qt_main.c index 4e9eb1b..fab6003 100644 --- a/src/qt_main.c +++ b/src/qt_main.c @@ -11,19 +11,19 @@ G_MODULE_EXPORT GtkRcStyle * theme_create_rc_style (void); G_MODULE_EXPORT void theme_init (GTypeModule *module) { - createQApp(); + createTQApp(); qtengine_rc_style_register_type (module); qtengine_style_register_type (module); } G_MODULE_EXPORT void theme_exit (void) { - destroyQApp(); + destroyTQApp(); } G_MODULE_EXPORT GtkRcStyle * theme_create_rc_style (void) { - void *ptr = GTK_RC_STYLE (g_object_new (QTENGINE_TYPE_RC_STYLE, NULL)); + void *ptr = GTK_RC_STYLE (g_object_new (TQTENGINE_TYPE_RC_STYLE, NULL)); return (GtkRcStyle *)ptr; } diff --git a/src/qt_qt_wrapper.cpp b/src/qt_qt_wrapper.cpp index 6ca87fb..9eb3c47 100644 --- a/src/qt_qt_wrapper.cpp +++ b/src/qt_qt_wrapper.cpp @@ -1,20 +1,20 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #undef signals #include @@ -40,41 +40,41 @@ #include "qt_qt_wrapper.h" #include "qt_style.h" -#define RC_CACHE_VERSION QString("1") +#define RC_CACHE_VERSION TQString("1") -bool gtkQtEnable = false; +bool gtkTQtEnable = false; bool mozillaFix = false; -bool qAppOwner = false; +bool tqAppOwner = false; -QStringList appDirList; -typedef QMap IconMap; +TQStringList appDirList; +typedef TQMap IconMap; IconMap iconMap[4]; extern int errno; -QScrollBar* scrollBar = 0; -QWidget* meepWidget = 0; -QWidget* meepWidgetP = 0; -QSlider* meepSlider = 0; -QTabBar* meepTabBar = 0; +TQScrollBar* scrollBar = 0; +TQWidget* meepWidget = 0; +TQWidget* meepWidgetP = 0; +TQSlider* meepSlider = 0; +TQTabBar* meepTabBar = 0; GdkGC* altBackGC = 0; -QWidget* smw = 0; +TQWidget* smw = 0; GtkRcStyle* gtkRcStyle = 0; -QStringList kdeSearchPaths; -QString iconTheme; -QStringList iconThemeDirs; -QColor alternateBackgroundColour; +TQStringList kdeSearchPaths; +TQString iconTheme; +TQStringList iconThemeDirs; +TQColor alternateBackgroundColour; int showIconsOnButtons; int toolbarStyle; -const QPixmap* backgroundTile; +const TQPixmap* backgroundTile; GdkPixmap* backgroundTileGdk; -QPixmap* menuBackgroundPixmap; +TQPixmap* menuBackgroundPixmap; GdkPixmap* menuBackgroundPixmapGdk; -QPixmap* fillPixmap; +TQPixmap* fillPixmap; int scrollBarSpacingLeft = 0; int scrollBarSpacingRight = 0; @@ -86,14 +86,14 @@ int isDomino; int isPolyester; int eclipseFix; int openOfficeFix; -int gtkQtDebug; +int gtkTQtDebug; Atom kipcCommAtom; Atom desktopWindowAtom; void setFillPixmap(GdkPixbuf* buf) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; // This code isn't very robust. It doesn't handle depths other than 24 bits. @@ -106,7 +106,7 @@ void setFillPixmap(GdkPixbuf* buf) if (depth != 24) return; - QImage fillImage(width, height, 32); + TQImage fillImage(width, height, 32); uchar* source = gdk_pixbuf_get_pixels(buf); uchar* dest = fillImage.bits(); @@ -130,7 +130,7 @@ void setFillPixmap(GdkPixbuf* buf) if (fillPixmap) delete fillPixmap; fillPixmap = 0; - fillPixmap = new QPixmap(); + fillPixmap = new TQPixmap(); fillPixmap->convertFromImage(fillImage); return; } @@ -151,7 +151,7 @@ static int dummy_xio_errhandler( Display * ) return 0; } -void createQApp() +void createTQApp() { int argc = 1; char** argv; @@ -160,7 +160,7 @@ void createQApp() argv[0] = (char*) malloc(sizeof(char) * 19); strncpy(argv[0], "gtk-qt-application", 19); - QString cmdLine; + TQString cmdLine; #ifdef USE_FREEBSD /* @@ -205,7 +205,7 @@ void createQApp() } if (ret == -1) { - printf("Gtk-Qt theme engine warning:\n"); + printf("Gtk-TQt theme engine warning:\n"); printf(msg); printf(" This may cause problems for the GNOME window manager\n"); } @@ -289,18 +289,18 @@ void createQApp() if (ret == -1) { - printf("Gtk-Qt theme engine warning:\n"); + printf("Gtk-TQt theme engine warning:\n"); printf(msg); printf(" This may cause problems for the GNOME window manager\n"); } #else // USE_SOLARIS #ifndef USE_FREEBSD - QCString cmdlinePath; + TQCString cmdlinePath; cmdlinePath.sprintf("/proc/%d/cmdline", getpid()); int fd = open(cmdlinePath, O_RDONLY); if (fd == -1) { - printf("Gtk-Qt theme engine warning:\n"); + printf("Gtk-TQt theme engine warning:\n"); printf(" Could not open %s\n", (const char*)cmdlinePath); printf(" This may cause problems for the GNOME window manager\n"); } @@ -319,7 +319,7 @@ void createQApp() #endif // USE_FREEBSD #endif // USE_SOLARIS - mozillaFix = (cmdLine.contains("mozilla") || cmdLine.contains("firefox")); + mozillaFix = (cmdLine.tqcontains("mozilla") || cmdLine.tqcontains("firefox")); openOfficeFix = (cmdLine.endsWith("soffice.bin")) | (cmdLine.endsWith("swriter.bin")) @@ -328,17 +328,17 @@ void createQApp() | (cmdLine.endsWith("spadmin.bin")) | (cmdLine.endsWith("simpress.bin")); - eclipseFix = cmdLine.contains("eclipse"); + eclipseFix = cmdLine.tqcontains("eclipse"); - gtkQtDebug = (getenv("GTK_QT_ENGINE_DEBUG") != NULL) ? 1 : 0; + gtkTQtDebug = (getenv("GTK_TQT_ENGINE_DEBUG") != NULL) ? 1 : 0; - if (gtkQtDebug) - printf("createQApp()\n"); + if (gtkTQtDebug) + printf("createTQApp()\n"); char* sessionEnv = getenv("SESSION_MANAGER"); - if (QString(sessionEnv).endsWith(QString::number(getpid())) || cmdLine.contains("nspluginviewer") || cmdLine.contains("gnome-wm") || cmdLine.contains("metacity") || cmdLine.contains("xfwm4") || (getenv("GTK_QT_ENGINE_DISABLE") != NULL)) + if (TQString(sessionEnv).endsWith(TQString::number(getpid())) || cmdLine.tqcontains("nspluginviewer") || cmdLine.tqcontains("gnome-wm") || cmdLine.tqcontains("metacity") || cmdLine.tqcontains("xfwm4") || (getenv("GTK_TQT_ENGINE_DISABLE") != NULL)) { - printf("Not initializing the Gtk-Qt theme engine\n"); + printf("Not initializing the Gtk-TQt theme engine\n"); } else { @@ -355,10 +355,10 @@ void createQApp() initKdeSettings(); - if (!qApp) + if (!tqApp) { - new QApplication(gdk_x11_get_default_xdisplay()); - qAppOwner = true; + new TQApplication(gdk_x11_get_default_xdisplay()); + tqAppOwner = true; } #ifndef USE_SOLARIS @@ -372,29 +372,29 @@ void createQApp() XSetErrorHandler( original_x_errhandler ); XSetIOErrorHandler( original_xio_errhandler ); - gtkQtEnable = true; + gtkTQtEnable = true; } free(argv[0]); free(argv); - if (!gtkQtEnable) + if (!gtkTQtEnable) return; - isBaghira = (QString(qApp->style().name()).lower() == "baghira"); - isKeramik = (QString(qApp->style().name()).lower() == "keramik"); - isAlloy = (QString(qApp->style().name()).lower() == "alloy"); - isDomino = (QString(qApp->style().name()).lower() == "domino"); - isPolyester = (QString(qApp->style().name()).lower() == "polyester"); + isBaghira = (TQString(tqApp->tqstyle().name()).lower() == "baghira"); + isKeramik = (TQString(tqApp->tqstyle().name()).lower() == "keramik"); + isAlloy = (TQString(tqApp->tqstyle().name()).lower() == "alloy"); + isDomino = (TQString(tqApp->tqstyle().name()).lower() == "domino"); + isPolyester = (TQString(tqApp->tqstyle().name()).lower() == "polyester"); if (isDomino) { - QScrollBar sbar(NULL); + TQScrollBar sbar(NULL); sbar.setOrientation(Qt::Horizontal); sbar.setValue(1); sbar.resize(200,25); - QRect rect = qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar, &sbar, QStyle::SC_ScrollBarGroove); + TQRect rect = tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar, &sbar, TQStyle::SC_ScrollBarGroove); scrollBarSpacingLeft = rect.x(); scrollBarSpacingRight = 200 - rect.x() - rect.width(); } @@ -403,7 +403,7 @@ void createQApp() /*setGnomeFonts(); setGnomeIcons();*/ - if (!cmdLine.contains("xfce-mcs-manager")) + if (!cmdLine.tqcontains("xfce-mcs-manager")) { // Get KDE related atoms from the X server kipcCommAtom = XInternAtom ( gdk_x11_get_default_xdisplay() , "KIPC_COMM_ATOM" , false ); @@ -411,7 +411,7 @@ void createQApp() // Create a new window, and set the KDE_DESKTOP_WINDOW property on it // This window will then receive events from KDE when the style changes - smw = new QWidget(0,0); + smw = new TQWidget(0,0); long data = 1; XChangeProperty(gdk_x11_get_default_xdisplay(), smw->winId(), desktopWindowAtom, desktopWindowAtom, @@ -421,12 +421,12 @@ void createQApp() gdk_window_add_filter( NULL, gdkEventFilter, 0); } - meepWidgetP = new QWidget(0); - meepWidget = new QWidget(meepWidgetP); - meepSlider = new QSlider(meepWidget); + meepWidgetP = new TQWidget(0); + meepWidget = new TQWidget(meepWidgetP); + meepSlider = new TQSlider(meepWidget); meepWidget->polish(); - meepTabBar = new QTabBar(meepWidget); + meepTabBar = new TQTabBar(meepWidget); menuBackgroundPixmap = NULL; backgroundTile = meepWidget->paletteBackgroundPixmap(); @@ -434,18 +434,18 @@ void createQApp() backgroundTileGdk = gdk_pixmap_foreign_new(backgroundTile->handle()); } -void destroyQApp() +void destroyTQApp() { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; delete meepWidget; delete meepWidgetP; delete menuBackgroundPixmap; delete smw; - if (qAppOwner) + if (tqAppOwner) { - delete qApp; - qApp = 0; + delete tqApp; + tqApp = 0; } if (altBackGC != 0) gtk_gc_release(altBackGC); @@ -463,17 +463,17 @@ GdkFilterReturn gdkEventFilter(GdkXEvent *xevent, GdkEvent *gevent, gpointer dat if (event->xclient.data.l[0] != 2) return GDK_FILTER_REMOVE; - if (gtkQtDebug) + if (gtkTQtDebug) printf("StyleChanged IPC message\n"); // Find out the new widget style - QString styleName = kdeConfigValue("General", "widgetStyle", ""); - QStyle* style = QStyleFactory::create(styleName); + TQString styleName = kdeConfigValue("General", "widgetStyle", ""); + TQStyle* style = TQStyleFactory::create(styleName); if (!style) return GDK_FILTER_REMOVE; - // Tell the QApplication about this new style - qApp->setStyle(style); + // Tell the TQApplication about this new style + tqApp->setStyle(style); // Now we need to update GTK's properties setRcProperties(gtkRcStyle, 1); // Rewrite our cache file @@ -484,20 +484,20 @@ GdkFilterReturn gdkEventFilter(GdkXEvent *xevent, GdkEvent *gevent, gpointer dat return GDK_FILTER_CONTINUE; } -QString kdeConfigValue(const QString& section, const QString& name, const QString& def) +TQString kdeConfigValue(const TQString& section, const TQString& name, const TQString& def) { - for ( QStringList::Iterator it = kdeSearchPaths.begin(); it != kdeSearchPaths.end(); ++it ) + for ( TQStringList::Iterator it = kdeSearchPaths.begin(); it != kdeSearchPaths.end(); ++it ) { - if (!QFile::exists((*it) + "/share/config/kdeglobals")) + if (!TQFile::exists((*it) + "/share/config/kdeglobals")) continue; - QFile file((*it) + "/share/config/kdeglobals"); + TQFile file((*it) + "/share/config/kdeglobals"); if (!file.open( IO_ReadOnly )) continue; - QTextStream stream( &file ); - QString line; - QString sec; + TQTextStream stream( &file ); + TQString line; + TQString sec; int i = 1; while ( !stream.atEnd() ) { @@ -509,7 +509,7 @@ QString kdeConfigValue(const QString& section, const QString& name, const QStrin } if (sec != section) continue; - QRegExp parser("([\\S]*)\\s*=\\s*([\\S]*)"); + TQRegExp parser("([\\S]*)\\s*=\\s*([\\S]*)"); if (parser.search(line) == -1) continue; if (parser.cap(1) == name) @@ -520,23 +520,23 @@ QString kdeConfigValue(const QString& section, const QString& name, const QStrin return def; } -QString kdeFindDir(const QString& suffix, const QString& file1, const QString& file2) +TQString kdeFindDir(const TQString& suffix, const TQString& file1, const TQString& file2) { - for ( QStringList::Iterator it = kdeSearchPaths.begin(); it != kdeSearchPaths.end(); ++it ) + for ( TQStringList::Iterator it = kdeSearchPaths.begin(); it != kdeSearchPaths.end(); ++it ) { - if ((QFile::exists((*it) + suffix + file1)) || (QFile::exists((*it) + suffix + file2))) + if ((TQFile::exists((*it) + suffix + file1)) || (TQFile::exists((*it) + suffix + file2))) return (*it) + suffix; } - return QString::null; + return TQString(); } -QString runCommand(const QString& command) +TQString runCommand(const TQString& command) { FILE* p = popen(command.latin1(), "r"); if ((p == NULL) || (p < 0)) - return QString::null; + return TQString(); - QString ret; + TQString ret; while (!feof(p)) { char buffer[256]; @@ -553,28 +553,28 @@ void initKdeSettings() { kdeSearchPaths.clear(); - QString kdeHome = getenv("KDEHOME"); - QString kdeDirs = getenv("KDEDIRS"); - QString kdeDir = getenv("KDEDIR"); + TQString kdeHome = getenv("KDEHOME"); + TQString kdeDirs = getenv("KDEDIRS"); + TQString kdeDir = getenv("KDEDIR"); if (!kdeHome.isEmpty()) kdeSearchPaths.append(kdeHome); kdeSearchPaths.append(runCommand("kde-config --localprefix")); if (!kdeDirs.isEmpty()) - kdeSearchPaths += QStringList::split(':', kdeDirs); + kdeSearchPaths += TQStringList::split(':', kdeDirs); if (!kdeDir.isEmpty()) kdeSearchPaths.append(kdeDir); kdeSearchPaths.append(runCommand("kde-config --prefix")); iconTheme = kdeConfigValue("Icons", "Theme", "crystalsvg"); - QStringList back = QStringList::split(',', kdeConfigValue("General", "alternateBackground", "238,246,255")); + TQStringList back = TQStringList::split(',', kdeConfigValue("General", "alternateBackground", "238,246,255")); alternateBackgroundColour.setRgb(back[0].toInt(), back[1].toInt(), back[2].toInt()); showIconsOnButtons = (kdeConfigValue("KDE", "ShowIconsOnPushButtons", "true").lower() == "true"); - QString tmp = kdeConfigValue("Toolbar style", "IconText", "true").lower(); + TQString tmp = kdeConfigValue("Toolbar style", "IconText", "true").lower(); if (tmp == "icononly") toolbarStyle = 0; else if (tmp == "icontextright") @@ -587,64 +587,64 @@ void initKdeSettings() toolbarStyle = 0; } -QStyle::SFlags stateToSFlags(GtkStateType state) +TQStyle::SFlags stateToSFlags(GtkStateType state) { switch (state) { case GTK_STATE_ACTIVE: - return QStyle::Style_Enabled | QStyle::Style_Down; + return TQStyle::Style_Enabled | TQStyle::Style_Down; case GTK_STATE_PRELIGHT: - return QStyle::Style_Enabled | QStyle::Style_MouseOver | QStyle::Style_Raised; + return TQStyle::Style_Enabled | TQStyle::Style_MouseOver | TQStyle::Style_Raised; case GTK_STATE_SELECTED: - return QStyle::Style_Enabled | QStyle::Style_HasFocus | QStyle::Style_Raised; + return TQStyle::Style_Enabled | TQStyle::Style_HasFocus | TQStyle::Style_Raised; case GTK_STATE_INSENSITIVE: - return QStyle::Style_Default | QStyle::Style_Raised; + return TQStyle::Style_Default | TQStyle::Style_Raised; default: - return QStyle::Style_Enabled | QStyle::Style_Raised; + return TQStyle::Style_Enabled | TQStyle::Style_Raised; } } -QColor gdkColorToQColor(GdkColor* c) +TQColor gdkColorToTQColor(GdkColor* c) { - return QColor(c->red / 256, c->green / 256, c->blue / 256); + return TQColor(c->red / 256, c->green / 256, c->blue / 256); } // The drawing functions follow the same pattern: // * Set the appropriate flags // * Ask QT to paint the widget to a pixmap -// * Create a GdkPixmap that points to our QPixmap +// * Create a GdkPixmap that points to our TQPixmap // * Paint the pixmap on the window void drawButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int defaultButton, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w, h); - QPainter painter(&pixmap); - QPushButton button(meepWidget); - button.setBackgroundOrigin(QWidget::ParentOrigin); + TQPixmap pixmap(w, h); + TQPainter painter(&pixmap); + TQPushButton button(meepWidget); + button.setBackgroundOrigin(TQWidget::ParentOrigin); button.setGeometry(x, y, w, h); if (style->rc_style->bg[GTK_STATE_NORMAL].pixel != 0) - button.setPaletteBackgroundColor(gdkColorToQColor(&style->rc_style->bg[GTK_STATE_NORMAL])); - QPoint p = button.backgroundOffset(); - QPoint pos = button.pos(); + button.setPaletteBackgroundColor(gdkColorToTQColor(&style->rc_style->bg[GTK_STATE_NORMAL])); + TQPoint p = button.backgroundOffset(); + TQPoint pos = button.pos(); - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); if (defaultButton) - sflags |= QStyle::Style_ButtonDefault; + sflags |= TQStyle::Style_ButtonDefault; button.setDefault(defaultButton); - painter.fillRect(0, 0, w, h, qApp->palette().active().background()); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().background()); - qApp->style().drawControl(QStyle::CE_PushButton, &painter, &button, - QRect(0,0,w,h), button.palette().active(), sflags); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_PushButton, &painter, &button, + TQRect(0,0,w,h), button.tqpalette().active(), sflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -654,11 +654,11 @@ void drawButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int defa // Thanks Peter Hartshorn void drawToolbar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; int w1, h1; - QStyle::SFlags sflags = stateToSFlags(state) | QStyle::Style_Raised; + TQStyle::SFlags sflags = stateToSFlags(state) | TQStyle::Style_Raised; // Keramik hack... @@ -668,7 +668,7 @@ void drawToolbar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, if (w > h) { - sflags |= QStyle::Style_Horizontal; + sflags |= TQStyle::Style_Horizontal; w1 = w * 3; h1 = h; } @@ -682,22 +682,22 @@ void drawToolbar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, (w < 1) || (h < 1)) return; - QPixmap pixmap(w1, h1); - QPixmap p(w, h); - QPainter painter(&pixmap); + TQPixmap pixmap(w1, h1); + TQPixmap p(w, h); + TQPainter painter(&pixmap); if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, w1, h1, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, w1, h1, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, w1, h1, qApp->palette().active().brush(QColorGroup::Background)); + painter.fillRect(0, 0, w1, h1, tqApp->tqpalette().active().brush(TQColorGroup::Background)); - qApp->style().drawPrimitive(QStyle::PE_PanelDockWindow, &painter, - QRect(0,0,w1,h1), qApp->palette().active(),sflags); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelDockWindow, &painter, + TQRect(0,0,w1,h1), tqApp->tqpalette().active(),sflags); if (isKeramik) { - qApp->style().drawPrimitive(QStyle::PE_DockWindowSeparator, &painter, - QRect(0,0,w1,h1), qApp->palette().active(),sflags); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_DockWindowSeparator, &painter, + TQRect(0,0,w1,h1), tqApp->tqpalette().active(),sflags); } bitBlt(&p, 0, 0, &pixmap, 0, 0, w, h); @@ -709,11 +709,11 @@ void drawToolbar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, void drawMenubar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; int w1, h1; - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); // Keramik hack... @@ -723,7 +723,7 @@ void drawMenubar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, if (w > h) { - sflags |= QStyle::Style_Horizontal; + sflags |= TQStyle::Style_Horizontal; w1 = w * 3; h1 = h; } @@ -737,17 +737,17 @@ void drawMenubar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, (w < 1) || (h < 1)) return; - QPixmap pixmap(w1, h1); - QPixmap p(w, h); - QPainter painter(&pixmap); + TQPixmap pixmap(w1, h1); + TQPixmap p(w, h); + TQPainter painter(&pixmap); if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, w1, h1, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, w1, h1, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, w1, h1, qApp->palette().active().brush(QColorGroup::Background)); + painter.fillRect(0, 0, w1, h1, tqApp->tqpalette().active().brush(TQColorGroup::Background)); - qApp->style().drawPrimitive(QStyle::PE_PanelMenuBar, &painter, - QRect(0,0,w1,h1), qApp->palette().active(),sflags); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelMenuBar, &painter, + TQRect(0,0,w1,h1), tqApp->tqpalette().active(),sflags); bitBlt(&p, 0, 0, &pixmap, 0, 0, w, h); @@ -758,27 +758,27 @@ void drawMenubar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, void drawTab(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w,h); - QPainter painter(&pixmap); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); // GTK doesn't tell us if our tab is on the left, right, or middle of the tabbar // So, let's always assume it's in the middle - it looks pretty - QTab* tab = new QTab; + TQTab* tab = new TQTab; meepTabBar->insertTab(tab,1); - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); if (state != GTK_STATE_ACTIVE) - sflags = QStyle::Style_Selected; + sflags = TQStyle::Style_Selected; - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawControl(QStyle::CE_TabBarTab, &painter, meepTabBar, QRect(0,0,w,h), qApp->palette().active(), sflags, QStyleOption(tab)); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_TabBarTab, &painter, meepTabBar, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags, TQStyleOption(tab)); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -789,7 +789,7 @@ void drawTab(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int void drawVLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int ySource, int yDest) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; int width = style->xthickness; @@ -800,13 +800,13 @@ void drawVLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, in if ((width < 1) || (height < 1)) return; - QPixmap pixmap(width, height); - QPainter painter(&pixmap); + TQPixmap pixmap(width, height); + TQPainter painter(&pixmap); - painter.fillRect(2, 0, width - 2, height, qApp->palette().active().brush(QColorGroup::Background)); - painter.setPen( qApp->palette().active().mid() ); + painter.fillRect(2, 0, width - 2, height, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + painter.setPen( tqApp->tqpalette().active().mid() ); painter.drawLine( 0, 0, 0, height ); - painter.setPen( qApp->palette().active().light() ); + painter.setPen( tqApp->tqpalette().active().light() ); painter.drawLine( 1, 0, 1, height ); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); @@ -816,7 +816,7 @@ void drawVLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, in void drawHLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int y, int xSource, int xDest) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; int width = abs(xSource-xDest); @@ -825,13 +825,13 @@ void drawHLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int y, in if ((width < 1) || (height < 1)) return; - QPixmap pixmap(width, height); - QPainter painter(&pixmap); + TQPixmap pixmap(width, height); + TQPainter painter(&pixmap); - painter.fillRect(0, 2, width, height-2, qApp->palette().active().brush(QColorGroup::Background)); - painter.setPen(qApp->palette().active().mid() ); + painter.fillRect(0, 2, width, height-2, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + painter.setPen(tqApp->tqpalette().active().mid() ); painter.drawLine(0, 0, width, 0); - painter.setPen(qApp->palette().active().light()); + painter.setPen(tqApp->tqpalette().active().light()); painter.drawLine(0, 1, width, 1); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); @@ -841,21 +841,21 @@ void drawHLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int y, in void drawLineEdit(GdkWindow* window, GtkStyle* style, GtkStateType state, int hasFocus, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w, h); - QPainter painter(&pixmap); + TQPixmap pixmap(w, h); + TQPainter painter(&pixmap); - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); if (hasFocus) - sflags |= QStyle::Style_HasFocus; + sflags |= TQStyle::Style_HasFocus; - painter.fillRect(0, 0, w, h, qApp->palette().active().base()); - qApp->style().drawPrimitive(QStyle::PE_PanelLineEdit, &painter, QRect(0, 0, w, h), qApp->palette().active(), sflags, QStyleOption(1,1)); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().base()); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelLineEdit, &painter, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, TQStyleOption(1,1)); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -864,25 +864,25 @@ void drawLineEdit(GdkWindow* window, GtkStyle* style, GtkStateType state, int ha void drawFrame(GdkWindow* window, GtkStyle* style, GtkStateType state, GtkShadowType shadow_type, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) // Caused crash in gaim file transfers window return; - QPixmap pixmap(w, h); - QPainter painter(&pixmap); + TQPixmap pixmap(w, h); + TQPainter painter(&pixmap); - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); if ((shadow_type == GTK_SHADOW_IN) || (shadow_type == GTK_SHADOW_ETCHED_IN)) - sflags |= QStyle::Style_Sunken; + sflags |= TQStyle::Style_Sunken; if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); - qApp->style().drawPrimitive(QStyle::PE_Panel, &painter, QRect(0, 0, w, h), qApp->palette().active(), sflags, QStyleOption(2,2) ); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_Panel, &painter, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, TQStyleOption(2,2) ); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -891,26 +891,26 @@ void drawFrame(GdkWindow* window, GtkStyle* style, GtkStateType state, GtkShadow void drawComboBox(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w,h); - QPainter painter(&pixmap); - QComboBox cb(false, 0); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); + TQComboBox cb(false, 0); cb.resize(w,h); - QStyle::SFlags sflags = stateToSFlags(state); - QStyle::SCFlags scflags = QStyle::SC_ComboBoxArrow | QStyle::SC_ComboBoxFrame | QStyle::SC_ComboBoxListBoxPopup; - QStyle::SCFlags activeflags = QStyle::SC_None; + TQStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SCFlags scflags = TQStyle::SC_ComboBoxArrow | TQStyle::SC_ComboBoxFrame | TQStyle::SC_ComboBoxListBoxPopup; + TQStyle::SCFlags activeflags = TQStyle::SC_None; if (state == GTK_STATE_PRELIGHT) - activeflags = QStyle::Style_MouseOver; + activeflags = TQStyle::Style_MouseOver; - painter.fillRect(0,0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawComplexControl(QStyle::CC_ComboBox, &painter, &cb, QRect(0, 0, w, h), qApp->palette().active(), sflags, scflags, activeflags); + painter.fillRect(0,0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawComplexControl(TQStyle::CC_ComboBox, &painter, &cb, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, scflags, activeflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -919,26 +919,26 @@ void drawComboBox(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, void drawCheckBox(GdkWindow* window, GtkStyle* style, GtkStateType state, int checked, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; - int realH = qApp->style().pixelMetric(QStyle::PM_IndicatorHeight); - int realW = qApp->style().pixelMetric(QStyle::PM_IndicatorWidth); + int realH = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorHeight); + int realW = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorWidth); if ((realW < 1) || (realH < 1)) return; - QPixmap pixmap(realW, realH); - QPainter painter(&pixmap); - QCheckBox checkbox(0); + TQPixmap pixmap(realW, realH); + TQPainter painter(&pixmap); + TQCheckBox checkbox(0); - QStyle::SFlags sflags = stateToSFlags(state); - sflags |= (checked ? QStyle::Style_On : QStyle::Style_Off); + TQStyle::SFlags sflags = stateToSFlags(state); + sflags |= (checked ? TQStyle::Style_On : TQStyle::Style_Off); - painter.fillRect(0, 0, realW, realH, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawControl(QStyle::CE_CheckBox, &painter, &checkbox, QRect(0, 0, realW, realH), qApp->palette().active(), sflags); + painter.fillRect(0, 0, realW, realH, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_CheckBox, &painter, &checkbox, TQRect(0, 0, realW, realH), tqApp->tqpalette().active(), sflags); - // Qt checkboxes are usually bigger than GTK wants. + // TQt checkboxes are usually bigger than GTK wants. // We cheat, and draw them over the expected area. int xOffset = (realW - w) / 2; int yOffset = (realH - h) / 2; @@ -950,33 +950,33 @@ void drawCheckBox(GdkWindow* window, GtkStyle* style, GtkStateType state, int ch void drawMenuCheck(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; - QCheckBox checkbox(0); + TQCheckBox checkbox(0); /* A previous version of the function followed the sizehints exclusively Now follow w and h provided by GTK, but if the checkmark is too big we might have to scale it */ /* - int w1 = checkbox.sizeHint().width(); - int h1 = checkbox.sizeHint().height(); */ + int w1 = checkbox.tqsizeHint().width(); + int h1 = checkbox.tqsizeHint().height(); */ if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w,h); - QPainter painter(&pixmap); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); - QStyle::SFlags sflags = stateToSFlags(state); - sflags |= QStyle::Style_On; + TQStyle::SFlags sflags = stateToSFlags(state); + sflags |= TQStyle::Style_On; if (fillPixmap && (!fillPixmap->isNull())) - painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *fillPixmap)); + painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *fillPixmap)); else if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawPrimitive(QStyle::PE_CheckMark, &painter, QRect(0, 0, w, h), qApp->palette().active(), sflags); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_CheckMark, &painter, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -985,32 +985,32 @@ void drawMenuCheck(GdkWindow* window, GtkStyle* style, GtkStateType state, int x void drawRadioButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int checked, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; - int realH = qApp->style().pixelMetric(QStyle::PM_IndicatorHeight); - int realW = qApp->style().pixelMetric(QStyle::PM_IndicatorWidth); + int realH = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorHeight); + int realW = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorWidth); if ((realW < 1) || (realH < 1)) return; - QPixmap pixmap(realH, realW); - QPainter painter(&pixmap); - QRadioButton radio(0); + TQPixmap pixmap(realH, realW); + TQPainter painter(&pixmap); + TQRadioButton radio(0); - QStyle::SFlags sflags = stateToSFlags(state); - sflags |= checked ? QStyle::Style_On : QStyle::Style_Off; + TQStyle::SFlags sflags = stateToSFlags(state); + sflags |= checked ? TQStyle::Style_On : TQStyle::Style_Off; if (fillPixmap && (!fillPixmap->isNull())) - painter.fillRect(0, 0, realW, realH, QBrush(QColor(255,255,255), *fillPixmap)); + painter.fillRect(0, 0, realW, realH, TQBrush(TQColor(255,255,255), *fillPixmap)); else if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, realW, realH, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, realW, realH, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, realW, realH, qApp->palette().active().brush(QColorGroup::Background)); + painter.fillRect(0, 0, realW, realH, tqApp->tqpalette().active().brush(TQColorGroup::Background)); - qApp->style().drawControl(QStyle::CE_RadioButton, &painter, &radio, QRect(0,0,realH,realW), qApp->palette().active(), sflags); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_RadioButton, &painter, &radio, TQRect(0,0,realH,realW), tqApp->tqpalette().active(), sflags); - // Qt checkboxes are usually bigger than GTK wants. + // TQt checkboxes are usually bigger than GTK wants. // We cheat, and draw them over the expected area. int xOffset = (realW - w) / 2; int yOffset = (realH - h) / 2; @@ -1023,7 +1023,7 @@ void drawRadioButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int void drawScrollBarSlider(GdkWindow* window, GtkStyle* style, GtkStateType state, int orientation, GtkAdjustment* adj, int x, int y, int w, int h, int offset, int totalExtent) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) @@ -1038,52 +1038,52 @@ void drawScrollBarSlider(GdkWindow* window, GtkStyle* style, GtkStateType state, else hCorrected = h + 14; } - QPixmap pixmap(wCorrected, hCorrected); - QPainter painter(&pixmap); + TQPixmap pixmap(wCorrected, hCorrected); + TQPainter painter(&pixmap); - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); if (orientation == GTK_ORIENTATION_HORIZONTAL) - sflags |= QStyle::Style_Horizontal; + sflags |= TQStyle::Style_Horizontal; - qApp->style().drawPrimitive(QStyle::PE_ScrollBarSlider, &painter, QRect(0,0,wCorrected,hCorrected), qApp->palette().active(), sflags); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_ScrollBarSlider, &painter, TQRect(0,0,wCorrected,hCorrected), tqApp->tqpalette().active(), sflags); // The domino style doesn't draw the entire slider in PE_ScrollBarSlider // We have to draw PE_ScrollBarAddPage and PE_ScrollBarSubPage and piece the bits together if (isDomino && !mozillaFix && !eclipseFix) { - QPixmap leftPix, rightPix; - QRect leftRect, rightRect; + TQPixmap leftPix, rightPix; + TQRect leftRect, rightRect; if (orientation == GTK_ORIENTATION_HORIZONTAL) { - leftRect = QRect(0, 0, offset-scrollBarSpacingLeft, h); - rightRect = QRect(6, 0, totalExtent-offset-w-scrollBarSpacingRight+2, h); + leftRect = TQRect(0, 0, offset-scrollBarSpacingLeft, h); + rightRect = TQRect(6, 0, totalExtent-offset-w-scrollBarSpacingRight+2, h); leftPix.resize(6 + leftRect.width(), h); rightPix.resize(6 + rightRect.width(), h); } else { - leftRect = QRect(0, 0, w, offset-scrollBarSpacingLeft); - rightRect = QRect(0, 6, w, totalExtent-offset-h-scrollBarSpacingRight+2); + leftRect = TQRect(0, 0, w, offset-scrollBarSpacingLeft); + rightRect = TQRect(0, 6, w, totalExtent-offset-h-scrollBarSpacingRight+2); leftPix.resize(w, 6 + leftRect.height()); rightPix.resize(w, 6 + rightRect.height()); } - QPainter dominoPainter(&leftPix); - qApp->style().drawPrimitive(QStyle::PE_ScrollBarSubPage, &dominoPainter, leftRect, qApp->palette().active(), sflags); + TQPainter dominoPainter(&leftPix); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_ScrollBarSubPage, &dominoPainter, leftRect, tqApp->tqpalette().active(), sflags); dominoPainter.end(); dominoPainter.begin(&rightPix); - qApp->style().drawPrimitive(QStyle::PE_ScrollBarAddPage, &dominoPainter, rightRect, qApp->palette().active(), sflags); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_ScrollBarAddPage, &dominoPainter, rightRect, tqApp->tqpalette().active(), sflags); if (orientation == GTK_ORIENTATION_HORIZONTAL) { - bitBlt(&pixmap, 1, 0, &leftPix, leftRect.width(), 0, 6, h, Qt::CopyROP, true); - bitBlt(&pixmap, w-7, 0, &rightPix, 0, 0, 7, h, Qt::CopyROP, true); + bitBlt(TQT_TQPAINTDEVICE(&pixmap), 1, 0, TQT_TQPAINTDEVICE(&leftPix), leftRect.width(), 0, 6, h, TQt::CopyROP, true); + bitBlt(TQT_TQPAINTDEVICE(&pixmap), w-7, 0, TQT_TQPAINTDEVICE(&rightPix), 0, 0, 7, h, TQt::CopyROP, true); } else { - bitBlt(&pixmap, 0, 1, &leftPix, 0, leftRect.height(), w, 6, Qt::CopyROP, true); - bitBlt(&pixmap, 0, h-7, &rightPix, 0, 0, w, 7, Qt::CopyROP, true); + bitBlt(TQT_TQPAINTDEVICE(&pixmap), 0, 1, TQT_TQPAINTDEVICE(&leftPix), 0, leftRect.height(), w, 6, TQt::CopyROP, true); + bitBlt(TQT_TQPAINTDEVICE(&pixmap), 0, h-7, TQT_TQPAINTDEVICE(&rightPix), 0, 0, w, 7, TQt::CopyROP, true); } } @@ -1104,7 +1104,7 @@ void drawScrollBarSlider(GdkWindow* window, GtkStyle* style, GtkStateType state, void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int orientation, GtkAdjustment* adj, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) @@ -1112,7 +1112,7 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o if (scrollBar != 0) delete scrollBar; - scrollBar = new QScrollBar(NULL); + scrollBar = new TQScrollBar(NULL); scrollBar->resize(w,h); @@ -1129,11 +1129,11 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o scrollBar->setOrientation(orientation ? Qt::Vertical : Qt::Horizontal); - QStyle::SFlags sflags = stateToSFlags(state); - if (sflags |= QStyle::Style_Down) sflags = QStyle::Style_Enabled; - if (orientation == GTK_ORIENTATION_HORIZONTAL) sflags |= QStyle::Style_Horizontal; + TQStyle::SFlags sflags = stateToSFlags(state); + if (sflags |= TQStyle::Style_Down) sflags = TQStyle::Style_Enabled; + if (orientation == GTK_ORIENTATION_HORIZONTAL) sflags |= TQStyle::Style_Horizontal; - QPixmap pixmap(w,h); + TQPixmap pixmap(w,h); scrollBar->setMinValue(0); scrollBar->setMaxValue(65535); @@ -1145,9 +1145,9 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o if (orientation == GTK_ORIENTATION_VERTICAL) { - QRect r; - r = qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar, - scrollBar, QStyle::SC_ScrollBarSlider); + TQRect r; + r = tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar, + scrollBar, TQStyle::SC_ScrollBarSlider); offset = r.y(); thumbSize = r.height(); if (thumbSize < 0) @@ -1156,23 +1156,23 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o if (!r.isValid()) // Fix a crash bug in Eclipse where it was trying to draw tiny scrollbars. return; - QPixmap tmpPixmap(w, h + thumbSize); - QPainter painter2(&tmpPixmap); + TQPixmap tmpPixmap(w, h + thumbSize); + TQPainter painter2(&tmpPixmap); scrollBar->resize(w, h + thumbSize); painter2.fillRect(0, 0, w, h + thumbSize, - qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawComplexControl(QStyle::CC_ScrollBar, - &painter2, scrollBar, QRect(0, 0, w, h+thumbSize), - qApp->palette().active(), sflags); + tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawComplexControl(TQStyle::CC_ScrollBar, + &painter2, scrollBar, TQRect(0, 0, w, h+thumbSize), + tqApp->tqpalette().active(), sflags); - bitBlt(&pixmap, 0, 0, &tmpPixmap, 0, 0, w, offset, Qt::CopyROP); + bitBlt(&pixmap, 0, 0, &tmpPixmap, 0, 0, w, offset, TQt::CopyROP); bitBlt(&pixmap, 0, offset, &tmpPixmap, 0, offset + thumbSize, - w, h - offset, Qt::CopyROP); + w, h - offset, TQt::CopyROP); } else { - QRect r; - r = qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar, - scrollBar, QStyle::SC_ScrollBarSlider); + TQRect r; + r = tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar, + scrollBar, TQStyle::SC_ScrollBarSlider); offset = r.x(); thumbSize = r.width(); if (thumbSize < 0) @@ -1181,19 +1181,19 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o if (!r.isValid()) // Fix a crash bug in Eclipse when it was trying to draw tiny scrollbars. return; - QPixmap tmpPixmap(w + thumbSize, h); - QPainter painter2(&tmpPixmap); + TQPixmap tmpPixmap(w + thumbSize, h); + TQPainter painter2(&tmpPixmap); scrollBar->resize(w + thumbSize, h); painter2.fillRect(0, 0, w + thumbSize, h, - qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawComplexControl(QStyle::CC_ScrollBar, - &painter2, scrollBar, QRect(0, 0, w+thumbSize, h), - qApp->palette().active(), sflags); + tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawComplexControl(TQStyle::CC_ScrollBar, + &painter2, scrollBar, TQRect(0, 0, w+thumbSize, h), + tqApp->tqpalette().active(), sflags); - bitBlt(&pixmap, 0, 0, &tmpPixmap, 0, 0, offset, h, Qt::CopyROP); + bitBlt(&pixmap, 0, 0, &tmpPixmap, 0, 0, offset, h, TQt::CopyROP); bitBlt(&pixmap, offset, 0, &tmpPixmap, offset + thumbSize, 0, - w - offset, h, Qt::CopyROP); + w - offset, h, TQt::CopyROP); } GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); @@ -1203,37 +1203,37 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o void drawToolButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QToolButton button(NULL); + TQToolButton button(NULL); button.resize(w, h); /* - int realW = button.sizeHint().width(); - int realH = button.sizeHint().height(); */ + int realW = button.tqsizeHint().width(); + int realH = button.tqsizeHint().height(); */ - QStyle::SFlags sflags = stateToSFlags(state); - QStyle::SCFlags activeflags = QStyle::SC_None; + TQStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SCFlags activeflags = TQStyle::SC_None; if (state == GTK_STATE_ACTIVE) { - sflags |= QStyle::Style_AutoRaise; - activeflags = QStyle::SC_ToolButton; + sflags |= TQStyle::Style_AutoRaise; + activeflags = TQStyle::SC_ToolButton; } else - sflags |= QStyle::Style_AutoRaise | QStyle::Style_Raised; + sflags |= TQStyle::Style_AutoRaise | TQStyle::Style_Raised; - QPixmap pixmap(w,h); - QPainter painter(&pixmap); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawComplexControl(QStyle::CC_ToolButton, &painter, &button, QRect(0, 0, w, h), qApp->palette().active(), sflags, QStyle::SC_ToolButton, activeflags); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawComplexControl(TQStyle::CC_ToolButton, &painter, &button, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, TQStyle::SC_ToolButton, activeflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -1242,20 +1242,20 @@ void drawToolButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int void drawMenuBarItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w, h); - QPainter painter(&pixmap); - QMenuItem mi; - QMenuBar mb(0); + TQPixmap pixmap(w, h); + TQPainter painter(&pixmap); + TQMenuItem mi; + TQMenuBar mb(0); - QStyle::SFlags sflags = QStyle::Style_Down | QStyle::Style_Enabled | QStyle::Style_Active | QStyle::Style_HasFocus; + TQStyle::SFlags sflags = TQStyle::Style_Down | TQStyle::Style_Enabled | TQStyle::Style_Active | TQStyle::Style_HasFocus; - qApp->style().drawControl(QStyle::CE_MenuBarItem, &painter, &mb, QRect(0, 0, w, h), qApp->palette().active(), sflags, QStyleOption(&mi)); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_MenuBarItem, &painter, &mb, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, TQStyleOption(&mi)); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -1264,23 +1264,23 @@ void drawMenuBarItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int void drawMenuItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w,h); - QPainter painter(&pixmap); - QPopupMenu pm; - QMenuData md; - QMenuItem* mi = md.findItem(md.insertItem("")); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); + TQPopupMenu pm; + TQMenuData md; + TQMenuItem* mi = md.tqfindItem(md.insertItem("")); - QStyleOption opt(mi, 16, 16); - QStyle::SFlags sflags = QStyle::Style_Active | QStyle::Style_Enabled; + TQStyleOption opt(mi, 16, 16); + TQStyle::SFlags sflags = TQStyle::Style_Active | TQStyle::Style_Enabled; - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawControl(QStyle::CE_PopupMenuItem, &painter, &pm, QRect(0,0,w,h), qApp->palette().active(), sflags, opt); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_PopupMenuItem, &painter, &pm, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags, opt); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -1289,21 +1289,21 @@ void drawMenuItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, void drawSplitter(GdkWindow* window, GtkStyle* style, GtkStateType state, int orientation, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w,h); - QPainter painter(&pixmap); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); // No idea why this works... - if (orientation != GTK_ORIENTATION_HORIZONTAL) sflags |= QStyle::Style_Horizontal; + if (orientation != GTK_ORIENTATION_HORIZONTAL) sflags |= TQStyle::Style_Horizontal; - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawPrimitive(QStyle::PE_Splitter, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_Splitter, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -1312,79 +1312,79 @@ void drawSplitter(GdkWindow* window, GtkStyle* style, GtkStateType state, int or void drawTabFrame(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h, GtkPositionType pos) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); - QPixmap pixmap(w, h); - QPainter painter(&pixmap); - QStyleOption opt(2, 2); // line width + TQPixmap pixmap(w, h); + TQPainter painter(&pixmap); + TQStyleOption opt(2, 2); // line width if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawPrimitive(QStyle::PE_PanelTabWidget, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags, opt); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelTabWidget, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags, opt); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); g_object_unref(pix); // Drawing tab base - int th = qApp->style().pixelMetric(QStyle::PM_TabBarBaseHeight, meepTabBar); + int th = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_TabBarBaseHeight, meepTabBar); int tw = w; if ((tw < 1) || (th < 1)) return; - QPixmap pixmap1(tw,th); - QPainter painter1(&pixmap1); + TQPixmap pixmap1(tw,th); + TQPainter painter1(&pixmap1); if ((backgroundTile) && (!backgroundTile->isNull())) - painter1.fillRect(0, 0, tw, th, QBrush(QColor(255,255,255), *backgroundTile)); + painter1.fillRect(0, 0, tw, th, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter1.fillRect(0, 0, tw, th, qApp->palette().active().brush(QColorGroup::Background)); + painter1.fillRect(0, 0, tw, th, tqApp->tqpalette().active().brush(TQColorGroup::Background)); - qApp->style().drawPrimitive(QStyle::PE_TabBarBase, &painter1, QRect(0, 0, tw, th), qApp->palette().active(), sflags, QStyleOption(1,1)); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_TabBarBase, &painter1, TQRect(0, 0, tw, th), tqApp->tqpalette().active(), sflags, TQStyleOption(1,1)); if (pos == GTK_POS_BOTTOM) { - QWMatrix m; + TQWMatrix m; m.scale(1, -1); pixmap1 = pixmap1.xForm(m); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap1.handle()); - gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y+h+qApp->style().pixelMetric(QStyle::PM_TabBarBaseOverlap, meepTabBar), tw, th); + gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y+h+tqApp->tqstyle().tqpixelMetric(TQStyle::PM_TabBarBaseOverlap, meepTabBar), tw, th); g_object_unref(pix); } else { GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap1.handle()); - gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y-qApp->style().pixelMetric(QStyle::PM_TabBarBaseOverlap, meepTabBar), tw, th); + gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y-tqApp->tqstyle().tqpixelMetric(TQStyle::PM_TabBarBaseOverlap, meepTabBar), tw, th); g_object_unref(pix); } } void drawMenu(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w, h); - QPainter painter(&pixmap); - QStyle::SFlags sflags = stateToSFlags(state); + TQPixmap pixmap(w, h); + TQPainter painter(&pixmap); + TQStyle::SFlags sflags = stateToSFlags(state); if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawPrimitive(QStyle::PE_PanelPopup, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelPopup, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -1408,7 +1408,7 @@ void drawMenu(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int void drawProgressChunk(GdkWindow * window, GtkStyle * style, GtkStateType state, int x, int y, int w, int h) { // This is only for Mozilla/Firefox - if (!mozillaFix || !gtkQtEnable) + if (!mozillaFix || !gtkTQtEnable) return; if ((w<=1) || (h<=1)) @@ -1418,24 +1418,24 @@ void drawProgressChunk(GdkWindow * window, GtkStyle * style, GtkStateType state, int w2 = isAlloy ? w+4 : w; int h2 = isAlloy ? h+4 : h; - QProgressBar bar(100, NULL); + TQProgressBar bar(100, NULL); bar.resize(w2, h2); bar.setProgress(100); bar.setCenterIndicator(false); bar.setPercentageVisible(false); - bar.setFrameStyle(QFrame::NoFrame); + bar.setFrameStyle(TQFrame::NoFrame); if ((w2 < 1) || (h2 < 1)) return; - QPixmap pixmap(w2, h2); - QPainter painter(&pixmap); + TQPixmap pixmap(w2, h2); + TQPainter painter(&pixmap); - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); - qApp->style().drawControl(QStyle::CE_ProgressBarContents, &painter, &bar, QRect(0,0,w2,h2), qApp->palette().active(), sflags); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_ProgressBarContents, &painter, &bar, TQRect(0,0,w2,h2), tqApp->tqpalette().active(), sflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); if (isAlloy) @@ -1447,13 +1447,13 @@ void drawProgressChunk(GdkWindow * window, GtkStyle * style, GtkStateType state, void drawProgressBar(GdkWindow * window, GtkStyle * style, GtkStateType state, GtkProgressBarOrientation orientation, gfloat percentage, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w<=1) || (h<=1)) return; // Trying to draw something that small caused a segdault - QProgressBar bar(100, NULL); + TQProgressBar bar(100, NULL); if ((orientation == GTK_PROGRESS_BOTTOM_TO_TOP) || (orientation == GTK_PROGRESS_TOP_TO_BOTTOM)) bar.resize(h, w); else @@ -1462,9 +1462,9 @@ void drawProgressBar(GdkWindow * window, GtkStyle * style, GtkStateType state, G bar.setCenterIndicator(false); bar.setPercentageVisible(false); - QPixmap pixmap = QPixmap::grabWidget(&bar); + TQPixmap pixmap = TQPixmap::grabWidget(&bar); - QWMatrix matrix; + TQWMatrix matrix; switch (orientation) { case GTK_PROGRESS_RIGHT_TO_LEFT: matrix.rotate(180); break; @@ -1483,10 +1483,10 @@ void drawProgressBar(GdkWindow * window, GtkStyle * style, GtkStateType state, G void drawSlider(GdkWindow * window, GtkStyle * style, GtkStateType state, GtkAdjustment *adj, int x, int y, int w, int h, GtkOrientation orientation, int inverted) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; - meepSlider->setBackgroundOrigin(QWidget::ParentOrigin); + meepSlider->setBackgroundOrigin(TQWidget::ParentOrigin); meepSlider->setOrientation((orientation == GTK_ORIENTATION_HORIZONTAL) ? Qt::Horizontal : Qt::Vertical); meepSlider->setEnabled(state != GTK_STATE_INSENSITIVE); @@ -1500,7 +1500,7 @@ void drawSlider(GdkWindow * window, GtkStyle * style, GtkStateType state, GtkAdj else // Inverted sliders... where max is at the left/top and min is at the right/bottom meepSlider->setValue(100-(int)((adj->value-adj->lower)/(adj->upper-adj->lower)*100)); - QPixmap pixmap = QPixmap::grabWidget(meepSlider); + TQPixmap pixmap = TQPixmap::grabWidget(meepSlider); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); g_object_unref(pix); @@ -1508,19 +1508,19 @@ void drawSlider(GdkWindow * window, GtkStyle * style, GtkStateType state, GtkAdj void drawSpinButton(GdkWindow * window, GtkStyle * style, GtkStateType state, int direction, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w, h); - QPainter painter(&pixmap); + TQPixmap pixmap(w, h); + TQPainter painter(&pixmap); - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawPrimitive((direction ? QStyle::PE_SpinWidgetDown : QStyle::PE_SpinWidgetUp), &painter, QRect(0,0,w,h), qApp->palette().active(), sflags); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawPrimitive((direction ? TQStyle::PE_SpinWidgetDown : TQStyle::PE_SpinWidgetUp), &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -1529,19 +1529,19 @@ void drawSpinButton(GdkWindow * window, GtkStyle * style, GtkStateType state, in void drawListHeader(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w,h); - QPainter painter(&pixmap); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); - QStyle::SFlags sflags = stateToSFlags(state) | QStyle::Style_Horizontal; + TQStyle::SFlags sflags = stateToSFlags(state) | TQStyle::Style_Horizontal; - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawPrimitive(QStyle::PE_HeaderSection, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_HeaderSection, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -1551,19 +1551,19 @@ void drawListHeader(GdkWindow* window, GtkStyle* style, GtkStateType state, int void drawListViewItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w, h); - QPainter painter(&pixmap); + TQPixmap pixmap(w, h); + TQPainter painter(&pixmap); /* Get the brush corresponding to highlight color */ - QBrush brush = qApp->palette().brush(QPalette::Active, QColorGroup::Highlight); + TQBrush brush = tqApp->palette().brush(TQPalette::Active, TQColorGroup::Highlight); painter.setBrush(brush); - painter.setPen(Qt::NoPen); + painter.setPen(TQt::NoPen); painter.drawRect(0, 0, w, h); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); @@ -1573,25 +1573,25 @@ void drawListViewItem(GdkWindow* window, GtkStyle* style, GtkStateType state, in void drawSquareButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; - QPixmap pixmap(20, 20); - QPainter painter(&pixmap); - QPushButton button(0); + TQPixmap pixmap(20, 20); + TQPainter painter(&pixmap); + TQPushButton button(0); - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); if (fillPixmap && (!fillPixmap->isNull())) - painter.fillRect(0, 0, 20, 20, QBrush(QColor(255,255,255), *fillPixmap)); + painter.fillRect(0, 0, 20, 20, TQBrush(TQColor(255,255,255), *fillPixmap)); else if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, 20, 20, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, 20, 20, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, 20, 20, qApp->palette().active().brush(QColorGroup::Background)); + painter.fillRect(0, 0, 20, 20, tqApp->tqpalette().active().brush(TQColorGroup::Background)); - qApp->style().drawControl(QStyle::CE_PushButton, &painter, &button, - QRect(0,0,20,20), qApp->palette().active(), sflags); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_PushButton, &painter, &button, + TQRect(0,0,20,20), tqApp->tqpalette().active(), sflags); - QImage image = pixmap.convertToImage().smoothScale(w,h); + TQImage image = pixmap.convertToImage().smoothScale(w,h); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -1600,22 +1600,22 @@ void drawSquareButton(GdkWindow* window, GtkStyle* style, GtkStateType state, in void initDrawTabNG(int count) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; delete meepTabBar; meepTabBar = 0; - meepTabBar = new QTabBar(meepWidget); + meepTabBar = new TQTabBar(meepWidget); for ( int i = 0; i < count; i++ ) - meepTabBar->addTab(new QTab); + meepTabBar->addTab(new TQTab); return; } void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h, GtkNotebook *notebook) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; GtkPositionType tpos = gtk_notebook_get_tab_pos(notebook); @@ -1632,7 +1632,7 @@ void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, in } } - QTab *tab = meepTabBar->tabAt(pos); + TQTab *tab = meepTabBar->tabAt(pos); if (!tab) { @@ -1644,11 +1644,11 @@ void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, in return; } - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); if (state != GTK_STATE_ACTIVE) { - sflags = QStyle::Style_Selected; + sflags = TQStyle::Style_Selected; if (tpos == GTK_POS_TOP) y += 3; h -= 3; @@ -1657,21 +1657,21 @@ void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, in if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w,h); - QPainter painter(&pixmap); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawControl(QStyle::CE_TabBarTab, &painter, (QTabBar *)meepTabBar, QRect(0,0,w,h), qApp->palette().active(), sflags, QStyleOption(tab)); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_TabBarTab, &painter, (TQTabBar *)meepTabBar, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags, TQStyleOption(tab)); painter.end(); // So the pixmap assignment below won't give an error // Account for tab position -- if its in the bottom flip the image if (tpos == GTK_POS_BOTTOM) { - QWMatrix m; + TQWMatrix m; m.scale(1, -1); pixmap = pixmap.xForm(m); } @@ -1683,39 +1683,39 @@ void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, in void drawArrow(GdkWindow* window, GtkStyle* style, GtkStateType state, GtkArrowType direction, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QStyle::SFlags sflags = stateToSFlags(state); + TQStyle::SFlags sflags = stateToSFlags(state); if (state == GTK_STATE_INSENSITIVE) - sflags |= QStyle::Style_Off; + sflags |= TQStyle::Style_Off; else if (state == GTK_STATE_PRELIGHT) - sflags |= QStyle::Style_On; + sflags |= TQStyle::Style_On; - QStyle::PrimitiveElement element; + TQStyle::PrimitiveElement element; switch(direction) { - case GTK_ARROW_UP: element = QStyle::PE_ArrowUp; break; - case GTK_ARROW_DOWN: element = QStyle::PE_ArrowDown; break; - case GTK_ARROW_LEFT: element = QStyle::PE_ArrowLeft; break; - case GTK_ARROW_RIGHT: element = QStyle::PE_ArrowRight; break; + case GTK_ARROW_UP: element = TQStyle::PE_ArrowUp; break; + case GTK_ARROW_DOWN: element = TQStyle::PE_ArrowDown; break; + case GTK_ARROW_LEFT: element = TQStyle::PE_ArrowLeft; break; + case GTK_ARROW_RIGHT: element = TQStyle::PE_ArrowRight; break; } - QPixmap pixmap(w,h); - QPainter painter(&pixmap); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); if (fillPixmap && (!fillPixmap->isNull())) - painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *fillPixmap)); + painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *fillPixmap)); else if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background)); + painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background)); - qApp->style().drawPrimitive(element, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags); + tqApp->tqstyle().tqdrawPrimitive(element, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h); @@ -1724,18 +1724,18 @@ void drawArrow(GdkWindow* window, GtkStyle* style, GtkStateType state, GtkArrowT void drawFocusRect(GdkWindow * window, GtkStyle * style, int x, int y, int w, int h) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((w < 1) || (h < 1)) return; - QPixmap pixmap(w,h); - QPainter painter(&pixmap); - QColor bg(qApp->palette().active().background()); + TQPixmap pixmap(w,h); + TQPainter painter(&pixmap); + TQColor bg(tqApp->tqpalette().active().background()); painter.fillRect(0,0,w,h,bg); - qApp->style().drawPrimitive(QStyle::PE_FocusRect, &painter, QRect(0,0,w,h), qApp->palette().active(), QStyle::Style_Default, QStyleOption(bg)); + tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_FocusRect, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), TQStyle::Style_Default, TQStyleOption(bg)); GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle()); gdk_draw_drawable(window, style->bg_gc[GTK_STATE_NORMAL], pix, 0, 0, x, y, w, h); @@ -1756,31 +1756,31 @@ GdkGC* alternateBackgroundGc(GtkStyle* style) gdk_colormap_alloc_color(style->colormap, &altBackColor, FALSE, TRUE); GdkGCValues gc_values; - GdkGCValuesMask gc_values_mask; - gc_values_mask = GDK_GC_FOREGROUND; + GdkGCValuesMask gc_values_tqmask; + gc_values_tqmask = GDK_GC_FOREGROUND; gc_values.foreground = altBackColor; - altBackGC = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + altBackGC = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); return altBackGC; } // Thanks Martin Dvorak of metatheme -QString parse_rc_string(const QString& defs, const QString& pattern, bool widgetClass = true) +TQString parse_rc_string(const TQString& defs, const TQString& pattern, bool widgetClass = true) { static int dynamic_counter = 0; ++dynamic_counter; - return "style \"gtk-qt-dynamic-" + QString::number(dynamic_counter) + "\" { " + defs + " } " + (widgetClass ? "widget_class" : "widget") + " \"" + pattern + "\" style \"gtk-qt-dynamic-" + QString::number(dynamic_counter) + "\"\n"; + return "style \"gtk-qt-dynamic-" + TQString::number(dynamic_counter) + "\" { " + defs + " } " + (widgetClass ? "widget_class" : "widget") + " \"" + pattern + "\" style \"gtk-qt-dynamic-" + TQString::number(dynamic_counter) + "\"\n"; } -QString doIconMapping(const QString& stockName, const QString& path, int sizes) +TQString doIconMapping(const TQString& stockName, const TQString& path, int sizes) { - QString fullPath; + TQString fullPath; bool has16 = false, has22 = false, has32 = false; - for( QStringList::ConstIterator it = iconThemeDirs.begin(); + for( TQStringList::ConstIterator it = iconThemeDirs.begin(); it != iconThemeDirs.end(); ++it ) { @@ -1798,7 +1798,7 @@ QString doIconMapping(const QString& stockName, const QString& path, int sizes) if (!has16 && !has22 && !has32) return ""; // sizes is an addition of 1=16, 2=22 and 4=32 - QString ret = "stock[\"" + stockName + "\"]={\n"; + TQString ret = "stock[\"" + stockName + "\"]={\n"; if (has22) ret += "\t{ \"22x22/" + path +"\", *, *, \"gtk-large-toolbar\" },\n"; @@ -1827,102 +1827,102 @@ QString doIconMapping(const QString& stockName, const QString& path, int sizes) return ret; } -QString colorString(QColor color) +TQString colorString(TQColor color) { - QString ret = "{"; - ret += QString::number(color.red() * 257) + ", "; - ret += QString::number(color.green() * 257) + ", "; - ret += QString::number(color.blue() * 257) + "}"; + TQString ret = "{"; + ret += TQString::number(color.red() * 257) + ", "; + ret += TQString::number(color.green() * 257) + ", "; + ret += TQString::number(color.blue() * 257) + "}"; return ret; } -void setColour(QString name, QColor color) +void setColour(TQString name, TQColor color) { gtk_rc_parse_string(parse_rc_string(name + " = " + colorString(color), "*").latin1()); } -static QStringList iconInheritsDirs( const QString& icondir ) +static TQStringList iconInheritsDirs( const TQString& icondir ) { - QFile index; + TQFile index; index.setName( icondir + "index.theme" ); if( !index.open( IO_ReadOnly )) { index.setName( icondir + "index.desktop" ); if( !index.open( IO_ReadOnly )) - return QStringList(); + return TQStringList(); } char buf[ 1024 ]; - QRegExp reg( "^\\s*Inherits=([^\\n]*)" ); + TQRegExp reg( "^\\s*Inherits=([^\\n]*)" ); for(;;) { if( index.readLine( buf, 1023 ) <= 0 ) break; if( reg.search( buf, 0 ) >= 0 ) - return QStringList::split(",", reg.cap(1)); + return TQStringList::split(",", reg.cap(1)); } - return QStringList(); + return TQStringList(); } void setRcProperties(GtkRcStyle* rc_style, int forceRecreate) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; - if (gtkQtDebug) + if (gtkTQtDebug) printf("setRcProperties()\n"); gtkRcStyle = rc_style; // Set colors // Normal - setColour("fg[NORMAL]", qApp->palette().active().text()); - setColour("bg[NORMAL]", qApp->palette().active().background()); - setColour("text[NORMAL]", qApp->palette().active().text()); - setColour("base[NORMAL]", qApp->palette().active().base()); + setColour("fg[NORMAL]", tqApp->tqpalette().active().text()); + setColour("bg[NORMAL]", tqApp->tqpalette().active().background()); + setColour("text[NORMAL]", tqApp->tqpalette().active().text()); + setColour("base[NORMAL]", tqApp->tqpalette().active().base()); // Active (on) - setColour("fg[ACTIVE]", qApp->palette().active().text()); - setColour("bg[ACTIVE]", qApp->palette().active().background()); - setColour("text[ACTIVE]", qApp->palette().active().text()); - setColour("base[ACTIVE]", qApp->palette().active().base()); + setColour("fg[ACTIVE]", tqApp->tqpalette().active().text()); + setColour("bg[ACTIVE]", tqApp->tqpalette().active().background()); + setColour("text[ACTIVE]", tqApp->tqpalette().active().text()); + setColour("base[ACTIVE]", tqApp->tqpalette().active().base()); // Mouseover - setColour("fg[PRELIGHT]", qApp->palette().active().text()); // menu items - change? - setColour("bg[PRELIGHT]", qApp->palette().active().highlight()); - setColour("text[PRELIGHT]", qApp->palette().active().text()); - setColour("base[PRELIGHT]", qApp->palette().active().base()); + setColour("fg[PRELIGHT]", tqApp->tqpalette().active().text()); // menu items - change? + setColour("bg[PRELIGHT]", tqApp->tqpalette().active().highlight()); + setColour("text[PRELIGHT]", tqApp->tqpalette().active().text()); + setColour("base[PRELIGHT]", tqApp->tqpalette().active().base()); // Selected - setColour("fg[SELECTED]", qApp->palette().active().highlightedText()); - setColour("bg[SELECTED]", qApp->palette().active().highlight()); - setColour("text[SELECTED]", qApp->palette().active().highlightedText()); - setColour("base[SELECTED]", qApp->palette().active().highlight()); + setColour("fg[SELECTED]", tqApp->tqpalette().active().highlightedText()); + setColour("bg[SELECTED]", tqApp->tqpalette().active().highlight()); + setColour("text[SELECTED]", tqApp->tqpalette().active().highlightedText()); + setColour("base[SELECTED]", tqApp->tqpalette().active().highlight()); // Disabled - setColour("fg[INSENSITIVE]", qApp->palette().disabled().text()); - setColour("bg[INSENSITIVE]", qApp->palette().disabled().background()); - setColour("text[INSENSITIVE]", qApp->palette().disabled().text()); - setColour("base[INSENSITIVE]", qApp->palette().disabled().background()); + setColour("fg[INSENSITIVE]", tqApp->tqpalette().disabled().text()); + setColour("bg[INSENSITIVE]", tqApp->tqpalette().disabled().background()); + setColour("text[INSENSITIVE]", tqApp->tqpalette().disabled().text()); + setColour("base[INSENSITIVE]", tqApp->tqpalette().disabled().background()); - gtk_rc_parse_string(("gtk-button-images = " + QString::number(showIconsOnButtons)).latin1()); + gtk_rc_parse_string(("gtk-button-images = " + TQString::number(showIconsOnButtons)).latin1()); - gtk_rc_parse_string(("gtk-toolbar-style = " + QString::number(toolbarStyle)).latin1()); + gtk_rc_parse_string(("gtk-toolbar-style = " + TQString::number(toolbarStyle)).latin1()); // This function takes quite a long time to execute, and is run at the start of every app. // In order to speed it up, we can store the results in a file, along with the name of icon // theme and style. This file can then be regenerated when the icon theme or style change. - QString cacheFilePath = QDir::homeDirPath() + "/.gtk_qt_engine_rc"; - QFile cacheFile(cacheFilePath); - QTextStream stream; + TQString cacheFilePath = TQDir::homeDirPath() + "/.gtk_qt_engine_rc"; + TQFile cacheFile(cacheFilePath); + TQTextStream stream; if (!forceRecreate && cacheFile.exists()) { cacheFile.open(IO_ReadOnly); - stream.setDevice(&cacheFile); + stream.setDevice(TQT_TQIODEVICE(&cacheFile)); - if (stream.readLine() == "# " + iconTheme + ", " + qApp->style().name() + ", " + RC_CACHE_VERSION) + if (stream.readLine() == "# " + iconTheme + ", " + tqApp->tqstyle().name() + ", " + RC_CACHE_VERSION) { // This cache matches the current icon theme and style // Let's load it and return @@ -1935,13 +1935,13 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate) } cacheFile.open(IO_WriteOnly | IO_Truncate); - stream.setDevice(&cacheFile); + stream.setDevice(TQT_TQIODEVICE(&cacheFile)); - stream << "# " << iconTheme << ", " << qApp->style().name() << ", " << RC_CACHE_VERSION << "\n\n"; - stream << "# This file was generated by the Gtk Qt Theme Engine\n"; + stream << "# " << iconTheme << ", " << tqApp->tqstyle().name() << ", " << RC_CACHE_VERSION << "\n\n"; + stream << "# This file was generated by the Gtk TQt Theme Engine\n"; stream << "# It will be recreated when you change your KDE icon theme or widget style\n\n"; - QScrollBar sbar(NULL); + TQScrollBar sbar(NULL); sbar.setOrientation(Qt::Horizontal); sbar.setValue(1); sbar.resize(200,25); @@ -1949,53 +1949,53 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate) // The following code determines how many buttons are on a scrollbar // It works by looking at each pixel of the scrollbar's area not taken up by the groove, // and asking the style which subcontrol is at that location. - QRect rect = qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar, &sbar, QStyle::SC_ScrollBarGroove); + TQRect rect = tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar, &sbar, TQStyle::SC_ScrollBarGroove); bool back1 = false; bool forward1 = false; bool back2 = false; bool forward2 = false; - QStyle::SubControl sc = QStyle::SC_None; - for (QPoint pos(0,7) ; pos.x()style().querySubControl(QStyle::CC_ScrollBar, &sbar, pos); + TQStyle::SubControl sc2 = tqApp->tqstyle().querySubControl(TQStyle::CC_ScrollBar, &sbar, pos); if (sc != sc2) { - if (sc2 == QStyle::SC_ScrollBarAddLine) forward1 = true; - if (sc2 == QStyle::SC_ScrollBarSubLine) back1 = true; + if (sc2 == TQStyle::SC_ScrollBarAddLine) forward1 = true; + if (sc2 == TQStyle::SC_ScrollBarSubLine) back1 = true; sc = sc2; } } - sc = QStyle::SC_None; - for (QPoint pos(rect.x()+rect.width(),7) ; pos.x()<200 ; pos.setX(pos.x()+1)) + sc = TQStyle::SC_None; + for (TQPoint pos(rect.x()+rect.width(),7) ; pos.x()<200 ; pos.setX(pos.x()+1)) { - QStyle::SubControl sc2 = qApp->style().querySubControl(QStyle::CC_ScrollBar, &sbar, pos); + TQStyle::SubControl sc2 = tqApp->tqstyle().querySubControl(TQStyle::CC_ScrollBar, &sbar, pos); if (sc != sc2) { - if (sc2 == QStyle::SC_ScrollBarAddLine) forward2 = true; - if (sc2 == QStyle::SC_ScrollBarSubLine) back2 = true; + if (sc2 == TQStyle::SC_ScrollBarAddLine) forward2 = true; + if (sc2 == TQStyle::SC_ScrollBarSubLine) back2 = true; sc = sc2; } } - stream << parse_rc_string(QString("GtkScrollbar::has-backward-stepper = ") + (back1 ? "1" : "0"), "*"); - stream << parse_rc_string(QString("GtkScrollbar::has-forward-stepper = ") + (forward2 ? "1" : "0"), "*"); - stream << parse_rc_string(QString("GtkScrollbar::has-secondary-forward-stepper = ") + (forward1 ? "1" : "0"), "*"); - stream << parse_rc_string(QString("GtkScrollbar::has-secondary-backward-stepper = ") + (back2 ? "1" : "0"), "*"); + stream << parse_rc_string(TQString("GtkScrollbar::has-backward-stepper = ") + (back1 ? "1" : "0"), "*"); + stream << parse_rc_string(TQString("GtkScrollbar::has-forward-stepper = ") + (forward2 ? "1" : "0"), "*"); + stream << parse_rc_string(TQString("GtkScrollbar::has-secondary-forward-stepper = ") + (forward1 ? "1" : "0"), "*"); + stream << parse_rc_string(TQString("GtkScrollbar::has-secondary-backward-stepper = ") + (back2 ? "1" : "0"), "*"); - stream << parse_rc_string("GtkScrollbar::stepper-size = " + QString::number(qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar, &sbar, QStyle::SC_ScrollBarSubLine).width() - 1), "*"); + stream << parse_rc_string("GtkScrollbar::stepper-size = " + TQString::number(tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar, &sbar, TQStyle::SC_ScrollBarSubLine).width() - 1), "*"); - stream << parse_rc_string("GtkScrollbar::min-slider-length = " + QString::number(qApp->style().pixelMetric(QStyle::PM_ScrollBarSliderMin)), "*"); - stream << parse_rc_string("GtkScrollbar::slider-width = " + QString::number(qApp->style().pixelMetric(QStyle::PM_ScrollBarExtent)-2), "*"); - stream << parse_rc_string("GtkButton::child-displacement-x = " + QString::number(qApp->style().pixelMetric(QStyle::PM_ButtonShiftHorizontal)), "*"); - stream << parse_rc_string("GtkButton::child-displacement-y = " + QString::number(qApp->style().pixelMetric(QStyle::PM_ButtonShiftVertical)), "*"); - QSlider slider(NULL); // To keep BlueCurve happy - stream << parse_rc_string("GtkScale::slider-length = " + QString::number(qApp->style().pixelMetric(QStyle::PM_SliderLength, &slider)), "*"); + stream << parse_rc_string("GtkScrollbar::min-slider-length = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_ScrollBarSliderMin)), "*"); + stream << parse_rc_string("GtkScrollbar::slider-width = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_ScrollBarExtent)-2), "*"); + stream << parse_rc_string("GtkButton::child-displacement-x = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_ButtonShiftHorizontal)), "*"); + stream << parse_rc_string("GtkButton::child-displacement-y = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_ButtonShiftVertical)), "*"); + TQSlider slider(NULL); // To keep BlueCurve happy + stream << parse_rc_string("GtkScale::slider-length = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_SliderLength, &slider)), "*"); stream << parse_rc_string("GtkButton::default-border = { 0, 0, 0, 0 }", "*"); - stream << parse_rc_string("xthickness = " + QString::number(qApp->style().pixelMetric(QStyle::PM_DefaultFrameWidth)), "*.GtkMenu"); - stream << parse_rc_string("ythickness = " + QString::number(qApp->style().pixelMetric(QStyle::PM_DefaultFrameWidth)), "*.GtkMenu"); + stream << parse_rc_string("xthickness = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_DefaultFrameWidth)), "*.GtkMenu"); + stream << parse_rc_string("ythickness = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_DefaultFrameWidth)), "*.GtkMenu"); stream << parse_rc_string("xthickness = 5", "*.GtkMenu.Gtk*MenuItem"); stream << parse_rc_string("xthickness = 3", "*.GtkNotebook"); stream << parse_rc_string("ythickness = 3", "*.GtkNotebook"); @@ -2003,7 +2003,7 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate) stream << parse_rc_string("fg[NORMAL] = {0, 0, 0}", "gtk-tooltips.GtkLabel", false); // This one may not work... - //insertIntProperty(rc_style, "GtkCheckButton", "indicator-size", qApp->style().pixelMetric(QStyle::PM_IndicatorHeight) ); + //insertIntProperty(rc_style, "GtkCheckButton", "indicator-size", tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorHeight) ); // For icons @@ -2047,8 +2047,8 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate) stream << doIconMapping("gtk-edit", "actions/gtk-edit.png"); //2.6 stream << doIconMapping("gtk-execute", "actions/exec.png"); stream << doIconMapping("gtk-file", "mimetypes/gtk-file.png"); - stream << doIconMapping("gtk-find", "actions/find.png"); - stream << doIconMapping("gtk-find-and-replace", "actions/gtk-find-and-replace.png"); + stream << doIconMapping("gtk-tqfind", "actions/find.png"); + stream << doIconMapping("gtk-tqfind-and-tqreplace", "actions/gtk-tqfind-and-tqreplace.png"); stream << doIconMapping("gtk-floppy", "devices/3floppy_unmount.png"); stream << doIconMapping("gtk-fullscreen", "actions/gtk-fullscreen.png"); stream << doIconMapping("gtk-goto-bottom", "actions/bottom.png"); @@ -2125,58 +2125,58 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate) gtk_rc_add_default_file(cacheFilePath.latin1()); } -void addIconThemeDir(const QString& theme) +void addIconThemeDir(const TQString& theme) { // Try to find this theme's directory - QString icondir = kdeFindDir("/share/icons/" + theme + "/", "index.theme", "index.desktop"); + TQString icondir = kdeFindDir("/share/icons/" + theme + "/", "index.theme", "index.desktop"); if(icondir.isEmpty()) return; - if (iconThemeDirs.contains(icondir)) + if (iconThemeDirs.tqcontains(icondir)) return; // Add this theme to the list iconThemeDirs.append(icondir); - // Do it again for any parent themes - QStringList parents = iconInheritsDirs(icondir); - for ( QStringList::Iterator it=parents.begin() ; it!=parents.end(); ++it) + // Do it again for any tqparent themes + TQStringList tqparents = iconInheritsDirs(icondir); + for ( TQStringList::Iterator it=tqparents.begin() ; it!=tqparents.end(); ++it) addIconThemeDir((*it).stripWhiteSpace()); } void setMenuBackground(GtkStyle* style) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if (menuBackgroundPixmap == NULL) { // Get the menu background image - menuBackgroundPixmap = new QPixmap(1024, 25); // Meh - QPainter painter(menuBackgroundPixmap); - QPopupMenu pm; - QMenuData md; - QMenuItem* mi = md.findItem(md.insertItem("")); + menuBackgroundPixmap = new TQPixmap(1024, 25); // Meh + TQPainter painter(menuBackgroundPixmap); + TQPopupMenu pm; + TQMenuData md; + TQMenuItem* mi = md.tqfindItem(md.insertItem("")); - qApp->style().polish(&pm); + tqApp->tqstyle().polish(&pm); - QStyleOption opt(mi, 16, 16); - QStyle::SFlags sflags = QStyle::Style_Default; + TQStyleOption opt(mi, 16, 16); + TQStyle::SFlags sflags = TQStyle::Style_Default; if ((backgroundTile) && (!backgroundTile->isNull())) - painter.fillRect(0, 0, 1024, 25, QBrush(QColor(255,255,255), *backgroundTile)); + painter.fillRect(0, 0, 1024, 25, TQBrush(TQColor(255,255,255), *backgroundTile)); else - painter.fillRect(0, 0, 1024, 25, qApp->palette().active().brush(QColorGroup::Background)); - qApp->style().drawControl(QStyle::CE_PopupMenuItem, &painter, &pm, QRect(0,0,1024,25), qApp->palette().active(), sflags, opt); + painter.fillRect(0, 0, 1024, 25, tqApp->tqpalette().active().brush(TQColorGroup::Background)); + tqApp->tqstyle().tqdrawControl(TQStyle::CE_PopupMenuItem, &painter, &pm, TQRect(0,0,1024,25), tqApp->tqpalette().active(), sflags, opt); menuBackgroundPixmapGdk = gdk_pixmap_foreign_new(menuBackgroundPixmap->handle()); } - QTENGINE_STYLE(style)->menuBackground = menuBackgroundPixmapGdk; + TQTENGINE_STYLE(style)->menuBackground = menuBackgroundPixmapGdk; g_object_ref(menuBackgroundPixmapGdk); } // It has a 'u' damnit -void setColour(GdkColor* g, QColor q) +void setColour(GdkColor* g, TQColor q) { g->red = q.red() * 257; g->green = q.green() * 257; @@ -2185,10 +2185,10 @@ void setColour(GdkColor* g, QColor q) void setColors(GtkStyle* style) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; - if (gtkQtDebug) + if (gtkTQtDebug) printf("setColors()\n"); /*gtkStyle = style;*/ @@ -2206,13 +2206,13 @@ void setColors(GtkStyle* style) void getTextColor(GdkColor *color, GtkStateType state_type) { - if (!gtkQtEnable) + if (!gtkTQtEnable) return; if ((state_type == GTK_STATE_PRELIGHT) || (state_type == GTK_STATE_ACTIVE) || (state_type == GTK_STATE_SELECTED)) - setColour(color, qApp->palette().active().highlightedText()); + setColour(color, tqApp->tqpalette().active().highlightedText()); else if (state_type == GTK_STATE_NORMAL) - setColour(color, qApp->palette().active().text()); + setColour(color, tqApp->tqpalette().active().text()); else if (state_type == GTK_STATE_INSENSITIVE) - setColour(color, qApp->palette().disabled().text()); + setColour(color, tqApp->tqpalette().disabled().text()); } diff --git a/src/qt_qt_wrapper.h b/src/qt_qt_wrapper.h index d07ff9d..743f463 100644 --- a/src/qt_qt_wrapper.h +++ b/src/qt_qt_wrapper.h @@ -1,5 +1,5 @@ -#ifndef QTENGINE_QT_WRAPPER_H -#define QTENGINE_QT_WRAPPER_H +#ifndef TQTENGINE_TQT_WRAPPER_H +#define TQTENGINE_TQT_WRAPPER_H #include @@ -10,20 +10,20 @@ #ifdef __cplusplus extern "C" { -void mapColour(GdkColor* g, QColor q); -void addIconThemeDir(const QString& theme); -QString doIconMapping(const QString& stockName, const QString& path, int sizes = 7); +void mapColour(GdkColor* g, TQColor q); +void addIconThemeDir(const TQString& theme); +TQString doIconMapping(const TQString& stockName, const TQString& path, int sizes = 7); void initKdeSettings(); -QString kdeConfigValue(const QString& section, const QString& name, const QString& def); -QString kdeFindDir(const QString& suffix, const QString& file1, const QString& file2); +TQString kdeConfigValue(const TQString& section, const TQString& name, const TQString& def); +TQString kdeFindDir(const TQString& suffix, const TQString& file1, const TQString& file2); GdkFilterReturn gdkEventFilter(GdkXEvent *xevent, GdkEvent *event, gpointer data); #endif -void createQApp(); -void destroyQApp(); +void createTQApp(); +void destroyTQApp(); void setColors(GtkStyle* style); void setRcProperties(GtkRcStyle* rc_style, int forceRecreate); void drawButton(GdkWindow * window, GtkStyle * style, GtkStateType state, int defaultButton, int x, int y, int w, int h); @@ -70,7 +70,7 @@ extern int isAlloy; extern int isDomino; extern int isPolyester; extern int openOfficeFix; -extern int gtkQtDebug; +extern int gtkTQtDebug; #ifdef __cplusplus } diff --git a/src/qt_rc_style.c b/src/qt_rc_style.c index 0a9947a..ba03a7f 100644 --- a/src/qt_rc_style.c +++ b/src/qt_rc_style.c @@ -4,8 +4,8 @@ -static void qtengine_rc_style_init (QtEngineRcStyle *style); -static void qtengine_rc_style_class_init (QtEngineRcStyleClass *klass); +static void qtengine_rc_style_init (TQtEngineRcStyle *style); +static void qtengine_rc_style_class_init (TQtEngineRcStyleClass *klass); static void qtengine_rc_style_finalize (GObject *object); static guint qtengine_rc_style_parse (GtkRcStyle *rc_style, GtkSettings *settings, @@ -15,7 +15,7 @@ static void qtengine_rc_style_merge (GtkRcStyle *dest, static GtkStyle *qtengine_rc_style_create_style (GtkRcStyle *rc_style); -static GtkRcStyleClass *parent_class; +static GtkRcStyleClass *tqparent_class; GType qtengine_type_rc_style = 0; @@ -24,30 +24,30 @@ void qtengine_rc_style_register_type (GTypeModule *module) { static const GTypeInfo object_info = { - sizeof (QtEngineRcStyleClass), + sizeof (TQtEngineRcStyleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) qtengine_rc_style_class_init, NULL, /* class_finalize */ NULL, /* class_data */ - sizeof (QtEngineRcStyle), + sizeof (TQtEngineRcStyle), 0, /* n_preallocs */ (GInstanceInitFunc) qtengine_rc_style_init, }; - qtengine_type_rc_style = g_type_module_register_type (module, GTK_TYPE_RC_STYLE, "QtEngineRcStyle", &object_info, 0); + qtengine_type_rc_style = g_type_module_register_type (module, GTK_TYPE_RC_STYLE, "TQtEngineRcStyle", &object_info, 0); } -static void qtengine_rc_style_init (QtEngineRcStyle *style) +static void qtengine_rc_style_init (TQtEngineRcStyle *style) { } -static void qtengine_rc_style_class_init (QtEngineRcStyleClass *klass) +static void qtengine_rc_style_class_init (TQtEngineRcStyleClass *klass) { GtkRcStyleClass *rc_style_class = GTK_RC_STYLE_CLASS (klass); GObjectClass *object_class = G_OBJECT_CLASS (klass); - parent_class = g_type_class_peek_parent (klass); + tqparent_class = g_type_class_peek_parent (klass); rc_style_class->parse = qtengine_rc_style_parse; rc_style_class->merge = qtengine_rc_style_merge; @@ -88,7 +88,7 @@ static void qtengine_rc_style_merge (GtkRcStyle * dest, GtkRcStyle * src) { - parent_class->merge(dest, src); + tqparent_class->merge(dest, src); } /* Create an empty style suitable to this RC style @@ -96,6 +96,6 @@ qtengine_rc_style_merge (GtkRcStyle * dest, static GtkStyle * qtengine_rc_style_create_style (GtkRcStyle *rc_style) { - void *ptr = GTK_STYLE (g_object_new (QTENGINE_TYPE_STYLE, NULL)); + void *ptr = GTK_STYLE (g_object_new (TQTENGINE_TYPE_STYLE, NULL)); return (GtkStyle *)ptr; } diff --git a/src/qt_rc_style.h b/src/qt_rc_style.h index 5235f09..e88a167 100644 --- a/src/qt_rc_style.h +++ b/src/qt_rc_style.h @@ -1,25 +1,25 @@ #include -typedef struct _QtEngineRcStyle QtEngineRcStyle; -typedef struct _QtEngineRcStyleClass QtEngineRcStyleClass; +typedef struct _TQtEngineRcStyle TQtEngineRcStyle; +typedef struct _TQtEngineRcStyleClass TQtEngineRcStyleClass; extern GType qtengine_type_rc_style; -#define QTENGINE_TYPE_RC_STYLE qtengine_type_rc_style -#define QTENGINE_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), QTENGINE_TYPE_RC_STYLE, QtEngineRcStyle)) -#define QTENGINE_RC_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), QTENGINE_TYPE_RC_STYLE, QtEngineRcStyleClass)) -#define QTENGINE_IS_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), QTENGINE_TYPE_RC_STYLE)) -#define QTENGINE_IS_RC_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), QTENGINE_TYPE_RC_STYLE)) -#define QTENGINE_RC_STYLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), QTENGINE_TYPE_RC_STYLE, QtEngineRcStyleClass)) +#define TQTENGINE_TYPE_RC_STYLE qtengine_type_rc_style +#define TQTENGINE_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), TQTENGINE_TYPE_RC_STYLE, TQtEngineRcStyle)) +#define TQTENGINE_RC_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TQTENGINE_TYPE_RC_STYLE, TQtEngineRcStyleClass)) +#define TQTENGINE_IS_RC_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), TQTENGINE_TYPE_RC_STYLE)) +#define TQTENGINE_IS_RC_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TQTENGINE_TYPE_RC_STYLE)) +#define TQTENGINE_RC_STYLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TQTENGINE_TYPE_RC_STYLE, TQtEngineRcStyleClass)) -struct _QtEngineRcStyle +struct _TQtEngineRcStyle { - GtkRcStyle parent_instance; + GtkRcStyle tqparent_instance; }; -struct _QtEngineRcStyleClass +struct _TQtEngineRcStyleClass { - GtkRcStyleClass parent_class; + GtkRcStyleClass tqparent_class; }; void qtengine_rc_style_register_type (GTypeModule *module); diff --git a/src/qt_style.h b/src/qt_style.h index 4a4bc78..425215f 100644 --- a/src/qt_style.h +++ b/src/qt_style.h @@ -1,27 +1,27 @@ #include -typedef struct _QtEngineStyle QtEngineStyle; -typedef struct _QtEngineStyleClass QtEngineStyleClass; +typedef struct _TQtEngineStyle TQtEngineStyle; +typedef struct _TQtEngineStyleClass TQtEngineStyleClass; extern GType qtengine_type_style; -#define QTENGINE_TYPE_STYLE qtengine_type_style -#define QTENGINE_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), QTENGINE_TYPE_STYLE, QtEngineStyle)) -#define QTENGINE_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), QTENGINE_TYPE_STYLE, QtEngineStyleClass)) -#define QTENGINE_IS_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), QTENGINE_TYPE_STYLE)) -#define QTENGINE_IS_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), QTENGINE_TYPE_STYLE)) -#define QTENGINE_STYLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), QTENGINE_TYPE_STYLE, QtEngineStyleClass)) +#define TQTENGINE_TYPE_STYLE qtengine_type_style +#define TQTENGINE_STYLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), TQTENGINE_TYPE_STYLE, TQtEngineStyle)) +#define TQTENGINE_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TQTENGINE_TYPE_STYLE, TQtEngineStyleClass)) +#define TQTENGINE_IS_STYLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), TQTENGINE_TYPE_STYLE)) +#define TQTENGINE_IS_STYLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TQTENGINE_TYPE_STYLE)) +#define TQTENGINE_STYLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TQTENGINE_TYPE_STYLE, TQtEngineStyleClass)) -struct _QtEngineStyle +struct _TQtEngineStyle { - GtkStyle parent_instance; + GtkStyle tqparent_instance; GdkPixmap* menuBackground; }; -struct _QtEngineStyleClass +struct _TQtEngineStyleClass { - GtkStyleClass parent_class; + GtkStyleClass tqparent_class; }; void qtengine_style_register_type (GTypeModule *module); diff --git a/src/qt_theme_draw.c b/src/qt_theme_draw.c index c67016c..49a63ab 100644 --- a/src/qt_theme_draw.c +++ b/src/qt_theme_draw.c @@ -18,7 +18,7 @@ #define DETAIL(xx) ((detail) && (!strcmp(xx, detail))) #define DETAILHAS(xx) ((detail) && (strstr(detail, xx))) -#define PARENT(xx) ((parent) && (!strcmp(xx, gtk_widget_get_name(parent)))) +#define PARENT(xx) ((tqparent) && (!strcmp(xx, gtk_widget_get_name(tqparent)))) #ifndef max #define max(x,y) ((x)>=(y)?(x):(y)) #endif @@ -26,17 +26,17 @@ #define min(x,y) ((x)<=(y)?(x):(y)) #endif -static void qtengine_style_init (QtEngineStyle *style); -static void qtengine_style_class_init (QtEngineStyleClass *klass); +static void qtengine_style_init (TQtEngineStyle *style); +static void qtengine_style_class_init (TQtEngineStyleClass *klass); static GtkNotebook *notebook = NULL; static int nb_num_pages = 0; -static GtkStyleClass *parent_class = NULL; +static GtkStyleClass *tqparent_class = NULL; static PangoLayout* get_insensitive_layout (GdkDrawable *drawable, - PangoLayout *layout); + PangoLayout *tqlayout); static GtkShadowType @@ -81,7 +81,7 @@ draw_hline(GtkStyle* style, gint x2, gint y) { - if (gtkQtDebug) + if (gtkTQtDebug) printf("HLINE (%d,%d,%d) Widget: %s Detail: %s\n",x1,y1,y,gtk_widget_get_name(widget),detail); if (DETAIL("vscale")) @@ -102,7 +102,7 @@ draw_vline(GtkStyle* style, gint yDest, gint x) { - if (gtkQtDebug) + if (gtkTQtDebug) printf("VLINE (%d,%d,%d) Widget: %s Detail: %s\n",ySource ,yDest ,x,gtk_widget_get_name(widget),detail); @@ -135,7 +135,7 @@ draw_shadow(GtkStyle *style, sanitize_size(window, &width, &height); - if (gtkQtDebug) + if (gtkTQtDebug) printf("Shadow (%d,%d,%d,%d) Widget: %s Detail: %s\n",x,y,width,height,gtk_widget_get_name(widget),detail); @@ -159,9 +159,9 @@ draw_shadow(GtkStyle *style, } /* The remainder of this function was borrowed from the "Metal" theme/ - I don't really want to use Qt to draw these frames as there are too + I don't really want to use TQt to draw these frames as there are too many of them (it would slow down the theme engine even more). - TODO: Make them use the Qt color palette */ + TODO: Make them use the TQt color palette */ switch (shadow_type) { @@ -459,7 +459,7 @@ draw_arrow(GtkStyle* style, { sanitize_size(window, &width, &height); - if (gtkQtDebug) + if (gtkTQtDebug) printf("Arrow (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail); if (DETAIL("hscrollbar") || DETAIL("vscrollbar")) @@ -474,7 +474,7 @@ draw_arrow(GtkStyle* style, if (DETAIL("arrow")) { GdkPixbuf *gpix; - GtkWidget* parent; + GtkWidget* tqparent; if (gdk_window_is_viewable(gtk_widget_get_parent_window(widget))) { gpix = gdk_pixbuf_get_from_drawable(NULL, gtk_widget_get_parent_window(widget),NULL, x, y, 0, 0, width, height); @@ -482,8 +482,8 @@ draw_arrow(GtkStyle* style, g_object_unref(gpix); } - parent = gtk_widget_get_parent(widget); - drawArrow(window,style, GTK_WIDGET_STATE(parent), arrow_type, x, y, width, height); + tqparent = gtk_widget_get_parent(widget); + drawArrow(window,style, GTK_WIDGET_STATE(tqparent), arrow_type, x, y, width, height); return; } /* if (DETAIL("menuitem")) @@ -531,7 +531,7 @@ draw_arrow(GtkStyle* style, ay = y; aw = width; ah = height; - calculate_arrow_geometry (arrow_type, &ax, &ay, &aw, &ah); + calculate_arrow_tqgeometry (arrow_type, &ax, &ay, &aw, &ah); half_width = width / 2; half_height = height / 2; @@ -615,7 +615,7 @@ draw_box(GtkStyle * style, int nbpages; sanitize_size(window, &width, &height); - if (gtkQtDebug) + if (gtkTQtDebug) printf("Box (%d,%d,%d,%d) Widget: %s Detail: %s\n",x,y,width,height,gtk_widget_get_name(widget),detail); if (GTK_IS_SCROLLBAR(widget)) @@ -641,7 +641,7 @@ draw_box(GtkStyle * style, if (DETAIL("menubar")) { if (openOfficeFix == 1) - parent_class->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height); + tqparent_class->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height); else drawMenubar(window,style,state_type,x,y,width,height); return; @@ -649,7 +649,7 @@ draw_box(GtkStyle * style, if (DETAIL("menu")) { if (openOfficeFix == 1) - parent_class->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height); + tqparent_class->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height); else { if ((x >= 0) && (y >= 0)) /* Work around weirdness in firefox */ @@ -700,11 +700,11 @@ draw_box(GtkStyle * style, } if (DETAIL("button")) { - GtkWidget *parent; + GtkWidget *tqparent; int toolbutton = 0; - parent = gtk_widget_get_parent(widget); + tqparent = gtk_widget_get_parent(widget); - if (parent && (GTK_IS_CLIST(parent) || GTK_IS_LIST(parent) || GTK_IS_TREE_VIEW(parent))) + if (tqparent && (GTK_IS_CLIST(tqparent) || GTK_IS_LIST(tqparent) || GTK_IS_TREE_VIEW(tqparent))) { drawListHeader(window,style,state_type,x,y,width,height); return; @@ -714,12 +714,12 @@ draw_box(GtkStyle * style, * toolbar in gtk */ while (1) { - if (GTK_IS_WIDGET(parent)) + if (GTK_IS_WIDGET(tqparent)) { #ifdef HAVE_BONOBO - if (GTK_IS_TOOLBAR(parent) || BONOBO_IS_UI_TOOLBAR(parent)) + if (GTK_IS_TOOLBAR(tqparent) || BONOBO_IS_UI_TOOLBAR(tqparent)) #else - if (GTK_IS_TOOLBAR(parent)) + if (GTK_IS_TOOLBAR(tqparent)) #endif { toolbutton = 1; @@ -728,10 +728,10 @@ draw_box(GtkStyle * style, } else break; - parent = gtk_widget_get_parent(parent); + tqparent = gtk_widget_get_parent(tqparent); } - parent = gtk_widget_get_parent(widget); + tqparent = gtk_widget_get_parent(widget); if (toolbutton) drawToolButton(window,style,state_type,x,y,width,height); @@ -744,9 +744,9 @@ draw_box(GtkStyle * style, int defaultButton = GTK_WIDGET_HAS_FOCUS(widget); GtkWindow* toplevel; - if (isBaghira && GTK_IS_BOX(parent) && (g_list_length(GTK_BOX(parent)->children) == 2)) + if (isBaghira && GTK_IS_BOX(tqparent) && (g_list_length(GTK_BOX(tqparent)->children) == 2)) { - child1 = g_list_first((GTK_BOX(parent)->children)); + child1 = g_list_first((GTK_BOX(tqparent)->children)); child = ((GtkBoxChild *)child1->data)->widget; if (GTK_IS_ENTRY(child)) { @@ -754,7 +754,7 @@ draw_box(GtkStyle * style, return; } - child1 = g_list_last((GTK_BOX(parent)->children)); + child1 = g_list_last((GTK_BOX(tqparent)->children)); child = ((GtkBoxChild *)child1->data)->widget; if (GTK_IS_ENTRY(child)) { @@ -781,9 +781,9 @@ draw_box(GtkStyle * style, /* THIS IS WHAT WORKS NOW -- Tabs and tabbarbase will be drawn properly according to the QT style But the tabs won't be aligned according to QT. GTK+ does not have - an option for alignment of tabs. So if were to do this not only do we have to - calculate the x,y position of the tab ourselves, which is difficult in Qt unless - we are displaying the tab (can be done by subclassing QTabBar/QTabWidget) + an option for tqalignment of tabs. So if were to do this not only do we have to + calculate the x,y position of the tab ourselves, which is difficult in TQt unless + we are displaying the tab (can be done by subclassing TQTabBar/TQTabWidget) but also have to position the tab bar label ourselves in gtk. */ @@ -811,7 +811,7 @@ draw_box(GtkStyle * style, if (DETAIL("toolbar")) { if (openOfficeFix == 1) - parent_class->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height); + tqparent_class->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height); else drawToolbar(window,style,state_type,x,y,width,height); return; @@ -852,24 +852,24 @@ draw_flat_box(GtkStyle * style, { sanitize_size(window, &width, &height); - if (gtkQtDebug) + if (gtkTQtDebug) printf("Flat Box (%d,%d,%d,%d) Widget: %s Detail: %s %d %d\n",x,y,width,height,gtk_widget_get_name(widget),detail, state_type, GTK_STATE_SELECTED); if (DETAIL("tooltip")) { GdkColor tooltipColor; GdkGCValues gc_values; - GdkGCValuesMask gc_values_mask; + GdkGCValuesMask gc_values_tqmask; GdkGC* tooltipGc; tooltipColor.red = 255*257; tooltipColor.green = 255*257; tooltipColor.blue = 220*257; gdk_colormap_alloc_color(style->colormap, &tooltipColor, FALSE, TRUE); - gc_values_mask = GDK_GC_FOREGROUND; + gc_values_tqmask = GDK_GC_FOREGROUND; gc_values.foreground = tooltipColor; - tooltipGc = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + tooltipGc = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); gdk_draw_rectangle(window, tooltipGc, TRUE, x, y, width, height); gdk_draw_rectangle(window, style->black_gc, FALSE, x, y, width - 1, height - 1); @@ -908,7 +908,7 @@ draw_check(GtkStyle * style, gint width, gint height) { - if (gtkQtDebug) + if (gtkTQtDebug) printf("Check (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail); if (GTK_IS_MENU_ITEM(widget)) @@ -945,7 +945,7 @@ draw_option(GtkStyle * style, gint width, gint height) { - if (gtkQtDebug) + if (gtkTQtDebug) printf("Option (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail); if (gdk_window_is_viewable(gtk_widget_get_parent_window(widget))) @@ -979,7 +979,7 @@ draw_tab(GtkStyle * style, gint width, gint height) { - if (gtkQtDebug) + if (gtkTQtDebug) printf("Tab (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail); gtk_paint_box(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height); @@ -1011,7 +1011,7 @@ draw_shadow_gap(GtkStyle * style, sanitize_size (window, &width, &height); shadow_type = get_shadow_type (style, detail, shadow_type); - if (gtkQtDebug) + if (gtkTQtDebug) printf("Shadow_Gap (%d,%d,%d,%d) Widget: %s Detail: %s\n",x,y,width,height,gtk_widget_get_name(widget),detail); switch (shadow_type) { @@ -1154,7 +1154,7 @@ draw_box_gap(GtkStyle* style, if (width<0 || height<0) return; /* Eclipse really can be this stupid! */ - if (gtkQtDebug) + if (gtkTQtDebug) printf("Box_gap (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail); if (DETAIL("notebook")) @@ -1181,7 +1181,7 @@ draw_extension(GtkStyle * style, sanitize_size (window, &width, &height); - if (gtkQtDebug) + if (gtkTQtDebug) printf("Extension (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail); gtk_paint_box(style, window, state_type, shadow_type, area, widget, detail, @@ -1201,14 +1201,14 @@ draw_focus (GtkStyle *style, gint width, gint height) { - if (gtkQtDebug) + if (gtkTQtDebug) printf("Focus Rect (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail); - GtkWidget* parent = gtk_widget_get_parent(widget); + GtkWidget* tqparent = gtk_widget_get_parent(widget); if (GTK_IS_CHECK_BUTTON(widget) || GTK_IS_RADIO_BUTTON(widget) || - (parent && (GTK_IS_CLIST(parent) || GTK_IS_LIST(parent) || GTK_IS_TREE_VIEW(parent)))) + (tqparent && (GTK_IS_CLIST(tqparent) || GTK_IS_LIST(tqparent) || GTK_IS_TREE_VIEW(tqparent)))) { drawFocusRect(window, style, x, y, width, height); } @@ -1229,7 +1229,7 @@ draw_slider(GtkStyle * style, gint height, GtkOrientation orientation) { - if (gtkQtDebug) + if (gtkTQtDebug) printf("Slider (%d,%d,%d,%d) Widget: %s Detail: %s\n", x, y, width, height,gtk_widget_get_name(widget),detail); if (DETAIL("slider")) @@ -1237,11 +1237,11 @@ draw_slider(GtkStyle * style, GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(widget)); int widgetX, widgetY; - GtkWidget* parent = widget; - while (gtk_widget_get_parent(parent) != NULL) - parent = gtk_widget_get_parent(parent); + GtkWidget* tqparent = widget; + while (gtk_widget_get_parent(tqparent) != NULL) + tqparent = gtk_widget_get_parent(tqparent); - gtk_widget_translate_coordinates(widget, parent, 0, 0, &widgetX, &widgetY); + gtk_widget_translate_coordinates(widget, tqparent, 0, 0, &widgetX, &widgetY); if (orientation == GTK_ORIENTATION_VERTICAL) drawScrollBarSlider(window, style, state_type, orientation, adj, x-1, y, width+2, height, y-widgetY, widget->allocation.height); @@ -1270,7 +1270,7 @@ draw_handle(GtkStyle * style, sanitize_size(window, &width, &height); - if (gtkQtDebug) + if (gtkTQtDebug) printf("Handle (%d,%d,%d,%d) Widget: %s Detail: %s \n",x,y,width,height,gtk_widget_get_name(widget),detail, state_type); drawSplitter(window,style,state_type,orientation,x,y,width,height); @@ -1287,33 +1287,33 @@ void draw_layout (GtkStyle *style, const gchar *detail, gint x, gint y, - PangoLayout *layout) + PangoLayout *tqlayout) { GdkColor color; GdkGC *gc; getTextColor(&color, state_type); - if (gtkQtDebug) + if (gtkTQtDebug) printf("Layout (%d,%d) Widget: %s Detail: %s %d \n",x,y,gtk_widget_get_name(widget),detail, state_type); if (DETAIL("accellabel") || DETAIL("label") || DETAIL("cellrenderertext")) { - GtkWidget* parent = gtk_widget_get_parent(widget); - GtkWidget* parent1 = gtk_widget_get_parent(parent); + GtkWidget* tqparent = gtk_widget_get_parent(widget); + GtkWidget* tqparent1 = gtk_widget_get_parent(tqparent); - /* printf("parent's names are %s->%s->%s\n", gtk_widget_get_name(widget), gtk_widget_get_name(parent), gtk_widget_get_name(parent1)); */ + /* printf("tqparent's names are %s->%s->%s\n", gtk_widget_get_name(widget), gtk_widget_get_name(tqparent), gtk_widget_get_name(tqparent1)); */ /* In baghira -- even highlight the menu bar items */ - if ((GTK_IS_MENU_ITEM(parent) && (!GTK_IS_MENU_BAR(parent1) || isBaghira || isPolyester)) || GTK_IS_TREE_VIEW(widget)) + if ((GTK_IS_MENU_ITEM(tqparent) && (!GTK_IS_MENU_BAR(tqparent1) || isBaghira || isPolyester)) || GTK_IS_TREE_VIEW(widget)) { - PangoAttrList *layoutattr; + PangoAttrList *tqlayoutattr; const gchar *text; gint text_length = 0; gint text_bytelen = 0; - text = pango_layout_get_text (layout); + text = pango_layout_get_text (tqlayout); if (text != 0) { PangoAttribute *textcolorattr; @@ -1324,19 +1324,19 @@ void draw_layout (GtkStyle *style, textcolorattr->start_index = 0; textcolorattr->end_index = text_bytelen; - layoutattr = pango_layout_get_attributes(layout); + tqlayoutattr = pango_layout_get_attributes(tqlayout); - if (layoutattr == NULL) + if (tqlayoutattr == NULL) { - layoutattr = pango_attr_list_new(); - pango_attr_list_insert(layoutattr, pango_attribute_copy(textcolorattr)); - pango_layout_set_attributes(layout,layoutattr); - pango_attr_list_unref(layoutattr); + tqlayoutattr = pango_attr_list_new(); + pango_attr_list_insert(tqlayoutattr, pango_attribute_copy(textcolorattr)); + pango_layout_set_attributes(tqlayout,tqlayoutattr); + pango_attr_list_unref(tqlayoutattr); } else { - pango_attr_list_change(layoutattr, pango_attribute_copy(textcolorattr)); - pango_layout_set_attributes(layout,layoutattr); + pango_attr_list_change(tqlayoutattr, pango_attribute_copy(textcolorattr)); + pango_layout_set_attributes(tqlayout,tqlayoutattr); } pango_attribute_destroy(textcolorattr); } @@ -1355,13 +1355,13 @@ void draw_layout (GtkStyle *style, if (state_type == GTK_STATE_INSENSITIVE) { PangoLayout *ins; - ins = get_insensitive_layout (window, layout); + ins = get_insensitive_layout (window, tqlayout); gdk_draw_layout (window, gc, x, y, ins); g_object_unref (ins); } else { - gdk_draw_layout (window, gc, x, y, layout); + gdk_draw_layout (window, gc, x, y, tqlayout); } if (area) @@ -1390,7 +1390,7 @@ range_new (guint start, static PangoLayout* get_insensitive_layout (GdkDrawable *drawable, - PangoLayout *layout) + PangoLayout *tqlayout) { GSList *embossed_ranges = NULL; GSList *stippled_ranges = NULL; @@ -1400,7 +1400,7 @@ get_insensitive_layout (GdkDrawable *drawable, PangoAttrList *attrs; GdkBitmap *stipple = NULL; - iter = pango_layout_get_iter (layout); + iter = pango_layout_get_iter (tqlayout); do { @@ -1447,7 +1447,7 @@ get_insensitive_layout (GdkDrawable *drawable, pango_layout_iter_free (iter); - new_layout = pango_layout_copy (layout); + new_layout = pango_layout_copy (tqlayout); attrs = pango_layout_get_attributes (new_layout); @@ -1526,25 +1526,25 @@ qtengine_style_register_type (GTypeModule *module) { static const GTypeInfo object_info = { - sizeof (QtEngineStyleClass), + sizeof (TQtEngineStyleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) qtengine_style_class_init, NULL, /* class_finalize */ NULL, /* class_data */ - sizeof (QtEngineStyle), + sizeof (TQtEngineStyle), 0, /* n_preallocs */ (GInstanceInitFunc) qtengine_style_init, }; qtengine_type_style = g_type_module_register_type (module, GTK_TYPE_STYLE, - "QtEngineStyle", + "TQtEngineStyle", &object_info, 0); } static void -qtengine_style_init (QtEngineStyle *style) +qtengine_style_init (TQtEngineStyle *style) { } @@ -1743,7 +1743,7 @@ static void gtk_style_real_realize (GtkStyle *style) { GdkGCValues gc_values; - GdkGCValuesMask gc_values_mask; + GdkGCValuesMask gc_values_tqmask; gint i; @@ -1771,13 +1771,13 @@ gtk_style_real_realize (GtkStyle *style) style->white.blue = 0xffff; gdk_colormap_alloc_color (style->colormap, &style->white, FALSE, TRUE); - gc_values_mask = GDK_GC_FOREGROUND; + gc_values_tqmask = GDK_GC_FOREGROUND; gc_values.foreground = style->black; - style->black_gc = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->black_gc = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); gc_values.foreground = style->white; - style->white_gc = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->white_gc = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); for (i = 0; i < 5; i++) { @@ -1808,28 +1808,28 @@ gtk_style_real_realize (GtkStyle *style) style->text_aa[i].red, style->text_aa[i].green, style->text_aa[i].blue); gc_values.foreground = style->fg[i]; - style->fg_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->fg_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); gc_values.foreground = style->bg[i]; - style->bg_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->bg_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); gc_values.foreground = style->light[i]; - style->light_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->light_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); gc_values.foreground = style->dark[i]; - style->dark_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->dark_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); gc_values.foreground = style->mid[i]; - style->mid_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->mid_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); gc_values.foreground = style->text[i]; - style->text_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->text_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); gc_values.foreground = style->base[i]; - style->base_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->base_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); gc_values.foreground = style->text_aa[i]; - style->text_aa_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask); + style->text_aa_gc[i] = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask); } } @@ -1845,15 +1845,15 @@ static void set_background (GtkStyle *style, GdkWindow *window, GtkStateType state_type) { GdkPixmap *pixmap; - gint parent_relative; + gint tqparent_relative; GdkPixmap* pix_test; /* What kind of horrible person would store a pointer to a widget here... */ - void* parent = 0; - gdk_window_get_user_data(window, &parent); - if (GTK_IS_MENU((GtkWidget*) parent)) + void* tqparent = 0; + gdk_window_get_user_data(window, &tqparent); + if (GTK_IS_MENU((GtkWidget*) tqparent)) { - pix_test = QTENGINE_STYLE(style)->menuBackground; + pix_test = TQTENGINE_STYLE(style)->menuBackground; } else pix_test = style->bg_pixmap[state_type]; @@ -1863,28 +1863,28 @@ set_background (GtkStyle *style, GdkWindow *window, GtkStateType state_type) if (pix_test == (GdkPixmap*) GDK_PARENT_RELATIVE) { pixmap = NULL; - parent_relative = TRUE; + tqparent_relative = TRUE; } else { pixmap = pix_test; - parent_relative = FALSE; + tqparent_relative = FALSE; gdk_drawable_set_colormap(pixmap, style->colormap); } if (pixmap && !gdk_drawable_get_colormap (pixmap)) gdk_drawable_set_colormap (pixmap, gdk_drawable_get_colormap (window)); - gdk_window_set_back_pixmap (window, pixmap, parent_relative); + gdk_window_set_back_pixmap (window, pixmap, tqparent_relative); } else gdk_window_set_background (window, &style->bg[state_type]); } static void -qtengine_style_class_init (QtEngineStyleClass *klass) +qtengine_style_class_init (TQtEngineStyleClass *klass) { GtkStyleClass *style_class = GTK_STYLE_CLASS (klass); - parent_class = g_type_class_peek_parent (klass); + tqparent_class = g_type_class_peek_parent (klass); style_class->draw_hline = draw_hline; style_class->draw_vline = draw_vline; -- cgit v1.2.1