TDE
/
gtk3-tqt-engine
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/gtk3-tqt-engine
0
0
Fork 0
Code Issues Releases Wiki Activity

Quite a few widgets now work

Browse Source
pull/1/head
Timothy Pearson 12 years ago
parent d53bb73349
commit b2d6cebbfd
2 changed files with 561 additions and 164 deletions
Show Stats Download Patch File Download Diff File

659
tdegtk/tdegtk-draw.cpp
Unescape View File

@ -26,6 +26,7 @@
#include <tqpainter.h>
#include <tqstyle.h>
#include <tqpopupmenu.h>
#include <tqlistview.h>
#include <kiconloader.h>
#include <kicontheme.h>
@ -319,8 +320,6 @@ tdegtk_draw_arrow (GtkThemingEngine *engine,
TQt3CairoPaintDevice pd(NULL, x, y, size, size, cr);
TQPainter p(&pd);
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,0,255);
GtkStateFlags state;
state = gtk_theming_engine_get_state(engine);
@ -427,54 +426,102 @@ static void
tdegtk_draw_cell_background (DRAW_ARGS,
GtkRegionFlags flags)
{
GtkJunctionSides junction;
guint hidden_side;
TQRect boundingRect(0, 0, width, height);
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
junction = (GtkJunctionSides)(GTK_JUNCTION_RIGHT | GTK_JUNCTION_LEFT);
const GtkWidgetPath* path;
GtkStateFlags state;
GtkWidget* widget;
hidden_side = SIDE_RIGHT | SIDE_LEFT;
path = gtk_theming_engine_get_path(engine);
state = gtk_theming_engine_get_state(engine);
widget = m_widgetLookup.find(cr, path);
if ((flags & GTK_REGION_FIRST) != 0)
{
junction = (GtkJunctionSides)(junction & ~(GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMLEFT));
hidden_side &= ~(SIDE_LEFT);
}
if ((flags & GTK_REGION_LAST) != 0)
{
junction = (GtkJunctionSides)(junction & ~(GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMRIGHT));
hidden_side &= ~(SIDE_RIGHT);
}
if (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW)) {
TQStringList objectTypes;
objectTypes.append(TQLISTVIEW_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
tdegtk_cairo_draw_background (engine, cr,
x, y, width, height,
hidden_side, junction);
TQStyleControlElementData ceData;
TQStyle::ControlElementFlags elementFlags;
ceData.widgetObjectTypes = objectTypes;
ceData.rect = boundingRect;
if ((state & GTK_STATE_FLAG_SELECTED) != 0) {
ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Highlight);
}
else {
ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Base);
}
TQListViewItem tqt3ListViewItem;
TQStyleOption listViewItemOpt(&tqt3ListViewItem);
TQRect paintDeviceRect;
TQRect backgroundRect;
// Draw item
tqApp->style().drawComplexControl(TQStyle::CC_ListView, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE), TQStyle::SC_ListView, TQStyle::SC_All, listViewItemOpt);
}
else {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,128,64);
printf("[WARNING] tdegtk_draw_cell_background() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
}
p.end();
}
static void
tdegtk_draw_cell_frame (DRAW_ARGS,
GtkRegionFlags flags)
{
GtkJunctionSides junction;
guint hidden_side;
TQRect boundingRect(0, 0, width, height);
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
junction = (GtkJunctionSides)(GTK_JUNCTION_RIGHT | GTK_JUNCTION_LEFT);
const GtkWidgetPath* path;
GtkStateFlags state;
GtkWidget* widget;
hidden_side = SIDE_RIGHT | SIDE_LEFT;
path = gtk_theming_engine_get_path(engine);
state = gtk_theming_engine_get_state(engine);
widget = m_widgetLookup.find(cr, path);
if ((flags & GTK_REGION_FIRST) != 0)
{
junction = (GtkJunctionSides)(junction & ~(GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMLEFT));
hidden_side &= ~(SIDE_LEFT);
}
if ((flags & GTK_REGION_LAST) != 0)
{
junction = (GtkJunctionSides)(junction & ~(GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMRIGHT));
hidden_side &= ~(SIDE_RIGHT);
}
#if 0
if (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW)) {
TQStringList objectTypes;
objectTypes.append(TQLISTVIEW_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
tdegtk_cairo_draw_frame (engine, cr,
x, y, width, height,
hidden_side, junction);
TQStyleControlElementData ceData;
TQStyle::ControlElementFlags elementFlags;
ceData.widgetObjectTypes = objectTypes;
ceData.rect = boundingRect;
if ((state & GTK_STATE_FLAG_SELECTED) != 0) {
ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Highlight);
}
else {
ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Base);
}
TQListViewItem tqt3ListViewItem;
TQStyleOption listViewItemOpt(&tqt3ListViewItem);
TQRect paintDeviceRect;
TQRect backgroundRect;
// Draw item
tqApp->style().drawComplexControl(TQStyle::CC_ListView, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE), TQStyle::SC_ListView, TQStyle::SC_All, listViewItemOpt);
}
else {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,64,64);
printf("[WARNING] tdegtk_draw_cell_background() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
}
#endif
p.end();
}
static void
@ -484,8 +531,6 @@ tdegtk_draw_check (DRAW_ARGS)
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,0,0);
GtkStateFlags state;
state = gtk_theming_engine_get_state(engine);
const GtkWidgetPath* path(gtk_theming_engine_get_path(engine));
@ -522,12 +567,20 @@ tdegtk_draw_common_background (DRAW_ARGS)
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,0,0,255);
const GtkWidgetPath* path;
GtkStateFlags state;
GtkWidget* widget;
path = gtk_theming_engine_get_path(engine);
state = gtk_theming_engine_get_state(engine);
widget = m_widgetLookup.find(cr, path);
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY)) {
if ((gtk_widget_path_is_type(path, GTK_TYPE_ENTRY))
|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_VIEW))
|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_BUFFER))
|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY))
|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_COMBOBOX_ENTRY))
) {
TQStringList objectTypes;
objectTypes.append(TQLINEEDIT_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
@ -537,7 +590,7 @@ tdegtk_draw_common_background (DRAW_ARGS)
DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
}
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCROLLBAR)) {
else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCROLLBAR)) {
TQStringList objectTypes;
objectTypes.append(TQSCROLLBAR_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
@ -552,7 +605,7 @@ tdegtk_draw_common_background (DRAW_ARGS)
tqApp->style().drawPrimitive(TQStyle::PE_PanelLineEdit, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE) | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
}
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BUTTON)) {
else if (gtk_widget_path_is_type(path, GTK_TYPE_BUTTON)) {
TQStringList objectTypes;
objectTypes.append(TQBUTTON_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
@ -562,7 +615,27 @@ tdegtk_draw_common_background (DRAW_ARGS)
DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
}
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_TOOLTIP)) {
else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_TOOLBAR)) {
TQStringList objectTypes;
objectTypes.append(TQTOOLBAR_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
// Draw background
TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
}
else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUBAR)) {
TQStringList objectTypes;
objectTypes.append(TQMENUBAR_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
// Draw background
TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
}
else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_TOOLTIP)) {
TQStringList objectTypes;
objectTypes.append(TQTIPLABEL_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
@ -572,56 +645,126 @@ tdegtk_draw_common_background (DRAW_ARGS)
DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
}
if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENU)) || (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM))) {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,128,255);
else if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENU)) || (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM))) {
GtkWidget* parent(widget?gtk_widget_get_parent(widget):0L);
if (!GTK_IS_MENU_BAR(parent)) {
// FIXME
// Mouse movements in the popup menu should be tracked similarly to mouse movements in the tab bar
// Many TQt3 styles highlight inactive menu items on hover; not providing this visual feedback may cause users to briefly think their GTK application has frozen up
// // Register menu item with animation engine
// m_animations.menuItemEngine().registerWidget(widget);
//
// // Check tab properties
// int tabIndex = Gtk::gtk_notebook_find_tab(widget, x+width/2, y+height/2);
// m_animations.tabWidgetEngine().updateTabRect(widget, tabIndex, x, y, width, height);
// bool prelight = (tabIndex == m_animations.tabWidgetEngine().hoveredTab(widget));
// GtkMenuItem* menuitem = GTK_MENU_ITEM(widget);
// const int currentPage = gtk_notebook_get_current_page(notebook);
// const int numPages = gtk_notebook_get_n_pages(notebook);
// bool selectedTab = (tabIndex==currentPage);
TQStringList objectTypes;
objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
bool pressed = false;
bool prelight = false;
TQStyleControlElementData ceData;
TQStyle::ControlElementFlags elementFlags;
ceData.widgetObjectTypes = objectTypes;
ceData.rect = boundingRect;
TQMenuItem tqt3MenuItem;
int maxAcceleratorTextWidth = 0;
int maxIconWidth = IconSize(KIcon::Small) + 4;
TQStyleOption menuOpt(&tqt3MenuItem, maxIconWidth, maxAcceleratorTextWidth);
// if (???) elementFlags = elementFlags | TQStyle::TQStyle::CEF_IsCheckable;
TQRect paintDeviceRect;
TQRect backgroundRect;
// Draw item
tqApp->style().drawControl(TQStyle::CE_PopupMenuItem, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQMenuItem) | ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM))?TQStyle::Style_Active:TQStyle::Style_Default) | ((pressed)?TQStyle::Style_Down:TQStyle::Style_Default) | ((prelight)?TQStyle::Style_MouseOver:TQStyle::Style_Default), menuOpt);
}
}
else if (gtk_widget_path_is_type(path, GTK_TYPE_NOTEBOOK)) {
TQStringList objectTypes;
objectTypes.append(TQTABWIDGET_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
// FIXME
// Mouse movements in the popup menu should be tracked similarly to mouse movements in the tab bar
// Many TQt3 styles highlight inactive menu items on hover; not providing this visual feedback may cause users to briefly think their GTK application has frozen up
// Draw background
TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
}
// // Register menu item with animation engine
// m_animations.menuItemEngine().registerWidget(widget);
//
// // Check tab properties
// int tabIndex = Gtk::gtk_notebook_find_tab(widget, x+width/2, y+height/2);
// m_animations.tabWidgetEngine().updateTabRect(widget, tabIndex, x, y, width, height);
// bool prelight = (tabIndex == m_animations.tabWidgetEngine().hoveredTab(widget));
// GtkMenuItem* menuitem = GTK_MENU_ITEM(widget);
// const int currentPage = gtk_notebook_get_current_page(notebook);
// const int numPages = gtk_notebook_get_n_pages(notebook);
// bool selectedTab = (tabIndex==currentPage);
else if (gtk_widget_path_is_type(path, GTK_TYPE_PROGRESS_BAR)) {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,64,64,255);
}
else if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BACKGROUND))
|| (gtk_widget_path_is_type(path, GTK_TYPE_EXPANDER))
|| (gtk_widget_path_is_type(path, GTK_TYPE_BOX))
|| (gtk_widget_path_is_type(path, GTK_TYPE_VIEWPORT))
|| (gtk_widget_path_is_type(path, GTK_TYPE_SCROLLED_WINDOW))
|| (gtk_widget_path_is_type(path, GTK_TYPE_PANED))
) {
TQStringList objectTypes;
objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
objectTypes.append(TQWIDGET_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
// Draw background
TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
}
else if (gtk_widget_path_is_type(path, GTK_TYPE_HANDLE_BOX)) {
TQStringList objectTypes;
objectTypes.append(TQDOCKWINDOWHANDLE_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
// Draw background
TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
}
else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_CELL)) {
TQStringList objectTypes;
objectTypes.append(TQLISTVIEW_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
TQStyleControlElementData ceData;
TQStyle::ControlElementFlags elementFlags;
ceData.widgetObjectTypes = objectTypes;
ceData.rect = boundingRect;
if ((state & GTK_STATE_FLAG_SELECTED) != 0) {
ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Highlight);
}
else {
ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Base);
}
TQMenuItem tqt3MenuItem;
int maxAcceleratorTextWidth = 0;
int maxIconWidth = IconSize(KIcon::Small) + 4;
TQStyleOption menuOpt(&tqt3MenuItem, maxIconWidth, maxAcceleratorTextWidth);
// if (???) elementFlags = elementFlags | TQStyle::TQStyle::CEF_IsCheckable;
TQListViewItem tqt3ListViewItem;
TQStyleOption listViewItemOpt(&tqt3ListViewItem);
TQRect paintDeviceRect;
TQRect backgroundRect;
// Draw item
tqApp->style().drawControl(TQStyle::CE_PopupMenuItem, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQMenuItem) | ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM))?TQStyle::Style_Active:TQStyle::Style_Default), menuOpt);
tqApp->style().drawComplexControl(TQStyle::CC_ListView, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE), TQStyle::SC_ListView, TQStyle::SC_All, listViewItemOpt);
}
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BACKGROUND)) {
TQStringList objectTypes;
objectTypes.append(TQWIDGET_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
else if (gtk_widget_path_is_type(path, GTK_TYPE_IMAGE)) {
// Do nothing
}
// Draw background
TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
else {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,0,0,255);
printf("[WARNING] tdegtk_draw_common_background() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
}
p.end();
@ -630,12 +773,20 @@ tdegtk_draw_common_background (DRAW_ARGS)
static void
tdegtk_draw_common_frame (DRAW_ARGS)
{
cairo_save(cr);
cairo_reset_clip(cr);
TQRect boundingRect(0, 0, width, height);
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
const GtkWidgetPath* path;
GtkStateFlags state;
GtkWidget* widget;
path = gtk_theming_engine_get_path(engine);
state = gtk_theming_engine_get_state(engine);
widget = m_widgetLookup.find(cr, path);
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCROLLBAR)) {
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BUTTON)) {
@ -669,12 +820,12 @@ tdegtk_draw_common_frame (DRAW_ARGS)
}
}
else {
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BUTTON)) {
if (gtk_widget_path_is_type(path, GTK_TYPE_BUTTON)) {
// Draw frame
tqApp->style().drawPrimitive(TQStyle::PE_ButtonBevel, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQPushButton));
}
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY)) {
else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY)) {
TQStringList objectTypes;
objectTypes.append(TQLINEEDIT_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
@ -683,23 +834,76 @@ tdegtk_draw_common_frame (DRAW_ARGS)
tqApp->style().drawPrimitive(TQStyle::PE_PanelLineEdit, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE));
}
if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENU)) {
else if (gtk_widget_path_is_type(path, GTK_TYPE_SPIN_BUTTON)) {
// Draw frame
tqApp->style().drawPrimitive(TQStyle::PE_ButtonBevel, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQPushButton));
}
else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENU)) {
TQStringList objectTypes;
objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
TQStyleControlElementData ceData;
TQStyle::ControlElementFlags elementFlags;
ceData.widgetObjectTypes = objectTypes;
ceData.rect = boundingRect;
ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;
// Draw frame
tqApp->style().drawPrimitive(TQStyle::PE_PanelPopup, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE) | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
}
else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM)) {
GtkWidget* parent(widget?gtk_widget_get_parent(widget):0L);
if (GTK_IS_MENU_BAR(parent)) {
TQStringList objectTypes;
objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
// See FIXME in tdegtk_draw_common_background
bool pressed = true;
bool prelight = false;
TQStyleControlElementData ceData;
TQStyle::ControlElementFlags elementFlags;
ceData.widgetObjectTypes = objectTypes;
ceData.rect = boundingRect;
ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;
// Draw frame
tqApp->style().drawPrimitive(TQStyle::PE_ButtonDropDown, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQMenuItem) | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default) | ((pressed)?TQStyle::Style_Down:TQStyle::Style_Default) | ((prelight)?TQStyle::Style_MouseOver:TQStyle::Style_Default));
}
}
else if (gtk_widget_path_is_type(path, GTK_TYPE_PROGRESS_BAR)) {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,64,64,255);
}
else if (gtk_widget_path_is_type(path, GTK_TYPE_IMAGE)) {
// Do nothing
}
else if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BACKGROUND))
|| (gtk_widget_path_is_type(path, GTK_TYPE_EXPANDER))
|| (gtk_widget_path_is_type(path, GTK_TYPE_BOX))
|| (gtk_widget_path_is_type(path, GTK_TYPE_VIEWPORT))
|| (gtk_widget_path_is_type(path, GTK_TYPE_SCROLLED_WINDOW))
|| (gtk_widget_path_is_type(path, GTK_TYPE_PANED))
) {
// Do nothing
}
else {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,64,255);
printf("[WARNING] tdegtk_draw_common_frame() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
}
}
p.end();
cairo_restore(cr);
}
static void
@ -753,8 +957,6 @@ tdegtk_draw_extension (DRAW_ARGS,
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,255,0);
const GtkWidgetPath* path;
GtkStateFlags state;
GtkWidget* widget;
@ -809,7 +1011,7 @@ tdegtk_draw_extension (DRAW_ARGS,
ceData.tabBarData.shape = TQTabBar::RoundedBelow;
paintDeviceRect = TQRect(x-tab_overlap, y-tab_to_frame_gap_height, width+(tab_overlap*2), height+tab_to_frame_gap_height);
boundingRect = TQRect(0, 0, width+(tab_overlap*2)-tab_overlap, height+tab_to_frame_gap_height);
boundingRect = TQRect(0, 0, width+tab_overlap, height+tab_to_frame_gap_height);
backgroundRect = TQRect(tab_overlap, 0, width, height+2);
break;
case GTK_POS_LEFT:
@ -822,15 +1024,15 @@ tdegtk_draw_extension (DRAW_ARGS,
tqt3Tab.setIdentifier(tabIndex);
ceData.tabBarData.identIndexMap[tqt3Tab.identifier()] = tabIndex;
paintDeviceRect = TQRect(x-tab_overlap, y, width+(tab_overlap*2), height);
boundingRect = TQRect(0, 0, width+(tab_overlap*2)-tab_overlap, height);
paintDeviceRect = TQRect(x-tab_to_frame_gap_height, y, width+tab_to_frame_gap_height, height);
boundingRect = TQRect(0, 0, width, height);
backgroundRect = TQRect(0, 0, width, height);
break;
case GTK_POS_BOTTOM:
ceData.tabBarData.shape = TQTabBar::RoundedAbove;
paintDeviceRect = TQRect(x-tab_overlap, y, width+(tab_overlap*2), height+tab_to_frame_gap_height);
boundingRect = TQRect(0, 0, width+(tab_overlap*2)-tab_overlap, height+tab_to_frame_gap_height);
boundingRect = TQRect(0, 0, width+tab_overlap, height+tab_to_frame_gap_height);
backgroundRect = TQRect(tab_overlap, 0, width, height+2);
break;
case GTK_POS_RIGHT:
@ -843,8 +1045,8 @@ tdegtk_draw_extension (DRAW_ARGS,
tqt3Tab.setIdentifier(tabIndex);
ceData.tabBarData.identIndexMap[tqt3Tab.identifier()] = tabIndex;
paintDeviceRect = TQRect(x-tab_overlap, y, width+(tab_overlap*2), height);
boundingRect = TQRect(0, 0, width+(tab_overlap*2)-tab_overlap, height);
paintDeviceRect = TQRect(x, y, width+tab_to_frame_gap_height, height);
boundingRect = TQRect(0, 0, width, height);
backgroundRect = TQRect(0, 0, width, height);
break;
}
@ -865,17 +1067,82 @@ tdegtk_draw_extension (DRAW_ARGS,
cairo_restore(cr);
}
else {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,255,0);
printf("[WARNING] tdegtk_draw_extension() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
}
p.end();
}
static void
tdegtk_draw_focus (DRAW_ARGS)
{
TQRect boundingRect(0, 0, width, height);
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
const GtkWidgetPath* path;
GtkStateFlags state;
GtkWidget* widget;
path = gtk_theming_engine_get_path(engine);
state = gtk_theming_engine_get_state(engine);
widget = m_widgetLookup.find(cr, path);
if ((gtk_widget_path_is_type(path, GTK_TYPE_ENTRY))
|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_VIEW))
|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_BUFFER))
|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY))
|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_COMBOBOX_ENTRY))
|| (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW))
|| (gtk_widget_path_is_type(path, GTK_TYPE_BUTTON))
|| (gtk_widget_path_is_type(path, GTK_TYPE_EXPANDER))
) {
TQStyle::SFlags sflags = TQStyle::Style_Default;
TQStringList objectTypes;
if ((gtk_widget_path_is_type(path, GTK_TYPE_ENTRY))
|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_VIEW))
|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_BUFFER))
|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY))
|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_COMBOBOX_ENTRY))
) {
objectTypes.append(TQLINEEDIT_OBJECT_NAME_STRING);
}
else if (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW)) {
objectTypes.append(TQLISTVIEW_OBJECT_NAME_STRING);
}
else {
objectTypes.append(TQWIDGET_OBJECT_NAME_STRING);
}
TQPalette objectPalette = tqApp->palette(objectTypes);
TQColor bgColor;
state = gtk_theming_engine_get_state (engine);
return;
if (state & GTK_STATE_FLAG_INSENSITIVE) {
bgColor = objectPalette.color(TQPalette::Disabled, TQColorGroup::Background);
}
else {
bgColor = objectPalette.color(TQPalette::Active, TQColorGroup::Background);
}
TQStyleOption opt(bgColor);
tqApp->style().drawPrimitive(TQStyle::PE_FocusRect, &p, boundingRect, gtkToTQtColorGroup(engine, state), sflags, opt);
}
else if ((gtk_widget_path_is_type(path, GTK_TYPE_ENTRY))
|| (gtk_widget_path_is_type(path, GTK_TYPE_NOTEBOOK))
) {
// Draw nothing
}
else {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,255,64);
printf("[WARNING] tdegtk_draw_focus() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
}
p.end();
}
static void
@ -997,59 +1264,38 @@ tdegtk_draw_handle (DRAW_ARGS)
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,0,128,255);
p.end();
return;
gdouble line_width;
gint i, bar_y, num_bars, bar_spacing, bar_width, bar_height;
tdegtk_cairo_draw_background (engine, cr,
x, y, width, height,
0, gtk_theming_engine_get_junction_sides (engine));
if (draw_centroid_texture (engine, cr, x, y, width, height))
return;
tdegtk_get_line_width (engine, &line_width);
bar_y = 1;
num_bars = 3;
bar_spacing = 3;
bar_width = 3;
bar_height = num_bars * bar_spacing * line_width;
cairo_save (cr);
cairo_translate (cr, x + (gint) (width / 2), y + (gint) (height / 2));
const GtkWidgetPath* path;
GtkStateFlags state;
//GtkWidget* widget;
if (height > width)
cairo_translate (cr, - bar_width / 2 - 0.5, - bar_height / 2 + 0.5);
else
{
cairo_translate (cr, - bar_height / 2 + 0.5, bar_width / 2 + 0.5);
cairo_rotate (cr, - G_PI / 2);
}
path = gtk_theming_engine_get_path(engine);
state = gtk_theming_engine_get_state(engine);
//widget = m_widgetLookup.find(cr, path);
for (i = 0; i < num_bars; i++)
{
/* draw bars */
cairo_move_to (cr, 0, bar_y);
cairo_line_to (cr, bar_width, bar_y);
tdegtk_cairo_set_source_border (engine, cr, bar_width, 3);
cairo_stroke (cr);
if (gtk_widget_path_is_type(path, GTK_TYPE_HANDLE_BOX)) {
TQStringList objectTypes;
objectTypes.append(TQDOCKWINDOWHANDLE_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
// Draw handle
tqApp->style().drawPrimitive(TQStyle::PE_DockWindowHandle, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE) | ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQStyle::Style_Default:TQStyle::Style_Horizontal));
}
cairo_move_to (cr, 0, bar_y + line_width);
cairo_line_to (cr, bar_width, bar_y + line_width);
tdegtk_cairo_set_source_inner_stroke (engine, cr, bar_width, line_width);
cairo_stroke (cr);
else if (gtk_widget_path_is_type(path, GTK_TYPE_PANED)) {
TQStringList objectTypes;
objectTypes.append(TQSPLITTER_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
// Draw handle
tqApp->style().drawPrimitive(TQStyle::PE_Splitter, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE) | ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQStyle::Style_Default:TQStyle::Style_Horizontal));
}
bar_y += bar_spacing;
}
else {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,0,128,255);
printf("[WARNING] tdegtk_draw_handle() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
}
cairo_restore (cr);
p.end();
}
static void
@ -1060,26 +1306,24 @@ tdegtk_draw_line (GtkThemingEngine *engine,
gdouble x1,
gdouble y1)
{
/* line endings */
if (y0 == y1)
{
y0 += 0.5;
y1 += 0.5;
x0 += 0.5;
x1 -= 0.5;
}
else if (x0 == x1)
{
x0 += 0.5;
x1 += 0.5;
y0 += 0.5;
y1 -= 0.5;
}
cairo_move_to (cr, x0, y0);
cairo_line_to (cr, x1, y1);
tdegtk_cairo_set_source_border (engine, cr, MAX (x1 - x0, 1), MAX (y1 - y0, 1));
cairo_stroke (cr);
// line endings
if (y0 == y1) {
y0 += 0.5;
y1 += 0.5;
x0 += 0.5;
x1 -= 0.5;
}
else if (x0 == x1) {
x0 += 0.5;
x1 += 0.5;
y0 += 0.5;
y1 -= 0.5;
}
cairo_move_to (cr, x0, y0);
cairo_line_to (cr, x1, y1);
tdegtk_cairo_set_source_border (engine, cr, MAX (x1 - x0, 1), MAX (y1 - y0, 1));
cairo_stroke (cr);
}
static void
@ -1118,15 +1362,47 @@ tdegtk_draw_radio (DRAW_ARGS)
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,0,0);
const GtkWidgetPath* path;
GtkStateFlags state;
GtkWidget* widget;
path = gtk_theming_engine_get_path(engine);
state = gtk_theming_engine_get_state(engine);
const GtkWidgetPath* path(gtk_theming_engine_get_path(engine));
widget = m_widgetLookup.find(cr, path);
if (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW)) {
tqApp->style().drawPrimitive(TQStyle::PE_ExclusiveIndicator, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_GTKTreeViewCell));
}
else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM)) {
const GtkAllocation allocation = Gtk::gtk_widget_get_allocation(widget);
boundingRect = TQRect(0, 0, allocation.width, allocation.height);
TQt3CairoPaintDevice pd2(NULL, 0, 0, allocation.width, allocation.height, cr);
TQPainter p2(&pd2);
bool checked = ((state & GTK_STATE_FLAG_ACTIVE) != 0);
int maxAcceleratorTextWidth = 0;
int maxIconWidth = IconSize(KIcon::Small) + 4;
TQStringList objectTypes;
objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
TQStyleControlElementData ceData;
TQStyle::ControlElementFlags elementFlags;
ceData.widgetObjectTypes = objectTypes;
ceData.rect = boundingRect;
TQMenuItem tqt3MenuItem;
tqt3MenuItem.setChecked(checked);
TQStyleOption menuOpt(&tqt3MenuItem, maxIconWidth, maxAcceleratorTextWidth);
elementFlags = elementFlags | TQStyle::TQStyle::CEF_IsCheckable;
if (checked) {
tqApp->style().drawPrimitive(TQStyle::PE_MenuItemIndicatorFrame, &p2, ceData, elementFlags, ceData.rect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQRadioButton), menuOpt);
tqApp->style().drawPrimitive(TQStyle::PE_MenuItemIndicatorCheck, &p2, ceData, elementFlags, ceData.rect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQRadioButton), menuOpt);
}
}
else {
tqApp->style().drawPrimitive(TQStyle::PE_ExclusiveIndicator, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQRadioButton));
}
@ -1137,6 +1413,65 @@ tdegtk_draw_radio (DRAW_ARGS)
static void
tdegtk_draw_separator (DRAW_ARGS)
{
TQRect boundingRect(0, 0, width, height);
TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
TQPainter p(&pd);
const GtkWidgetPath* path;
GtkStateFlags state;
GtkWidget* widget;
path = gtk_theming_engine_get_path(engine);
state = gtk_theming_engine_get_state(engine);
widget = m_widgetLookup.find(cr, path);
if (gtk_widget_path_is_type(path, GTK_TYPE_SEPARATOR_MENU_ITEM)) {
TQStringList objectTypes;
objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
bool pressed = false;
bool prelight = false;
TQStyleControlElementData ceData;
TQStyle::ControlElementFlags elementFlags;
ceData.widgetObjectTypes = objectTypes;
ceData.rect = boundingRect;
TQMenuItem tqt3MenuItem;
tqt3MenuItem.setSeparator(true);
int maxAcceleratorTextWidth = 0;
int maxIconWidth = IconSize(KIcon::Small) + 4;
TQStyleOption menuOpt(&tqt3MenuItem, maxIconWidth, maxAcceleratorTextWidth);
// if (???) elementFlags = elementFlags | TQStyle::TQStyle::CEF_IsCheckable;
TQRect paintDeviceRect;
TQRect backgroundRect;
// Draw item
tqApp->style().drawControl(TQStyle::CE_PopupMenuItem, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQMenuItem), menuOpt);
}
else if (gtk_widget_path_is_type(path, GTK_TYPE_SEPARATOR)) {
TQt::Orientation orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;
tqApp->style().drawPrimitive(TQStyle::PE_Separator, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE) | ((orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
}
else if (gtk_widget_path_is_type(path, GTK_TYPE_SEPARATOR_TOOL_ITEM)) {
TQt::Orientation orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;
tqApp->style().drawPrimitive(TQStyle::PE_Separator, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE) | ((orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
}
else {
DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,128,255);
printf("[WARNING] tdegtk_draw_separator() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
}
p.end();
return;
gdouble line_width;
tdegtk_get_line_width (engine, &line_width);

66
tdegtk/tdegtk-theme.cpp
Unescape View File

@ -79,6 +79,7 @@ extern "C" {
#include <tqscrollbar.h>
#include <tqregexp.h>
#include <tqfont.h>
#include <tqpopupmenu.h>
#include <kapplication.h>
#include <kcmdlineargs.h>
@ -376,12 +377,12 @@ TQString colorString(TQColor color) {
return ret;
}
void setColour(TQString name, TQString state, TQColor color) {
void setColour(TQString name, TQString state, TQColor color, TQString widgetTypes = TQString("*")) {
state = ":" + state;
if (state == ":normal") {
state = "";
}
gtk3_tqt_load_resource_string(parse_rc_string(name + ": " + colorString(color), "*" + state).latin1());
gtk3_tqt_load_resource_string(parse_rc_string(name + ": " + colorString(color), widgetTypes + state).latin1());
}
static TQStringList iconInheritsDirs(const TQString& icondir) {
@ -680,6 +681,67 @@ void writeGtkThemeControlFile(int forceRecreate) {
stream << parse_rc_string("-GtkButton-child-displacement-x: " + TQString::number(tqApp->style().pixelMetric(TQStyle::PM_ButtonShiftHorizontal)), "*");
stream << parse_rc_string("-GtkButton-child-displacement-y: " + TQString::number(tqApp->style().pixelMetric(TQStyle::PM_ButtonShiftVertical)), "*");
// Expand widget padding so as to keep the prelighting out of the active widget area
// FIXME
// Where do these 3px values actually come from?
stream << parse_rc_string("padding: " + TQString::number(3) + "px " + TQString::number(3) + "px", "GtkButton");
stream << parse_rc_string("padding: " + TQString::number(3) + "px " + TQString::number(3) + "px", "GtkNotebook");
stream << parse_rc_string("padding: " + TQString::number(3) + "px " + TQString::number(3) + "px", "GtkEntry");
// Set header sizes
stream << parse_rc_string("padding: " + TQString::number(0) + "px " + TQString::number(0) + "px", "GtkTreeView>*>GtkButton");
stream << parse_rc_string("border-width: " + TQString::number(0) + "px " + TQString::number(0) + "px", "GtkTreeView>*>GtkButton");
stream << parse_rc_string("padding: " + TQString::number(0) + "px " + TQString::number(0) + "px", "GtkList>*>GtkButton");
stream << parse_rc_string("border-width: " + TQString::number(0) + "px " + TQString::number(0) + "px", "GtkList>*>GtkButton");
// Separators appear to be hardcoded to 1px high in TQt3
// Anything else will cause a silent drawing failure!
stream << parse_rc_string("-GtkWidget-separator-height: " + TQString::number(1), "*");
stream << parse_rc_string("-GtkWidget-separator-width: " + TQString::number(1), "*");
stream << parse_rc_string("-GtkWidget-wide-separators: 1", "*");
// Set treeview cell size
stream << parse_rc_string("-GtkTreeView-vertical-separator: 0", "*");
// FIXME
// GTK3 does not currently support drawing GtkTextView backgrounds through the style engine
// Therefore, the best we can currently do is to set the background to the correct TQt3 color, which is obviously suboptimal as the TQt3 background drawing methods are never called!
// Even the recommended CSS style properties do not appear to work!
// See upstream GTK bug #687363
{
TQStringList objectTypes;
objectTypes.append(TQTEXTEDIT_OBJECT_NAME_STRING);
TQPalette objectPalette = tqApp->palette(objectTypes);
// stream << parse_rc_string("background-color: " + colorString(objectPalette.color(TQPalette::Active, TQColorGroup::Base)), "GtkTextView");
// stream << parse_rc_string("background-color: " + colorString(objectPalette.color(TQPalette::Disabled, TQColorGroup::Base)), "GtkTextView:insensitive");
setColour("color", "normal", objectPalette.color(TQPalette::Active, TQColorGroup::Foreground), "GtkTextView");
setColour("color", "insensitive", objectPalette.color(TQPalette::Disabled, TQColorGroup::Foreground), "GtkTextView");
setColour("background-color", "normal", objectPalette.color(TQPalette::Active, TQColorGroup::Base), "GtkTextView");
setColour("background-color", "insensitive", objectPalette.color(TQPalette::Disabled, TQColorGroup::Base), "GtkTextView");
}
// Handle menu metrics
int tdeStandardMenuItemHeight;
int tdeSeparatorMenuItemHeight;
{
TQMenuItem tqt3MenuItem;
tqt3MenuItem.setSeparator(false);
tdeStandardMenuItemHeight = TQPopupMenu::menuItemHeight(&tqt3MenuItem, tqApp->fontMetrics());
tqt3MenuItem.setSeparator(true);
tdeSeparatorMenuItemHeight = TQPopupMenu::menuItemHeight(&tqt3MenuItem, tqApp->fontMetrics());
}
stream << parse_rc_string("-GtkWidget-separator-height: " + TQString::number(tdeSeparatorMenuItemHeight), "GtkMenuItem");
stream << parse_rc_string("-GtkWidget-separator-width: " + TQString::number(tdeSeparatorMenuItemHeight), "GtkMenuItem");
stream << parse_rc_string("-GtkWidget-wide-separators: 1", "GtkMenuItem");
// stream << parse_rc_string("padding: " + TQString::number(tqApp->style().pixelMetric(TQStyle::PM_)), "GtkMenuBar");
stream << parse_rc_string("padding: " + TQString::number(tqApp->style().pixelMetric(TQStyle::PM_MenuBarFrameWidth)) + "px " + TQString::number(tqApp->style().pixelMetric(TQStyle::PM_MenuBarItemSpacing)*0.75) + "px", "GtkMenuBar>GtkMenuItem");
stream << parse_rc_string("padding: " + TQString::number((tdeStandardMenuItemHeight-tqApp->style().pixelMetric(TQStyle::PM_IndicatorHeight))/2) + "px " + TQString::number(0) + "px", "GtkMenu>GtkMenuItem");
stream << parse_rc_string("padding: " + TQString::number(0) + "px " + TQString::number(0) + "px", "GtkMenu>GtkMenuSpacerItem");
// stream << parse_rc_string("padding: " + TQString::number(tqApp->style().pixelMetric(TQStyle::PM_)), "GtkMenu>GtkSeparatorMenuItem");
// Set up fonts
TQFont generalFont = KGlobalSettings::generalFont();
TQFont toolBarFont = KGlobalSettings::toolBarFont();

Write Preview
Loading…
Cancel
Save