////////////////////////////////////////////////////////////////////////////// // phase2style.cpp // ------------------- // TQt/TDE widget style // ------------------- // Copyright (c) 2004 David Johnson // Please see the header file for copyright and license information. ////////////////////////////////////////////////////////////////////////////// // // Some miscellaneous notes // // Reimplemented scrollbar metric and drawing routines from TDEStyle to allow // better placement of subcontrols. This is because the subcontrols slightly // overlap to share part of their border. // // Menu and toolbars are painted with the background color by default. This // differs from the TQt default of giving them PaletteButton backgrounds. // Menubars have normal gradients, toolbars have reverse. // // Some toolbars are not part of a TQMainWindows, such as in a TDE file dialog. // In these cases we treat the toolbar as "floating" and paint it flat. // ////////////////////////////////////////////////////////////////////////////// #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 "phase2style.h" static const char* TQSPLITTERHANDLE = TQSPLITTERHANDLE_OBJECT_NAME_STRING; static const char* TQTOOLBAREXTENSION = "TQToolBarExtensionWidget"; static const char* KTOOLBARWIDGET = "tde toolbar widget"; // some convenient constants static const int ITEMFRAME = 1; // menu stuff static const int ITEMHMARGIN = 3; static const int ITEMVMARGIN = 0; //OBE: static const int ARROWMARGIN = 6; static const int RIGHTBORDER = 6; static const int MINICONSIZE = 16; static const int CHECKSIZE = 9; static const int MAXGRADIENTSIZE = 64; static unsigned contrast = 110; #include "scaling.h" #include "shapes.h" /**************************** TO-DO ********************************** * (1) The above "constants" should be re-scaled by the scaling.h * function Generate_Scaling_Metrics() * (2) Should the same function pre-draw other basic shapes in sizes * relative to FONT_Scale? *********************************************************************/ //#include "plastik-excerpt.cpp" ////////////////////////////////////////////////////////////////////////////// // Construction, Destruction, Initialization // ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // Phase2Style() // ----------- // Constructor Phase2Style::Phase2Style() : TDEStyle(FilledFrameWorkaround | AllowMenuTransparency, ThreeButtonScrollBar), gradients_(TQPixmap::defaultDepth() > 8), kicker_(false) { TQSettings settings; Set_QT3SCALE() ; Generate_Scaling_Metrics(0) ; Initialize_Shapes() ; if (gradients_) { // don't bother setting if already false gradients_ = settings.readBoolEntry("/phasestyle/Settings/gradients", true); contrast = 100 + settings.readNumEntry("/TQt/TDE/contrast", 5); } highlights_ = settings.readBoolEntry("/phasestyle/Settings/highlights", true); gradients = new TQMap >; reverse_ = TQApplication::reverseLayout(); } Phase2Style::~Phase2Style() { delete gradients; gradients = 0; if (KPE_ListViewExpander_ArrowLeft) { delete KPE_ListViewExpander_ArrowLeft ; KPE_ListViewExpander_ArrowLeft = 0 ; } if (KPE_ListViewExpander_ArrowRight) { delete KPE_ListViewExpander_ArrowRight ; KPE_ListViewExpander_ArrowLeft = 0 ; } } ////////////////////////////////////////////////////////////////////////////// // Polishing // ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // polish() // -------- // Initialize application specific void Phase2Style::applicationPolish(const TQStyleControlElementData &ceData, ControlElementFlags, void *ptr) { if (ceData.widgetObjectTypes.contains(TQAPPLICATION_OBJECT_NAME_STRING)) { TQApplication *app = reinterpret_cast(ptr); if (!qstrcmp(app->argv()[0], "kicker")) kicker_ = true; } } ////////////////////////////////////////////////////////////////////////////// // polish() // -------- // Initialize the appearance of a widget void Phase2Style::polish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr) { if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) { TQWidget *widget = reinterpret_cast(ptr); if (::tqqt_cast(widget) || ::tqqt_cast(widget)) { // anti-flicker optimization widget->setBackgroundMode(NoBackground); } else if (::tqqt_cast(widget) || widget->inherits(TQTOOLBAREXTENSION) || (!qstrcmp(widget->name(), KTOOLBARWIDGET))) { // needs special handling on paint events installObjectEventHandler(ceData, elementFlags, ptr, this); } else if (highlights_ && (::tqqt_cast(widget) || ::tqqt_cast(widget) || ::tqqt_cast(widget) || ::tqqt_cast(widget) || ::tqqt_cast(widget) || ::tqqt_cast(widget) || widget->inherits(TQSPLITTERHANDLE))) { // mouseover highlighting installObjectEventHandler(ceData, elementFlags, ptr, this); } else if (highlights_ && ::tqqt_cast(widget)) { // highlighting needing mouse tracking widget->setMouseTracking(true); installObjectEventHandler(ceData, elementFlags, ptr, this); } } TDEStyle::polish(ceData, elementFlags, ptr); } ////////////////////////////////////////////////////////////////////////////// // polish() // -------- // Initialize the palette void Phase2Style::polish(TQPalette &pal) { // clear out gradients on a color change gradients->clear(); // lighten up a bit, so the look is not so "crisp" if (TQPixmap::defaultDepth() > 8) { // but not on low color displays pal.setColor(TQPalette::Disabled, TQColorGroup::Dark, pal.color(TQPalette::Disabled, TQColorGroup::Dark).light(contrast)); pal.setColor(TQPalette::Active, TQColorGroup::Dark, pal.color(TQPalette::Active, TQColorGroup::Dark).light(contrast)); pal.setColor(TQPalette::Inactive, TQColorGroup::Dark, pal.color(TQPalette::Inactive, TQColorGroup::Dark).light(contrast)); } TQStyle::polish(pal); } ////////////////////////////////////////////////////////////////////////////// // unPolish() // ---------- // Undo the initialization of a widget's appearance void Phase2Style::unPolish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr) { if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) { TQWidget *widget = reinterpret_cast(ptr); if (::tqqt_cast(widget) || ::tqqt_cast(widget)) { widget->setBackgroundMode(PaletteBackground); } else if (::tqqt_cast(widget) || widget->inherits(TQTOOLBAREXTENSION) || (!qstrcmp(widget->name(), KTOOLBARWIDGET))) { removeObjectEventHandler(ceData, elementFlags, ptr, this); } else if (highlights_ && // highlighting (::tqqt_cast(widget) || ::tqqt_cast(widget) || ::tqqt_cast(widget) || ::tqqt_cast(widget) || ::tqqt_cast(widget) || ::tqqt_cast(widget) || widget->inherits(TQSPLITTERHANDLE))) { removeObjectEventHandler(ceData, elementFlags, ptr, this); } else if (highlights_ && ::tqqt_cast(widget)) { widget->setMouseTracking(false); removeObjectEventHandler(ceData, elementFlags, ptr, this); } } TDEStyle::unPolish(ceData, elementFlags, ptr); } ////////////////////////////////////////////////////////////////////////////// // Drawing // ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // drawPhaseGradient() // ------------------ // Draw gradient void Phase2Style::drawPhaseGradient(TQPainter *painter, const TQRect &rect, TQColor color, bool horizontal, int px, int py, int pw, int ph, bool reverse) const { if (!gradients_) { painter->fillRect(rect, color); return; } // px, py, pw, ph used for parent-relative pixmaps int size; if (horizontal) size = (pw > 0) ? pw : rect.width(); else size = (ph > 0) ? ph : rect.height(); if (size > MAXGRADIENTSIZE) { // keep it sensible painter->fillRect(rect, color); } else { // lazy allocation GradientSet *set = (*gradients)[color.rgb()][size]; if (!set) { set = new GradientSet(color, size); (*gradients)[color.rgb()].setAutoDelete(true); (*gradients)[color.rgb()].insert(size, set); } painter->drawTiledPixmap(rect, *set->gradient(horizontal, reverse), TQPoint(px, py)); } } ////////////////////////////////////////////////////////////////////////////// // drawPhaseBevel() // ---------------- // Draw the basic Phase bevel void Phase2Style::drawPhaseBevel(TQPainter *painter, int x, int y, int w, int h, const TQColorGroup &group, const TQColor &fill, bool sunken, bool horizontal, bool reverse) const { int x2 = x + w - 1; int y2 = y + h - 1; painter->save(); painter->setPen(group.dark()); painter->drawRect(x, y, w, h); painter->setPen(sunken ? group.mid() : group.midlight()); painter->drawLine(x+1, y+1, x2-2, y+1); painter->drawLine(x+1, y+2, x+1, y2-2); painter->setPen(sunken ? group.midlight() : group.mid()); painter->drawLine(x+2, y2-1, x2-1, y2-1); painter->drawLine(x2-1, y+2, x2-1, y2-2); painter->setPen(group.button()); painter->drawPoint(x+1, y2-1); painter->drawPoint(x2-1, y+1); if (sunken) { // sunken bevels don't get gradients painter->fillRect(x+2, y+2, w-4, h-4, fill); } else { drawPhaseGradient(painter, TQRect(x+2, y+2, w-4, h-4), fill, horizontal, 0, 0, w-4, h-4, reverse); } painter->restore(); } ////////////////////////////////////////////////////////////////////////////// // drawPhaseButton() // ---------------- // Draw the basic Phase button void Phase2Style::drawPhaseButton(TQPainter *painter, int x, int y, int w, int h, const TQColorGroup &group, const TQColor &fill, bool sunken) const { int x2 = x + w - 1; int y2 = y + h - 1; painter->setPen(group.midlight()); painter->drawLine(x+1, y2, x2, y2); painter->drawLine(x2, y+1, x2, y2-1); painter->setPen(group.mid()); painter->drawLine(x, y, x2-1, y); painter->drawLine(x, y+1, x, y2-1); painter->setPen(group.button()); painter->drawPoint(x, y2); painter->drawPoint(x2, y); drawPhaseBevel(painter, x+1, y+1, w-2, h-2, group, fill, sunken, false, false); } ////////////////////////////////////////////////////////////////////////////// // drawPhasePanel() // ---------------- // Draw the basic Phase panel void Phase2Style::drawPhasePanel(TQPainter *painter, int x, int y, int w, int h, const TQColorGroup &group, bool sunken, const TQBrush *fill) const { int x2 = x + w - 1; int y2 = y + h - 1; painter->save(); if (sunken) { painter->setPen(group.dark()); painter->drawRect(x+1, y+1, w-2, h-2); painter->setPen(group.midlight()); painter->drawLine(x+1, y2, x2, y2); painter->drawLine(x2, y+1, x2, y2-1); painter->setPen(group.mid()); painter->drawLine(x, y, x, y2-1); painter->drawLine(x+1, y, x2-1, y); painter->setPen(group.background()); painter->drawPoint(x, y2); painter->drawPoint(x2, y); } else { painter->setPen(group.dark()); painter->drawRect(x, y, w, h); painter->setPen(group.midlight()); painter->drawLine(x+1, y+1, x2-2, y+1); painter->drawLine(x+1, y+2, x+1, y2-2); painter->setPen(group.mid()); painter->drawLine(x+2, y2-1, x2-1, y2-1); painter->drawLine(x2-1, y+2, x2-1, y2-2); painter->setPen(group.background()); painter->drawPoint(x+1, y2-1); painter->drawPoint(x2-1, y+1); } if (fill) { painter->fillRect(x+2, y+2, w-4, h-4, fill->color()); } painter->restore(); } ////////////////////////////////////////////////////////////////////////////// // drawPhaseTab() // ------------- // Draw a Phase style tab void Phase2Style::drawPhaseTab(TQPainter *painter, int x, int y, int w, int h, const TQColorGroup &group, const TQStyleControlElementData &ceData, ControlElementFlags /*elementFlags*/, const TQStyleOption &option, SFlags flags) const { bool selected = (flags & Style_Selected); bool edge; // tab is at edge of bar const int x2 = x + w - 1; const int y2 = y + h - 1; painter->save(); // what position is the tab? if ((ceData.tabBarData.tabCount == 1) || (ceData.tabBarData.identIndexMap[option.tab()->identifier()] == 0)) { edge = true; } else { edge = false; } switch (TQTabBar::Shape(ceData.tabBarData.shape)) { case TQTabBar::RoundedAbove: case TQTabBar::TriangularAbove: { // is there a corner widget? if (!ceData.tabBarData.cornerWidgets[reverse_ ? TQStyleControlElementTabBarData::CWL_TopRight : TQStyleControlElementTabBarData::CWL_TopLeft].widgetObjectTypes.isEmpty()) { edge = false; } if (!selected) { // shorten y += 2; h -= 2; } if (selected) { painter->setPen(TQt::NoPen); painter->fillRect(x+1, y+1, w-1, h-1, group.brush(TQColorGroup::Background)); } else { drawPhaseGradient(painter, TQRect(x+1, y+1, w-1, h-2), (flags & Style_MouseOver) ? group.background() : TQColor(group.background().dark(contrast)), false, 0, 0, 0, h*2, false); } // draw tab painter->setPen(group.dark()); painter->drawLine(x, y, x, y2-2); painter->drawLine(x+1, y, x2, y); painter->drawLine(x2, y+1, x2, y2-2); painter->setPen(group.mid()); painter->drawLine(x2-1, y+2, x2-1, y2-2); painter->setPen(group.midlight()); painter->drawLine(x+1, y+1, x2-2, y+1); if ((selected) || edge) painter->drawLine(x+1, y+2, x+1, y2-2); // finish off bottom if (selected) { painter->setPen(group.dark()); painter->drawPoint(x, y2-1); painter->drawPoint(x2, y2-1); painter->setPen(group.midlight()); painter->drawPoint(x, y2); painter->drawLine(x+1, y2-1, x+1, y2); painter->drawPoint(x2, y2); painter->setPen(group.mid()); painter->drawPoint(x2-1, y2-1); if (!reverse_ && edge) { painter->setPen(group.dark()); painter->drawLine(x, y2-1, x, y2); painter->setPen(group.midlight()); painter->drawPoint(x+1, y2); } } else { painter->setPen(group.dark()); painter->drawLine(x, y2-1, x2, y2-1); painter->setPen(group.midlight()); painter->drawLine(x, y2, x2, y2); if (!reverse_ && edge) { painter->setPen(group.dark()); painter->drawLine(x, y2-1, x, y2); } } if (reverse_ && edge) { painter->setPen(group.dark()); painter->drawPoint(x2, y2); painter->setPen(selected ? group.mid() : group.background()); painter->drawPoint(x2-1, y2); } break; } case TQTabBar::RoundedBelow: case TQTabBar::TriangularBelow: { // is there a corner widget? if (!ceData.tabBarData.cornerWidgets[reverse_ ? TQStyleControlElementTabBarData::CWL_BottomRight : TQStyleControlElementTabBarData::CWL_BottomLeft].widgetObjectTypes.isEmpty()) { edge = false; } painter->setBrush((selected || (flags & Style_MouseOver)) ? group.background() : TQColor(group.background().dark(contrast))); painter->setPen(TQt::NoPen); painter->fillRect(x+1, y+1, w-1, h-1, painter->brush()); // draw tab painter->setPen(group.dark()); painter->drawLine(x, y+1, x, y2); painter->drawLine(x+1, y2, x2, y2); painter->drawLine(x2, y+1, x2, y2-1); painter->setPen(group.mid()); painter->drawLine(x2-1, y+1, x2-1, y2-1); painter->drawLine(x+2, y2-1, x2-1, y2-1); painter->drawPoint(x, y); painter->drawPoint(x2, y); if ((selected) || edge) { painter->setPen(group.midlight()); painter->drawLine(x+1, y+1, x+1, y2-2); } // finish off top if (selected) { if (!reverse_ && edge) { painter->setPen(group.dark()); painter->drawPoint(x, y); painter->setPen(group.midlight()); painter->drawPoint(x+1, y); } } else { painter->setPen(group.dark()); painter->drawLine(x, y+1, x2, y+1); painter->setPen(group.mid()); painter->drawLine(x, y, x2, y); if (!reverse_ && edge) { painter->setPen(group.dark()); painter->drawPoint(x, y); } } if (reverse_ && edge) { painter->setPen(group.dark()); painter->drawPoint(x2, y); painter->setPen(group.mid()); painter->drawPoint(x2-1, y); } break; } } painter->restore(); } ////////////////////////////////////////////////////////////////////////////// // drawPrimitive() // --------------- // Draw the primitive element void Phase2Style::drawPrimitive(TQ_PrimitiveElement element, TQPainter *painter, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &rect, const TQColorGroup &group, SFlags flags, const TQStyleOption &option) const { // common locals bool down = flags & Style_Down; bool on = flags & Style_On; bool depress = (down || on); bool enabled = flags & Style_Enabled; bool horiz = flags & Style_Horizontal; bool active = flags & Style_Active; bool mouseover = highlights_ && (flags & Style_MouseOver); int x, y, w, h, x2, y2, n, cx, cy; TQPointArray parray; TQWidget* widget; rect.rect(&x, &y, &w, &h); x2 = rect.right(); y2 = rect.bottom(); switch(element) { case PE_ButtonBevel: case PE_ButtonDefault: case PE_ButtonDropDown: case PE_ButtonTool: drawPhaseBevel(painter, x,y,w,h, group, group.button(), depress, false, false); break; case PE_ButtonCommand: drawPhaseButton(painter, x, y, w, h, group, mouseover ? TQColor(group.button().light(contrast)) : group.button(), depress); break; case PE_FocusRect: { TQPen old = painter->pen(); painter->setPen(group.highlight().dark(contrast)); painter->drawRect(rect); painter->setPen(old); break; } case PE_HeaderSection: { // covers kicker taskbar buttons and menu titles TQHeader* header = dynamic_cast(painter->device()); widget =dynamic_cast(painter->device()); if (header) { horiz = (header->orientation() ==Qt::Horizontal); } else { horiz = true; } if ((ceData.widgetObjectTypes.contains(TQPOPUPMENU_OBJECT_NAME_STRING)) || (ceData.widgetObjectTypes.contains("TDEPopupTitle"))) { // kicker/kdesktop menu titles drawPhaseBevel(painter, x,y,w,h, group, group.background(), depress, !horiz); } else if (kicker_) { // taskbar buttons (assuming no normal headers used in kicker) if (depress) { painter->setPen(group.dark()); painter->setBrush(group.brush(TQColorGroup::Mid)); painter->drawRect(x-1, y-1, w+1, h+1); } else { drawPhaseBevel(painter, x-1, y-1, w+1, h+1, group, group.button(), false, !horiz, true); } } else { // other headers if (depress) { painter->setPen(group.dark()); painter->setBrush(group.brush(TQColorGroup::Mid)); painter->drawRect(x-1, y-1, w+1, h+1); } else { drawPhaseBevel(painter, x-1, y-1, w+1, h+1, group, group.background(), false, !horiz, true); } } break; } case PE_HeaderArrow: { //--- Determine arrow size & position int arrowSize = ARROW_Size2 ; int arrowScaling = 0 ; int vdelta = ( h - arrowSize ) ; int hdelta = ( w - arrowSize ) ; int voffset = y + vdelta / 2 ; // vertical alignment: centered int hoffset = x + hdelta / 2 ; // horizontal alignment: centered TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ; //--- Determine arrow direction TQStyle::PrimitiveElement arrow = PE_ArrowDown ; if (flags & Style_Up) arrow = PE_ArrowUp ; //--- Determine arrow color if (enabled) painter->setPen( (flags & Style_Sunken) ? group.midlight() : darkBlue ); // ? group.midlight() : group.dark()); else painter->setPen( group.mid() ); //--- Draw arrow drawArrow(painter, frame, arrow, arrowScaling ); break ; //-------------------------------------------------------------------- /* Previous code: * / //-------------------------------------------------------------------- if (flags & Style_Up) drawArrow(painter, TQRect(x,y,h,w), PE_ArrowUp, 0) ; //drawPrimitive(PE_ArrowUp, painter, ceData, elementFlags, rect, group, Style_Enabled); else drawArrow(painter, TQRect(x,y,h,w), PE_ArrowDown, 0) ; //drawPrimitive(PE_ArrowDown, painter, ceData, elementFlags, rect, group, Style_Enabled); break ; /* End of previous code */ } case PE_ScrollBarAddPage: case PE_ScrollBarSubPage: if (h) { // has a height, thus visible painter->fillRect(rect, group.mid()); painter->setPen(group.dark()); if (horiz) { // vertical painter->drawLine(x, y, x2, y); painter->drawLine(x, y2, x2, y2); } else { // horizontal painter->drawLine(x, y, x, y2); painter->drawLine(x2, y, x2, y2); } } break; case PE_ScrollBarAddLine: case PE_ScrollBarSubLine: { drawPhaseBevel(painter, x, y, w, h, group, group.button(), down, !horiz, true); //--- Determine arrow direction TQ_PrimitiveElement arrow = ((horiz) ? ((element == PE_ScrollBarAddLine) ? PE_ArrowRight : PE_ArrowLeft) : ((element == PE_ScrollBarAddLine) ? PE_ArrowDown : PE_ArrowUp)); if (down) { // shift arrow switch (arrow) { case PE_ArrowRight: x++; break; case PE_ArrowLeft: x--; break; case PE_ArrowDown: y++; break; case PE_ArrowUp: y--; break; default: break; } } //--- Determine arrow size & position int arrowSize = ARROW_Size2 ; int arrowScaling = 0 ; int vdelta = ( h - arrowSize ) ; int hdelta = ( w - arrowSize ) ; int voffset = y + vdelta / 2 ; // vertical alignment: centered int hoffset = x + hdelta / 2 ; // horizontal alignment: centered TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ; //--- Determine arrow color if (enabled) painter->setPen( (flags & Style_Sunken) ? group.midlight() : darkBlue ); // ? group.midlight() : group.dark()); else painter->setPen( group.mid() ); //--- Draw arrow drawArrow(painter, frame, arrow, arrowScaling ); break; //-------------------------------------------------------------------- /* Previous code: * / //-------------------------------------------------------------------- //drawPrimitive(arrow, painter, ceData, elementFlags, TQRect(x,y,h,w), group, flags); drawArrow(painter, TQRect(x,y,h,w), arrow, 4) ; break ; /* End of previous code */ } case PE_ScrollBarSlider: drawPhaseBevel(painter, x, y, w, h, group, group.button(), false, !horiz, true); // draw doodads cx = x + w/2 - 2; cy = y + h/2 - 2; if (horiz && (w >=20)) { for (n = -5; n <= 5; n += 5) { kColorBitmaps(painter, group, cx+n, cy, 0, &doodad_mid, &doodad_light, 0, 0, 0); } } else if (!horiz && (h >= 20)) { for (n = -5; n <= 5; n += 5) { kColorBitmaps(painter, group, cx, cy+n, 0, &doodad_mid, &doodad_light, 0, 0, 0); } } break; case PE_Indicator: drawPhasePanel(painter, x+1, y+1, w-2, h-2, group, true, enabled ? &group.brush(TQColorGroup::Base) : &group.brush(TQColorGroup::Background)); if (on) { painter->setPen(mouseover ? TQColor(group.highlight().dark(contrast)) : group.dark()); painter->drawRect(x+4, y+4, w-8, h-8); painter->fillRect(x+5, y+5, w-10, h-10, group.brush(TQColorGroup::Highlight)); } else if (mouseover) { painter->setPen(TQColor(group.highlight().dark(contrast))); painter->drawRect(x+4, y+4, w-8, h-8); } break; case PE_IndicatorMask: painter->fillRect(x+1, y+1, w-2, h-2, TQt::color1); painter->setPen(TQt::color0); break; case PE_ExclusiveIndicator: { // note that this requires an even size from pixelMetric cx = (x + x2) / 2; cy = (y + y2) / 2; painter->setBrush(enabled ? group.brush(TQColorGroup::Base) : group.brush(TQColorGroup::Background)); painter->setPen(group.dark()); parray.putPoints(0, 8, x+1,cy+1, x+1,cy, cx,y+1, cx+1,y+1, x2-1,cy, x2-1,cy+1, cx+1,y2-1, cx,y2-1); painter->drawConvexPolygon(parray, 0, 8); painter->setPen(group.mid()); parray.putPoints(0, 4, x,cy, cx,y, cx+1,y, x2,cy); painter->drawPolyline(parray, 0, 4); painter->setPen(group.midlight()); parray.putPoints(0, 4, x2,cy+1, cx+1,y2, cx,y2, x,cy+1); painter->drawPolyline(parray, 0, 4); if (on) { painter->setBrush(group.brush(TQColorGroup::Highlight)); painter->setPen(mouseover ? TQColor(group.highlight().dark(contrast)) : group.dark()); parray.putPoints(0, 8, x+4,cy+1, x+4,cy, cx,y+4, cx+1,y+4, x2-4,cy, x2-4,cy+1, cx+1,y2-4, cx,y2-4); painter->drawConvexPolygon(parray, 0, 8); } else if (mouseover) { painter->setPen(TQColor(group.highlight().dark(contrast))); parray.putPoints(0, 9, x+4,cy+1, x+4,cy, cx,y+4, cx+1,y+4, x2-4,cy, x2-4,cy+1, cx+1,y2-4, cx,y2-4, x+4,cy+1); painter->drawPolyline(parray, 0, 9); } break; } case PE_ExclusiveIndicatorMask: cx = (x + x2) / 2; cy = (y + y2) / 2; painter->setBrush(TQt::color1); painter->setPen(TQt::color1); parray.putPoints(0, 8, x,cy+1, x,cy, cx,y, cx+1,y, x2,cy, x2,cy+1, cx+1,y2, cx,y2); painter->drawConvexPolygon(parray, 0, 8); painter->setPen(TQt::color0); break; case PE_DockWindowResizeHandle: drawPhasePanel(painter, x, y, w, h, group, false, &group.brush(TQColorGroup::Background)); break; case PE_Splitter: cx = x + w/2 - 2; cy = y + h/2 - 2; painter->fillRect(rect, (flags & Style_MouseOver) ? TQColor(group.background().light(contrast)) : group.background()); if (!horiz && (w >=20)) { for (n = -5; n <= 5; n += 5) { kColorBitmaps(painter, group, cx+n, cy, 0, &doodad_mid, &doodad_light, 0, 0, 0); } } else if (horiz && (h >= 20)) { for (n = -5; n <= 5; n += 5) { kColorBitmaps(painter, group, cx, cy+n, 0, &doodad_mid, &doodad_light, 0, 0, 0); } } break; case PE_Panel: case PE_PanelLineEdit: case PE_PanelTabWidget: case PE_TabBarBase: drawPhasePanel(painter, x, y, w, h, group, flags & Style_Sunken); break; case PE_PanelPopup: case PE_WindowFrame: drawPhasePanel(painter, x, y, w, h, group, false); break; case PE_GroupBoxFrame: case PE_PanelGroupBox: painter->setPen(group.dark()); painter->drawRect(rect); break; case PE_Separator: painter->setPen(group.dark()); if (w < h) painter->drawLine(w/2, y, w/2, y2); else painter->drawLine(x, h/2, x2, h/2); break; case PE_StatusBarSection: painter->setPen(group.mid()); painter->drawLine(x, y, x2-1, y); painter->drawLine(x, y+1, x, y2-1); painter->setPen(group.midlight()); painter->drawLine(x+1, y2, x2, y2); painter->drawLine(x2, y+1, x2, y2-1); break; case PE_PanelMenuBar: case PE_PanelDockWindow: if (kicker_ && (w == 2)) { // kicker handle separator painter->setPen(group.mid()); painter->drawLine(x, y, x, y2); painter->setPen(group.midlight()); painter->drawLine(x+1, y, x+1, y2); } else if (kicker_ && (h == 2)) { // kicker handle separator painter->setPen(group.mid()); painter->drawLine(x, y, x2, y); painter->setPen(group.midlight()); painter->drawLine(x, y+1, x2, y+1); } else { --x; --y; ++w; ++h; // adjust rect so we can use bevel drawPhaseBevel(painter, x, y, w, h, group, group.background(), false, (w < h), (element==PE_PanelDockWindow) ? true : false); } break; case PE_DockWindowSeparator: { widget = dynamic_cast(painter->device()); bool flat = true; if (ceData.parentWidgetData.widgetObjectTypes.contains(TQTOOLBAR_OBJECT_NAME_STRING)) { TQToolBar *toolbar = ::tqqt_cast(widget->parent()); if (toolbar) { // toolbar not floating or in a TQMainWindow flat = flatToolbar(ceData, elementFlags, toolbar); } } if (flat) painter->fillRect(rect, group.background()); else drawPhaseGradient(painter, rect, group.background(), !(horiz), 0, 0, -1, -1, true); if (horiz) { int cx = w/2 - 1; painter->setPen(group.mid()); painter->drawLine(cx, 0, cx, h-2); if (!flat) painter->drawLine(0, h-1, w-1, h-1); painter->setPen(group.midlight()); painter->drawLine(cx+1, 0, cx+1, h-2); } else { int cy = h/2 - 1; painter->setPen(group.mid()); painter->drawLine(0, cy, w-2, cy); if (!flat) painter->drawLine(w-1, 0, w-1, h-1); painter->setPen(group.midlight()); painter->drawLine(0, cy+1, w-2, cy+1); } break; } case PE_SizeGrip: { int sw = TQMIN(h, w) - 1; y = y2 - sw; if (reverse_) { x2 = x + sw; for (int n = 0; n < 4; ++n) { painter->setPen(group.dark()); painter->drawLine(x, y, x2, y2); painter->setPen(group.midlight()); painter->drawLine(x, y+1, x2-1, y2); y += 3;; x2 -= 3;; } } else { x = x2 - sw; for (int n = 0; n < 4; ++n) { painter->setPen(group.dark()); painter->drawLine(x, y2, x2, y); painter->setPen(group.midlight()); painter->drawLine(x+1, y2, x2, y+1); x += 3; y += 3; } } break; } case PE_CheckMark: drawCheckmark(painter, rect, 4 ); break ; painter->setPen(group.text()); painter->drawPixmap(x+w/2-4, y+h/2-4, bcheck); break; case PE_SpinWidgetPlus: case PE_SpinWidgetMinus: if (enabled) painter->setPen((flags & Style_Sunken) ? group.midlight() : group.dark()); else painter->setPen(group.mid()); painter->drawPixmap(x+w/2-3, y+h/2-3, (element==PE_SpinWidgetPlus) ? bplus : bminus); break; case PE_SpinWidgetUp: { // painter->drawPixmap(x+w/2-3, y+h/2-3, uarrow); break ; //--- Determine arrow size & position //int arrowSize = ARROW_Size4x3 ; //int arrowScaling = 1 ; int arrowSize = ARROW_Size2 ; int arrowScaling = 1 ; int vdelta = ( h - arrowSize ) ; int hdelta = ( w - arrowSize ) ; int voffset = y + vdelta ; // vertical alignment: top int hoffset = x + hdelta / 2 ; // horizontal alignment: centered TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ; //--- Determine arrow direction TQStyle::PrimitiveElement arrow = PE_ArrowUp ; //--- Determine arrow color if (flags & Style_Enabled) { painter->setPen((flags & Style_Sunken) ? group.midlight() : group.dark()); painter->setPen(darkBlue) ; } else { painter->setPen(group.mid()); } //--- Draw arrow drawArrow(painter, frame, arrow, arrowScaling ); break ; //-------------------------------------------------------------------- /* Previous code: * / //-------------------------------------------------------------------- drawArrow(painter, rect, element, 3) ; //drawArrow(painter, TQRect(x+w/2,y+h/2+3,h,w), element, 1) ; //painter->drawPixmap(x+w/2-3, y+h/2-3, uarrow); //drawArrow(painter, TQRect(x,y,h,w), element, 1) ; break ; /* End of previous code */ } case PE_SpinWidgetDown: { // painter->drawPixmap(x+w/2-3, y+h/2-3, darrow); break ; //--- Determine arrow size & position //int arrowSize = ARROW_Size4x3 ; //int arrowScaling = 1 ; int arrowSize = ARROW_Size2 ; int arrowScaling = 1 ; int vdelta = ( h - arrowSize ) ; int hdelta = ( w - arrowSize ) ; int voffset = y ; ; // vertical alignment: bottom int hoffset = x + hdelta / 2 ; // horizontal alignment: centered TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ; //--- Determine arrow direction TQStyle::PrimitiveElement arrow = PE_ArrowDown ; //--- Determine arrow color if (flags & Style_Enabled) { painter->setPen((flags & Style_Sunken) ? group.midlight() : group.dark()); painter->setPen(darkBlue) ; } else { painter->setPen(group.mid()); } //--- Draw arrow drawArrow(painter, frame, arrow, arrowScaling ); break ; //-------------------------------------------------------------------- /* Previous code: * / //-------------------------------------------------------------------- if (flags & Style_Enabled) { painter->setPen((flags & Style_Sunken) ? group.midlight() : group.dark()); painter->setPen(blue) ; } else { painter->setPen(group.mid()); } drawArrow(painter, rect, element, 3) ; //drawArrow(painter, TQRect(x+w/2,y+h/2-3,h,w), element, 1) ; //painter->drawPixmap(x+w/2-3, y+h/2-3, darrow); //drawArrow(painter, TQRect(x,y,h,w), element, 1) ; break ; /* End of previous code */ } case PE_ArrowUp: case PE_ArrowDown: case PE_ArrowLeft: case PE_ArrowRight: { //--- Determine arrow size & position int arrowSize = ARROW_Size4 ; int arrowScaling = -1 ; int vdelta = ( h - arrowSize ) ; int hdelta = ( w - arrowSize ) ; int voffset = y + vdelta / 2 ; // vertical alignment: centered int hoffset = x + hdelta / 2 ; // horizontal alignment: centered TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ; //--- Determine arrow color if (flags & Style_Enabled) { painter->setPen((flags & Style_Sunken) ? group.midlight() : group.dark()); } else { painter->setPen(group.mid()); } //--- Draw arrow if ( FONT_Scale <= 1.00 ) //--- Invoke legacy code that relies on hardcoded bitmaps drawArrowBitmap( painter, frame, element ) ; else //--- Invoke new code that relies on dynamic drawing routines drawArrow(painter, frame, element, arrowScaling ); break ; //-------------------------------------------------------------------- /* Previous code: * / //-------------------------------------------------------------------- if (flags & Style_Enabled) { // painter->setPen((flags & Style_Sunken) // ? group.midlight() : group.dark()); painter->setPen(black) ; } else { painter->setPen(group.mid()); } drawArrow(painter, rect, element, -1) ; // painter->drawPixmap(x+w/2-3, y+h/2-3, uarrow); // painter->drawPixmap(x+w/2-3, y+h/2-3, darrow); // painter->drawPixmap(x+w/2-3, y+h/2-3, larrow); // painter->drawPixmap(x+w/2-3, y+h/2-3, rarrow); break ; /* End of previous code */ } case PE_MenuItemIndicatorFrame: { // Draw nothing break; } case PE_MenuItemIndicatorIconFrame: { // Draw nothing break; } case PE_MenuItemIndicatorCheck: { int checkwidth = styleHint(SH_MenuIndicatorColumnWidth, ceData, elementFlags, option, NULL, NULL); int cx = reverse_ ? x+w - checkwidth : x; drawPrimitive(PE_CheckMark, painter, ceData, elementFlags, TQRect(cx + ITEMFRAME, y + ITEMFRAME, checkwidth - ITEMFRAME*2, h - ITEMFRAME*2), group, Style_Default | (active ? Style_Enabled : Style_On)); break; } default: TDEStyle::drawPrimitive(element, painter, ceData, elementFlags, rect, group, flags, option); } } ////////////////////////////////////////////////////////////////////////////// // drawTDEStylePrimitive() // --------------------- // Draw the element void Phase2Style::drawTDEStylePrimitive(TDEStylePrimitive element, TQPainter *painter, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &rect, const TQColorGroup &group, SFlags flags, const TQStyleOption &option, const TQWidget *widget) const { bool horiz = flags & Style_Horizontal; int x, y, w, h, x2, y2, n, cx, cy; rect.rect(&x, &y, &w, &h); x2 = rect.right(); y2 = rect.bottom(); cx = x + w/2; cy = y + h/2; switch (element) { case KPE_ToolBarHandle: cx-=2; cy-=2; drawPhaseGradient(painter, rect, group.background(), !horiz, 0, 0, w-1, h-1, true); if (horiz) { for (n = -5; n <= 5; n += 5) { kColorBitmaps(painter, group, cx, cy+n, 0, &doodad_mid, &doodad_light, 0, 0, 0); } painter->setPen(group.mid()); painter->drawLine(x, y2, x2, y2); } else { for (n = -5; n <= 5; n += 5) { kColorBitmaps(painter, group, cx+n, cy, 0, &doodad_mid, &doodad_light, 0, 0, 0); } painter->setPen(group.mid()); painter->drawLine(x2, y, x2, y2); } break; //case KPE_DockWindowHandle: case KPE_GeneralHandle: cx-=2; cy-=2; painter->fillRect(rect, group.brush(TQColorGroup::Background)); if (horiz) { for (n = -5; n <= 5; n += 5) { kColorBitmaps(painter, group, cx, cy+n, 0, &doodad_mid, &doodad_light, 0, 0, 0); } } else { for (n = -5; n <= 5; n += 5) { kColorBitmaps(painter, group, cx+n, cy, 0, &doodad_mid, &doodad_light, 0, 0, 0); } } break; case KPE_ListViewExpander: { //-------------------------------------------------------------------- /* METHOD 0: Let TDE draw the default style / //-------------------------------------------------------------------- TDEStyle::drawTDEStylePrimitive(element, painter, ceData, elementFlags, rect, group, flags, option, widget); break ; /* End of METHOD 0 */ //--- Determine arrow size & position int arrowSize = ARROW_Size2 ; int arrowScaling = 1 ; int vdelta = ( h - arrowSize ) ; int hdelta = ( w - arrowSize ) ; int voffset = y + vdelta / 2 ; // vertical alignment: centered int hoffset = x + hdelta / 2 ; // horizontal alignment: centered TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ; /**************************** FIXME ********************************** * First tree view suffers from a visible and relatively prolonged * "rippling" effect that NONE of the methods below seem to address. * This actually seems to be a problem with most widget styles! * * We are still encountering challenges drawing appropriately scaled * +|- (i.e. scaled relative to FONT_Size). For some reason, the * rectangle we are passed is *ALWAYS* 9x9 px and we have not been * able find the reason why. Debugging statements we have used: fprintf(stderr, "Rectangle pos (size): H - %3d + %3d x V - %3d + %3d\n", x, h, y, w ); fprintf(stderr, "Arrow position (siz): H - %3d + %3d x V - %3d + %3d\n", hoffset, arrowSize, voffset, arrowSize ); fprintf(stderr, "Pixelmetrics:\n PE_CheckListController='%d'\n PE_CheckListIndicator='%d'\n PE_CheckListExclusiveIndicator='%d'\n\n", (int)PE_CheckListController, (int)PE_CheckListIndicator, (int)PE_CheckListExclusiveIndicator ) ; fprintf(stderr, "Checkbox size = %d \n\n", FONT_Size & 0xfffe); *********************************************************************/ //-------------------------------------------------------------------- /* METHOD 1: Directly draw the arrows */ //-------------------------------------------------------------------- //--- Determine arrow direction TQStyle::PrimitiveElement arrow = PE_ArrowLeft ; if (flags & Style_On) arrow = PE_ArrowRight ; //--- Determine arrow color painter->setPen(group.mid()); //--- Draw arrow vector drawArrow(painter, frame, arrow, arrowScaling ); break ; /* End of METHOD 1 */ //-------------------------------------------------------------------- /* METHOD 2a: Generate reusable arrow pixmaps, then "draw" them * / //-------------------------------------------------------------------- //--- Generate reusable arrow pixmaps if (! KPE_ListViewExpander_ArrowLeft ) { KPE_ListViewExpander_ArrowLeft = Create_Arrow_Pix(PE_ArrowLeft, arrowSize, arrowScaling) ; } if (!KPE_ListViewExpander_ArrowRight ) { KPE_ListViewExpander_ArrowRight = Create_Arrow_Pix(PE_ArrowRight, arrowSize, arrowScaling) ; } //--- Determine arrow direction TQPixmap * arrow_pix = KPE_ListViewExpander_ArrowLeft ; if (flags & Style_On) arrow_pix = KPE_ListViewExpander_ArrowRight ; //--- Determine arrow color painter->setPen(group.mid()); //--- Draw arrow pixmap painter->drawPixmap(frame, *arrow_pix ); break ; /* End of METHOD 2a */ //-------------------------------------------------------------------- /* METHOD 2b: Generate reusable arrow pixmaps, then "bitBlt" them * / // (inspired by Asteroid CC_Slider code) //-------------------------------------------------------------------- //--- Generate reusable arrow pixmaps if (! KPE_ListViewExpander_ArrowLeft ) { KPE_ListViewExpander_ArrowLeft = Create_Arrow_Pix(PE_ArrowLeft, arrowSize, arrowScaling) ; } if (!KPE_ListViewExpander_ArrowRight ) { KPE_ListViewExpander_ArrowRight = Create_Arrow_Pix(PE_ArrowRight, arrowSize, arrowScaling) ; } //--- Determine arrow direction TQPixmap * arrow_pix = KPE_ListViewExpander_ArrowLeft ; if (flags & Style_On) arrow_pix = KPE_ListViewExpander_ArrowRight ; //--- Determine arrow color painter->setPen(group.mid()); //--- BitBlt arrow pixmap (allegedly faster) bitBlt( painter->device(), hoffset, voffset, arrow_pix, 0, 0, arrowSize, arrowSize, Qt::CopyROP, true ) ; // FIXME: draws only black arrows - maybe color needs to aready be in pixmap? break ; /* End of METHOD 2b */ //-------------------------------------------------------------------- /* METHOD 3: Generate reusable arrow images, then "draw" them * / //-------------------------------------------------------------------- //--- Generate reusable arrow images if (! iKPE_ListViewExpander_ArrowLeft ) iKPE_ListViewExpander_ArrowLeft = Create_Arrow_Image(PE_ArrowLeft, arrowSize, arrowScaling) ; if (! iKPE_ListViewExpander_ArrowRight ) iKPE_ListViewExpander_ArrowRight = Create_Arrow_Image(PE_ArrowRight, arrowSize, arrowScaling) ; //--- Determine arrow direction TQImage * arrow_img = iKPE_ListViewExpander_ArrowLeft ; if (flags & Style_On) arrow_img = iKPE_ListViewExpander_ArrowRight ; //--- Determine arrow color painter->setPen(group.mid()); //--- Draw arrow image painter->drawImage(frame, *arrow_img ); break /* End of METHOD 3 */ ; //-------------------------------------------------------------------- /* METHOD 4a: Draw +|- instead of arrows (cribbed from Plastik) * / //-------------------------------------------------------------------- arrowSize = ARROW_Size2 ; arrowScaling = 0 ; vdelta = ( h - arrowSize ) ; hdelta = ( w - arrowSize ) ; voffset = y + vdelta / 2 ; // vertical alignment: centered hoffset = x + hdelta / 2 ; // horizontal alignment: centered frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ; // Typical Windows style expand/collapse element. int radius = (frame.width() - 4) / 2; int centerx = rect.x() + rect.width()/2; int centery = rect.y() + rect.height()/2; // Outer box painter->setPen( group.mid() ); painter->drawRect( frame ); // plus or minus painter->setPen( group.text() ); painter->drawLine( centerx - radius, centery, centerx + radius, centery ); if ( flags & Style_On ) // Collapsed = On painter->drawLine( centerx, centery - radius, centerx, centery + radius ); break ; /* End of METHOD 4a */ //-------------------------------------------------------------------- /* METHOD 4b: Draw +|- instead of arrows (cribbed from Plastik) * / //-------------------------------------------------------------------- TQPen mypen ; mypen.setWidth(1) ; mypen.setColor(black) ; painter->setPen(mypen) ; //frame = TQRect(hoffset-1, voffset-1, arrowSize, arrowSize) ; int radius = frame.width() / 2 ; int centerx = rect.x() + rect.width()/2; int centery = rect.y() + rect.height()/2 ; painter->drawRect( frame ); painter->drawLine( centerx - radius , centery, centerx + radius, centery ); if (flags & Style_On) painter->drawLine( centerx, centery - radius, centerx, centery + radius ) ; break ; /* End of METHOD 4b */ //-------------------------------------------------------------------- /* Previous code: * / //-------------------------------------------------------------------- if (flags & Style_On) { // drawArrow(painter, rect, PE_ArrowRight, -(QT3SCALE-0)) ; drawArrow(painter, TQRect(x+offset, y+offset, arrowSize, arrowSize), PE_ArrowRight, 1 ); // painter->drawPixmap(x+w/2-4, y+h/2-4, rexpand); } else { drawArrow(painter, rect, PE_ArrowLeft, -(QT3SCALE-0)) ; // painter->drawPixmap(x+w/2-4, y+h/2-4, dexpand); } break ; /* End of previous code */ } case KPE_ListViewBranch: painter->setPen(group.mid()); if (flags & Style_Horizontal) { painter->drawLine(x, cy, x2, cy); } else { painter->drawLine(cx, y, cx, y2); } break; case KPE_SliderGroove: { if (ceData.orientation == TQt::Horizontal) { y = cy - 3; h = 7; } else { x = cx - 3; w = 7; } drawPhasePanel(painter, x, y, w, h, group, true, &group.brush(TQColorGroup::Mid)); break; } case KPE_SliderHandle: { TQColor color = (flags & Style_MouseOver) ? TQColor(group.button().light(contrast)) : group.button(); if (ceData.orientation == TQt::Horizontal) { drawPhaseBevel(painter, cx-5, y, 6, h, group, color, false, false, false); drawPhaseBevel(painter, cx, y, 6, h, group, color, false, false, false); } else { drawPhaseBevel(painter, x, cy-5, w, 6, group, color, false, true, false); drawPhaseBevel(painter, x, cy, w, 6, group, color, false, true, false); } break; } default: TDEStyle::drawTDEStylePrimitive(element, painter, ceData, elementFlags, rect, group, flags, option, widget); } } ////////////////////////////////////////////////////////////////////////////// // drawControl() // ------------- // Draw the control void Phase2Style::drawControl(TQ_ControlElement element, TQPainter *painter, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &rect, const TQColorGroup &group, SFlags flags, const TQStyleOption &option, const TQWidget *widget) const { bool active, enabled, depress; int x, y, w, h, x2, y2, dx; TQMenuItem *mi; TQIconSet::Mode mode; TQIconSet::State state; TQPixmap pixmap; rect.rect(&x, &y, &w, &h); x2 = rect.right(); y2 = rect.bottom(); switch (element) { case CE_PushButton: { depress = flags & (Style_Down | Style_On); int bd = pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget) + 1; if ((flags & Style_ButtonDefault) && !depress) { drawPhasePanel(painter, x, y, w, h, group, true, &group.brush(TQColorGroup::Mid)); drawPhaseBevel(painter, x+bd, y+bd, w-bd*2, h-bd*2, group, (flags & Style_MouseOver) ? TQColor(group.button().light(contrast)) : group.button(), false, false, false); } else { drawPhaseButton(painter, x, y, w, h, group, (flags & Style_MouseOver) ? TQColor(group.button().light(contrast)) : group.button(), depress); } if (flags & Style_HasFocus) { // draw focus drawPrimitive(PE_FocusRect, painter, ceData, elementFlags, subRect(SR_PushButtonFocusRect, ceData, elementFlags, widget), group, flags); } break; } case CE_PushButtonLabel: { const TQPushButton* button = ::tqqt_cast(widget); if (!button) { TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group, flags, option, widget); return; } active = button->isOn() || button->isDown(); if (active) { // shift contents x++; y++; flags |= Style_Sunken; } if (button->isMenuButton()) { // menu indicator int dx = pixelMetric(PM_MenuButtonIndicator, ceData, elementFlags, widget); //drawPrimitive(PE_ArrowDown, painter, ceData, elementFlags, // TQRect(x+w-dx-2, y+2, dx, h-4), // group, flags, option); if (flags & Style_Enabled) { painter->setPen(green) ; } else { painter->setPen(yellow) ; } drawArrow(painter, TQRect(x+w-dx-2, y+2, dx, h-4), PE_ArrowDown, 3) ; w -= dx; } /**************************** FIXME ********************************** *********************************************************************/ if (button->iconSet() && !button->iconSet()->isNull()) { // draw icon if (button->isEnabled()) { if (button->hasFocus()) { mode = TQIconSet::Active; } else { mode = TQIconSet::Normal; } } else { mode = TQIconSet::Disabled; } if (button->isToggleButton() && button->isOn()) { state = TQIconSet::On; } else { state = TQIconSet::Off; } pixmap = button->iconSet()->pixmap(TQIconSet::Small, mode, state); if (button->text().isEmpty() && !button->pixmap()) { painter->drawPixmap(x+w/2 - pixmap.width()/2, y+h/2 - pixmap.height()/2, pixmap); } else { painter->drawPixmap(x+4, y+h/2 - pixmap.height()/2, pixmap); } x += pixmap.width() + 4; w -= pixmap.width() + 4; } if (active || button->isDefault()) { // default button for(int n=0; n<2; n++) { drawItem(painter, TQRect(x+n, y, w, h), AlignCenter | ShowPrefix, button->colorGroup(), button->isEnabled(), button->pixmap(), button->text(), -1, (button->isEnabled()) ? &button->colorGroup().buttonText() : &button->colorGroup().mid()); } } else { // normal button drawItem(painter, TQRect(x, y, w, h), AlignCenter | ShowPrefix, button->colorGroup(), button->isEnabled(), button->pixmap(), button->text(), -1, (button->isEnabled()) ? &button->colorGroup().buttonText() : &button->colorGroup().mid()); } break; } case CE_CheckBoxLabel: case CE_RadioButtonLabel: { const TQButton *b = ::tqqt_cast(widget); if (!b) return; int alignment = reverse_ ? AlignRight : AlignLeft; drawItem(painter, rect, alignment | AlignVCenter | ShowPrefix, group, flags & Style_Enabled, b->pixmap(), b->text()); // only draw focus if content (forms on html won't) if ((flags & Style_HasFocus) && ((!b->text().isNull()) || b->pixmap())) { drawPrimitive(PE_FocusRect, painter, ceData, elementFlags, visualRect(subRect(SR_RadioButtonFocusRect, ceData, elementFlags, widget), ceData, elementFlags), group, flags); } break; } case CE_DockWindowEmptyArea: { const TQToolBar *tb = ::tqqt_cast(widget); if (tb) { // toolbar not floating or in a TQMainWindow if (flatToolbar(ceData, elementFlags, tb)) { if (tb->backgroundMode() == PaletteButton) // force default button color to background color painter->fillRect(rect, group.background()); else painter->fillRect(rect, tb->paletteBackgroundColor()); } } break; } case CE_MenuBarEmptyArea: drawPhaseGradient(painter, TQRect(x, y, w, h), group.background(), (w(widget); if (!mbar) { TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group, flags, option, widget); return; } mi = option.menuItem(); TQRect prect = mbar->rect(); if ((flags & Style_Active) && (flags & Style_HasFocus)) { if (flags & Style_Down) { drawPhasePanel(painter, x, y, w, h, group, true, &group.brush(TQColorGroup::Background)); } else { drawPhaseBevel(painter, x, y, w, h, group, group.background(), false, false, false); } } else { drawPhaseGradient(painter, rect, group.background(), false, x, y, prect.width()-2, prect.height()-2, false); } drawItem(painter, rect, AlignCenter | AlignVCenter | DontClip | ShowPrefix | SingleLine, group, flags & Style_Enabled, mi->pixmap(), mi->text()); break; } case CE_PopupMenuItem: { if (!ceData.widgetObjectTypes.contains(TQPOPUPMENU_OBJECT_NAME_STRING)) { TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group, flags, option, widget); return; } // We'll need these values for both arrows and text, so define them here int arrowSize = ARROW_Size2 ; int arrowRmargin = arrowSize / 2 ; mi = option.menuItem(); if (!mi) { painter->fillRect(rect, group.button()); break; } int tabwidth = option.tabWidth(); int checkwidth = option.maxIconWidth(); bool checkable = (elementFlags & CEF_IsCheckable); bool etchtext = styleHint(SH_EtchDisabledText, ceData, elementFlags); active = flags & Style_Active; enabled = mi->isEnabled(); TQRect vrect; if (checkable) checkwidth = TQMAX(checkwidth, 20); // draw background if (active && enabled) { painter->fillRect(x, y, w, h, group.highlight()); } else if (!ceData.bgPixmap.isNull()) { painter->drawPixmap(x, y, ceData.bgPixmap, x, y, w, h); } else { painter->fillRect(x, y, w, h, group.background()); } // draw separator if (mi->isSeparator()) { painter->setPen(group.dark()); painter->drawLine(x+checkwidth+1, y+1, x2-checkwidth-1, y+1); painter->setPen(group.mid()); painter->drawLine(x+checkwidth, y, x2-checkwidth-1, y); painter->drawPoint(x+checkwidth, y+1); painter->setPen(group.midlight()); painter->drawLine(x+checkwidth+1, y2, x2-checkwidth, y2); painter->drawPoint(x2-checkwidth, y2-1); break; } // draw icon if (mi->iconSet() && !mi->isChecked()) { if (active) mode = enabled ? TQIconSet::Active : TQIconSet::Disabled; else mode = enabled ? TQIconSet::Normal : TQIconSet::Disabled; pixmap = mi->iconSet()->pixmap(TQIconSet::Small, mode); TQRect pmrect(0, 0, pixmap.width(), pixmap.height()); vrect = visualRect(TQRect(x, y, checkwidth, h), rect); pmrect.moveCenter(vrect.center()); painter->drawPixmap(pmrect.topLeft(), pixmap); } // draw check if (mi->isChecked()) { drawPrimitive(PE_MenuItemIndicatorCheck, painter, ceData, elementFlags, TQRect(x, y, checkwidth, h), group, flags, option); } // draw text int xm = ITEMFRAME + checkwidth + ITEMHMARGIN; int xp = reverse_ ? x + tabwidth + RIGHTBORDER + ITEMHMARGIN + ITEMFRAME - 1 : x + xm; int offset = reverse_ ? -1 : 1; int tw = w - xm - tabwidth - (arrowSize + arrowRmargin) - ITEMHMARGIN * 3 - ITEMFRAME + 1 ; painter->setPen(enabled ? (active ? group.highlightedText() : group.buttonText()) : group.mid()); if (mi->custom()) { // draws own label painter->save(); if (etchtext && !enabled && !active) { painter->setPen(group.light()); mi->custom()->paint(painter, group, active, enabled, xp+offset, y+ITEMVMARGIN+1, tw, h-2*ITEMVMARGIN); painter->setPen(group.mid()); } mi->custom()->paint(painter, group, active, enabled, xp, y+ITEMVMARGIN, tw, h-2*ITEMVMARGIN); painter->restore(); } else { // draw label TQString text = mi->text(); if (!text.isNull()) { int t = text.find('\t'); int tflags = AlignVCenter | DontClip | ShowPrefix | SingleLine | (reverse_ ? AlignRight : AlignLeft); if (t >= 0) { int tabx = reverse_ ? x + RIGHTBORDER + ITEMHMARGIN + ITEMFRAME : x + w - tabwidth - RIGHTBORDER - ITEMHMARGIN - ITEMFRAME; // draw right label (accerator) if (etchtext && !enabled) { // etched painter->setPen(group.light()); painter->drawText(tabx+offset, y+ITEMVMARGIN+1, tabwidth, h-2*ITEMVMARGIN, tflags, text.mid(t+1)); painter->setPen(group.mid()); } painter->drawText(tabx, y+ITEMVMARGIN, tabwidth, h-2*ITEMVMARGIN, tflags, text.mid(t+1)); text = text.left(t); } // draw left label if (etchtext && !enabled) { // etched painter->setPen(group.light()); painter->drawText(xp+offset, y+ITEMVMARGIN+1, tw, h-2*ITEMVMARGIN, tflags, text, t); painter->setPen(group.mid()); } painter->drawText(xp, y+ITEMVMARGIN, tw, h-2*ITEMVMARGIN, tflags, text, t); } else if (mi->pixmap()) { // pixmap as label pixmap = *mi->pixmap(); if (pixmap.depth() == 1) painter->setBackgroundMode(Qt::OpaqueMode); dx = ((w - pixmap.width()) / 2) + ((w - pixmap.width()) % 2); painter->drawPixmap(x+dx, y+ITEMFRAME, pixmap); if (pixmap.depth() == 1) painter->setBackgroundMode(Qt::TransparentMode); } } if (mi->popup()) { // draw submenu arrow TQ_PrimitiveElement arrow = reverse_ ? PE_ArrowLeft : PE_ArrowRight; // arrowSize & arrowRmargin were defined earlier int arrowScaling = 1 ; int vdelta = ( h - arrowSize ) ; int hdelta = ( w - arrowSize - arrowRmargin ) ; int voffset = y + vdelta / 2 ; // vertical alignment: centered int hoffset = x + hdelta ; // horizontal alignment: right TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ; /* CUT - Debugging statements fprintf(stderr, "Rectangle pos (size): V - %3d + %3d x H - %3d + %3d\n", x, h, y, w ); fprintf(stderr, "Arrow position (siz): V - %3d + %3d x H- %3d + %3d\n", voffset, arrowSize, hoffset, arrowSize ); //fprintf(stderr, " or at %d (h) x %d (v)\n", vrect.left(), vrect.top()); CUT */ if (flags & Style_Enabled) { painter->setPen(black) ; } else { painter->setPen(group.mid()); } drawArrow(painter, frame, arrow, arrowScaling ); //-------------------------------------------------------------------- /* Previous code: * / //-------------------------------------------------------------------- int dim = (h-2*ITEMFRAME) / 2; vrect = visualRect(TQRect(x + w - ARROWMARGIN - ITEMFRAME - dim, y + h / 2 - dim / 2, dim, dim), rect); // drawPrimitive(arrow, painter, ceData, elementFlags, vrect, group, // enabled ? Style_Enabled : Style_Default); if (flags & Style_Enabled) { painter->setPen(red) ; } else { painter->setPen(group.mid()); } drawArrow(painter, vrect, arrow, -3+(QT3SCALE*3)) ; // drawArrow(painter, vrect, arrow, 3) ; /* End of previous code */ } break; } case CE_TabBarTab: { if (ceData.widgetObjectTypes.contains(TQTABBAR_OBJECT_NAME_STRING)) { // this guy can get complicated, we we do it elsewhere drawPhaseTab(painter, x, y, w, h, group, ceData, elementFlags, option, flags); } else { // not a tabbar TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group, flags, option, widget); return; } break; } case CE_ProgressBarGroove: { drawPhasePanel(painter, x, y, w, h, group, true, &group.brush(TQColorGroup::Base)); break; } case CE_ProgressBarContents: { if (!ceData.widgetObjectTypes.contains(TQPROGRESSBAR_OBJECT_NAME_STRING)) { TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group, flags, option, widget); return; } subRect(SR_ProgressBarContents, ceData, elementFlags, widget).rect(&x, &y, &w, &h); painter->setBrush(group.brush(TQColorGroup::Highlight)); painter->setPen(group.dark()); if (!ceData.totalSteps) { // busy indicator int bar = pixelMetric(PM_ProgressBarChunkWidth, ceData, elementFlags, widget) + 2; int progress = ceData.currentStep % ((w-bar) * 2); if (progress > (w-bar)) progress = 2 * (w-bar) - progress; painter->drawRect(x+progress+1, y+1, bar-2, h-2); } else { double progress = static_cast(ceData.currentStep) / static_cast(ceData.totalSteps); dx = static_cast(w * progress); if (dx < 4) break; if (reverse_) x += w - dx; painter->drawRect(x+1, y+1, dx-2, h-2); } break; } case CE_ToolBoxTab: { const TQToolBox *box = ::tqqt_cast(widget); if (!box) { TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group, flags, option, widget); return; } const int rx = x2 - 20; const int cx = rx - h + 1; TQPointArray parray(6); parray.putPoints(0, 6, x-1,y, cx,y, rx-2,y2-2, x2+1,y2-2, x2+1,y2+2, x-1,y2+2); if (box->currentItem() && (flags & Style_Selected)) { painter->setPen(group.dark()); painter->setBrush(box->currentItem()->paletteBackgroundColor()); painter->drawConvexPolygon(parray, 0, 6); painter->setBrush(NoBrush); } else { painter->setClipRegion(parray, TQPainter::CoordPainter); drawPhaseGradient(painter, rect, group.background(), false, 0, 0, 0, h*2, false); painter->setClipping(false); painter->drawPolyline(parray, 0, 4); } parray.putPoints(0, 4, x,y+1, cx,y+1, rx-2,y2-1, x2,y2-1); painter->setPen(group.midlight()); painter->drawPolyline(parray, 0, 4); break; } default: TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group, flags, option, widget); } } ////////////////////////////////////////////////////////////////////////////// // drawControlMask() // ----------------- // Draw a bitmask for the element void Phase2Style::drawControlMask(TQ_ControlElement element, TQPainter *painter, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &rect, const TQStyleOption &option, const TQWidget *widget) const { switch (element) { case CE_PushButton: painter->fillRect(rect, TQt::color1); painter->setPen(TQt::color0); break; default: TDEStyle::drawControlMask(element, painter, ceData, elementFlags, rect, option, widget); } } ////////////////////////////////////////////////////////////////////////////// // drawComplexControl() // -------------------- // Draw a complex control void Phase2Style::drawComplexControl(TQ_ComplexControl control, TQPainter *painter, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQRect &rect, const TQColorGroup &group, SFlags flags, SCFlags controls, SCFlags active, const TQStyleOption &option, const TQWidget *widget) const { bool down = flags & Style_Down; bool on = flags & Style_On; bool raised = flags & Style_Raised; bool sunken = flags & Style_Sunken; TQRect subrect; int x, y, w, h, x2, y2; rect.rect(&x, &y, &w, &h); switch (control) { case CC_ComboBox: { sunken = (active == SC_ComboBoxArrow); drawPhaseButton(painter, x, y, w, h, group, (flags & Style_MouseOver) ? TQColor(group.button().light(contrast)) : group.button(), sunken); if (controls & SC_ComboBoxArrow) { // draw arrow box TQ_PrimitiveElement arrow = PE_ArrowDown; int arrowSize = ARROW_Size2 ; int arrowRmargin = arrowSize / 2 ; int arrowScaling = 0 ; int vdelta = ( h - arrowSize ) ; int hdelta = ( w - arrowSize - arrowRmargin ) ; int voffset = y + vdelta / 2 ; // vertical alignment: centered int hoffset = x + hdelta ; // horizontal alignment: right TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ; painter->setPen(darkBlue); drawArrow(painter, frame, arrow, arrowScaling ); //-------------------------------------------------------------------- /* Previous code: * / //-------------------------------------------------------------------- subrect = visualRect(querySubControlMetrics(CC_ComboBox, ceData, elementFlags, SC_ComboBoxArrow, TQStyleOption::Default, widget), ceData, elementFlags); subrect.rect(&x, &y, &w, &h); int slot = TQMAX(h/4, 6) + (h % 2); drawPhasePanel(painter, x+3, y+(h/2)-(slot/2), w-6, slot, group, true, sunken ? &group.brush(TQColorGroup::Midlight) : &group.brush(TQColorGroup::Mid)); /* End of previous code */ } if (controls & SC_ComboBoxEditField) { // draw edit box if (elementFlags & CEF_IsEditable) { // editable box subrect = visualRect(querySubControlMetrics(CC_ComboBox, ceData, elementFlags, SC_ComboBoxEditField, TQStyleOption::Default, widget), ceData, elementFlags); x2 = subrect.right(); y2 = subrect.bottom(); painter->setPen(group.dark()); painter->drawLine(x2+1, y, x2+1, y2); painter->setPen(group.midlight()); painter->drawLine(x2+2, y, x2+2, y2-1); painter->setPen(group.button()); painter->drawPoint(x2+2, y2); } else if (elementFlags & CEF_HasFocus) { // non editable box subrect = visualRect(subRect(SR_ComboBoxFocusRect, ceData, elementFlags, widget), ceData, elementFlags); drawPrimitive(PE_FocusRect, painter, ceData, elementFlags, subrect, group, Style_FocusAtBorder, TQStyleOption(group.highlight())); } } painter->setPen(group.buttonText()); // for subsequent text break; } case CC_ScrollBar: { // always a three button scrollbar TQRect srect; bool horizontal = (ceData.orientation == TQt::Horizontal); SFlags scrollflags = (horizontal ? Style_Horizontal : Style_Default); if (ceData.minSteps == ceData.maxSteps) scrollflags |= Style_Default; else scrollflags |= Style_Enabled; // addline if (controls & SC_ScrollBarAddLine) { srect = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddLine, option, widget); if (srect.isValid()) drawPrimitive(PE_ScrollBarAddLine, painter, ceData, elementFlags, srect, group, scrollflags | ((active == SC_ScrollBarAddLine) ? Style_Down : Style_Default)); } // subline (two of them) if (controls & SC_ScrollBarSubLine) { // top/left subline srect = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubLine, option, widget); if (srect.isValid()) drawPrimitive(PE_ScrollBarSubLine, painter, ceData, elementFlags, srect, group, scrollflags | ((active == SC_ScrollBarSubLine) ? Style_Down : Style_Default)); // bottom/right subline srect = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddLine, option, widget); if (srect.isValid()) { if (horizontal) srect.moveBy(-srect.width()+1, 0); else srect.moveBy(0, -srect.height()+1); drawPrimitive(PE_ScrollBarSubLine, painter, ceData, elementFlags, srect, group, scrollflags | ((active == SC_ScrollBarSubLine) ? Style_Down : Style_Default)); } } // addpage if (controls & SC_ScrollBarAddPage) { srect = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddPage, option, widget); if (srect.isValid()) { if (horizontal) srect.addCoords(1, 0, 1, 0); else srect.addCoords(0, 1, 0, 1); drawPrimitive(PE_ScrollBarAddPage, painter, ceData, elementFlags, srect, group, scrollflags | ((active == SC_ScrollBarAddPage) ? Style_Down : Style_Default)); } } // subpage if (controls & SC_ScrollBarSubPage) { srect = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubPage, option, widget); if (srect.isValid()) { drawPrimitive(PE_ScrollBarSubPage, painter, ceData, elementFlags, srect, group, scrollflags | ((active == SC_ScrollBarSubPage) ? Style_Down : Style_Default)); } } // slider if (controls & SC_ScrollBarSlider) { if (ceData.minSteps == ceData.maxSteps) { // maxed out srect = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarGroove, option, widget); } else { srect = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSlider, option, widget); } if (srect.isValid()) { if (horizontal) srect.addCoords(0, 0, 1, 0); else srect.addCoords(0, 0, 0, 1); drawPrimitive(PE_ScrollBarSlider, painter, ceData, elementFlags, srect, group, scrollflags | ((active == SC_ScrollBarSlider) ? Style_Down : Style_Default)); // focus if (elementFlags & CEF_HasFocus) { srect.addCoords(2, 2, -2, -2); drawPrimitive(PE_FocusRect, painter, ceData, elementFlags, srect, group, Style_Default); } } } break; } case CC_SpinWidget: { //-Former experiment: #include "plastik-CC_SpinWidget.cpp" const TQSpinWidget *spin = ::tqqt_cast(widget); if (!spin) { TDEStyle::drawComplexControl(control, painter, ceData, elementFlags, rect, group, flags, controls, active, option, widget); return; } TQ_PrimitiveElement element; // draw frame if (controls & SC_SpinWidgetFrame) { drawPhasePanel(painter, x, y, w, h, group, true, NULL); } // draw button field if (controls & SC_SpinWidgetButtonField) { subrect = querySubControlMetrics(CC_SpinWidget, ceData, elementFlags, SC_SpinWidgetButtonField, option, widget); if (reverse_) subrect.moveLeft(spin->upRect().left()); drawPhaseBevel(painter, subrect.x(), subrect.y(), subrect.width(), subrect.height(), group, (flags & Style_MouseOver) ? TQColor(group.button().light(contrast)) : group.button(), false, false, false); } // draw up arrow if (controls & SC_SpinWidgetUp) { subrect = spin->upRect(); sunken = (active == SC_SpinWidgetUp); if (spin->buttonSymbols() == TQSpinWidget::PlusMinus) element = PE_SpinWidgetPlus; else element = PE_SpinWidgetUp; drawPrimitive(element, painter, ceData, elementFlags, subrect, group, flags | ((active == SC_SpinWidgetUp) ? Style_On | Style_Sunken : Style_Raised)); } // draw down button if (controls & SC_SpinWidgetDown) { subrect = spin->downRect(); sunken = (active == SC_SpinWidgetDown); if (spin->buttonSymbols() == TQSpinWidget::PlusMinus) element = PE_SpinWidgetMinus; else element = PE_SpinWidgetDown; drawPrimitive(element, painter, ceData, elementFlags, subrect, group, flags | ((active == SC_SpinWidgetDown) ? Style_On | Style_Sunken : Style_Raised)); } break; } case CC_ToolButton: { const TQToolButton *btn = ::tqqt_cast(widget); TQToolBar *toolbar; bool horiz = true; bool normal = !(down || on || raised); // normal button state x2 = rect.right(); y2 = rect.bottom(); // check for TQToolBar parent if (ceData.parentWidgetData.widgetObjectTypes.contains(TQTOOLBAR_OBJECT_NAME_STRING)) { toolbar = (btn)?::tqqt_cast(btn->parent()):NULL; horiz = (ceData.toolBarData.orientation == TQt::Horizontal); if (normal) { // draw background if (toolbar && flatToolbar(ceData, elementFlags, toolbar)) { // toolbar not floating or in a TQMainWindow painter->fillRect(rect, group.background()); } else { drawPhaseGradient(painter, rect, group.background(), !horiz, 0, 0, ceData.parentWidgetData.rect.width()-3, ceData.parentWidgetData.rect.height()-3, true); painter->setPen(group.mid()); if (horiz) { painter->drawLine(x, y2, x2, y2); } else { painter->drawLine(x2, y, x2, y2); } } } } // check for TQToolBarExtensionWidget parent else if (btn && ceData.parentWidgetData.widgetObjectTypes.contains(TQTOOLBAREXTENSION)) { TQWidget *extension; if ((extension = ::tqqt_cast(btn->parent()))) { toolbar = ::tqqt_cast(extension->parent()); if (toolbar) { horiz = (toolbar->orientation() == Qt::Horizontal); if (normal) { // draw background drawPhaseGradient(painter, rect, group.background(), !horiz, 0, 0, toolbar->width()-3, toolbar->height()-3, true); } } } } // check for background pixmap else if (normal && !ceData.parentWidgetData.bgPixmap.isNull()) { TQPixmap pixmap = ceData.parentWidgetData.bgPixmap; painter->drawTiledPixmap(rect, pixmap, ceData.pos); } // everything else else if (normal) { // toolbutton not on a toolbar painter->fillRect(rect, group.background()); } // now draw active buttons if (down || on) { drawPhasePanel(painter, x, y, w, h, group, true, &group.brush(TQColorGroup::Button)); } else if (raised) { drawPhaseBevel(painter, x, y, w, h, group, group.button(), false, !horiz, true); } painter->setPen(group.text()); break; } default: TDEStyle::drawComplexControl(control, painter, ceData, elementFlags, rect, group, flags, controls, active, option, widget); break; } } ////////////////////////////////////////////////////////////////////////////// // drawComplexControlMask() // ------------------------ // Draw a bitmask for the control void Phase2Style::drawComplexControlMask(TQ_ComplexControl control, TQPainter *painter, const TQStyleControlElementData &ceData, const ControlElementFlags elementFlags, const TQRect &rect, const TQStyleOption &option, const TQWidget *widget) const { switch (control) { case CC_ComboBox: case CC_ToolButton: { painter->fillRect(rect, TQt::color1); painter->setPen(TQt::color0); break; } default: TDEStyle::drawComplexControlMask(control,painter,ceData,elementFlags,rect,option,widget); } } ////////////////////////////////////////////////////////////////////////////// // pixelMetric() // ------------- // Get the pixel metric for metric int Phase2Style::pixelMetric(PixelMetric metric, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQWidget *widget) const { // not using widget's font, so that all metrics are uniform int em = FONT_Size ; //-Instead of: int em = TQMAX(TQApplication::fontMetrics().strikeOutPos() * 3, 17); switch (metric) { case PM_DefaultFrameWidth: return 2; //*QT3SCALE; case PM_ButtonDefaultIndicator: // size of default indicator return 2*FONT_Scale; case PM_ButtonMargin: // Space betweeen frame and label return 3*FONT_Scale; case PM_TabBarTabOverlap: // Amount of tab overlap return 1*FONT_Scale; case PM_TabBarTabHSpace: // extra tab spacing return 24*FONT_Scale; case PM_TabBarTabVSpace: if (ceData.widgetObjectTypes.contains(TQTABBAR_OBJECT_NAME_STRING)) { if (ceData.tabBarData.shape == TQTabBar::RoundedAbove) { return 10*FONT_Scale; } else { return 6*FONT_Scale; } } return 0; case PM_ExclusiveIndicatorWidth: // radiobutton size case PM_ExclusiveIndicatorHeight: case PM_IndicatorWidth: // checkbox size case PM_IndicatorHeight: case PM_CheckListButtonSize: // checkbox size in qlistview items case PM_ScrollBarExtent: // base width of a vertical scrollbar return em & 0xfffe; case PM_SplitterWidth: // width of spitter return (em / 3) & 0xfffe; case PM_ScrollBarSliderMin: // minimum length of slider return em * 2; case PM_SliderThickness: // slider thickness case PM_SliderControlThickness: return em; case PM_MenuIndicatorFrameHBorder: case PM_MenuIndicatorFrameVBorder: case PM_MenuIconIndicatorFrameHBorder: case PM_MenuIconIndicatorFrameVBorder: return ITEMFRAME*FONT_Scale; default: return TDEStyle::pixelMetric(metric, ceData, elementFlags, widget)*FONT_Scale; } } ////////////////////////////////////////////////////////////////////////////// // subRect() // --------- // Return subrect for the widget in logical coordinates TQRect Phase2Style::subRect(SubRect rect, const TQStyleControlElementData &ceData, const ControlElementFlags elementFlags, const TQWidget *widget) const { switch (rect) { case SR_ComboBoxFocusRect: { TQRect r = querySubControlMetrics(CC_ComboBox, ceData, elementFlags, SC_ComboBoxEditField, TQStyleOption::Default, widget); r.addCoords(1, 1,-1,-1); return r; } default: return TDEStyle::subRect(rect, ceData, elementFlags, widget); } } ////////////////////////////////////////////////////////////////////////////// // querySubControlMetrics() // ------------------------ // Get metrics for subcontrols of complex controls TQRect Phase2Style::querySubControlMetrics(TQ_ComplexControl control, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, SubControl subcontrol, const TQStyleOption &option, const TQWidget *widget) const { TQRect rect; const int fw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget); int w = ceData.rect.width(), h = ceData.rect.height(); int xc; switch (control) { case CC_ComboBox: { xc = h; // position between edit and arrow switch (subcontrol) { case SC_ComboBoxFrame: // total combobox area rect = ceData.rect; break; case SC_ComboBoxArrow: // the right side rect.setRect(w-xc, fw, xc-fw, h-(fw*2)); break; case SC_ComboBoxEditField: // the left side rect.setRect(fw, fw, w*FONT_Scale-xc-fw-1, h-(fw*2)); break; case SC_ComboBoxListBoxPopup: // the list popup box rect = option.rect(); break; default: break; } break; } case CC_ScrollBar: { bool horizontal = (ceData.orientation == TQt::Horizontal); rect = TDEStyle::querySubControlMetrics(control, ceData, elementFlags, subcontrol, option, widget); // adjust the standard metrics so controls can "overlap" if (subcontrol == SC_ScrollBarGroove) { if (horizontal) rect.addCoords(-1, 0, 1, 0); else rect.addCoords(0, -1, 0, 1); } break; } #if 0 /**************************** FIXME ********************************** The SpinWidgets were formerly clickable only around the base of the triangular arrow image, both of which exist near the center line of the enclosing rectangle. The problem appears to be resolved by removing the code below and falling back to the QT3 defaults. See also the corresponding draw* (PE|CC)_SpinWidget* code above. *********************************************************************/ case CC_SpinWidget: { /* fw = 2; const bool heightDividable = ((rect.height()%2) == 0); TQSize bs; if(heightDividable) bs.setHeight(TQMAX(8, (rect.height()-2)/2)); else bs.setHeight(TQMAX(8, (rect.height()-2-1)/2)); bs.setWidth(15); const int buttonsLeft = rect.right()-bs.width(); */ bool odd = ceData.rect.height() % 2; xc = (h * 3 / 4) + odd; // position between edit and arrows switch (subcontrol) { case SC_SpinWidgetButtonField: //rect.setRect(w-xc, 1, xc-1, h-2); rect.setRect(buttonsLeft, rect.top()+1, bs.width(), rect.height()-2); break; case SC_SpinWidgetEditField: rect.setRect(fw, fw, w-xc-fw, h-(fw*2)); /* rect.setRect(rect.left()+fw, rect.top()+fw, rect.width()-(bs.width()+1+2*fw), rect.height()-2*fw); */ break; case SC_SpinWidgetFrame: rect = ceData.rect; break; case SC_SpinWidgetUp: rect.setRect(w-xc, (h/2)-(odd ? 6 : 7), xc-1, 6); /* rect.setRect(buttonsLeft, rect.top()+1, bs.width(), bs.height() ); */ break; case SC_SpinWidgetDown: rect.setRect(w-xc, (h/2)+1, xc-1, odd ? 7 : 6); /* if(heightDividable) rect.setRect(buttonsLeft, rect.top()+1+bs.height(), bs.width(), rect.height()-(bs.height()+2) ); else rect.setRect(buttonsLeft, rect.top()+1+bs.height()+1, bs.width(), rect.height()-(bs.height()+2+1) ); */ break; default: break; } break; } #endif default: rect = TDEStyle::querySubControlMetrics(control, ceData, elementFlags, subcontrol, option, widget); } return rect; } ////////////////////////////////////////////////////////////////////////////// // sizeFromContents() // ------------------ // Returns the size of widget based on the contentsize TQSize Phase2Style::sizeFromContents(ContentsType contents, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQSize &contentsize, const TQStyleOption &option, const TQWidget* widget ) const { int w = contentsize.width(); int h = contentsize.height(); switch (contents) { case CT_PushButton: { const TQPushButton* button = ::tqqt_cast(widget); if (!button) { return TDEStyle::sizeFromContents(contents, ceData, elementFlags, contentsize, option, widget); } int margin = pixelMetric(PM_ButtonMargin, ceData, elementFlags, widget) + pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) + 4; w += margin + 6; // add room for bold font h += margin; // standard width and heights if (button->isDefault() || button->autoDefault()) { if (w < 80 && !button->pixmap()) w = 80; } if (h < 22) h = 22; return TQSize(w, h); } case CT_PopupMenuItem: { if (!widget || option.isDefault()) return contentsize; if (!ceData.widgetObjectTypes.contains(TQPOPUPMENU_OBJECT_NAME_STRING)) { return TDEStyle::sizeFromContents(contents, ceData, elementFlags, contentsize, option, widget); } TQMenuItem *item = option.menuItem(); if (item->custom()) { w = item->custom()->sizeHint().width(); h = item->custom()->sizeHint().height(); if (!item->custom()->fullSpan()) h += ITEMVMARGIN*2 + ITEMFRAME*2; } else if (item->widget()) { // a menu item that is a widget w = contentsize.width(); h = contentsize.height(); } else if (item->isSeparator()) { w = h = 3; } else { if (item->pixmap()) { h = TQMAX(h, item->pixmap()->height() + ITEMFRAME*2); } else { h = TQMAX(h, MINICONSIZE + ITEMFRAME*2); h = TQMAX(h, TQFontMetrics(ceData.font).height() + ITEMVMARGIN*2 + ITEMFRAME*2); } if (item->iconSet()) h = TQMAX(h, item->iconSet()-> pixmap(TQIconSet::Small, TQIconSet::Normal).height() + ITEMFRAME*2); } if (!item->text().isNull() && item->text().find('\t') >= 0) w += 12; else if (item->popup()) w += 2 * + ARROW_Size1 ; if (option.maxIconWidth() || (elementFlags & CEF_IsCheckable)) { w += TQMAX(option.maxIconWidth(), TQIconSet::iconSize(TQIconSet::Small).width()) + ITEMHMARGIN*2; } w += RIGHTBORDER; return TQSize(w, h); } default: return TDEStyle::sizeFromContents(contents, ceData, elementFlags, contentsize, option, widget); } } ////////////////////////////////////////////////////////////////////////////// // Miscellaneous // ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // flatToolbar() // ------------- // Is the toolbar "flat" bool Phase2Style::flatToolbar(const TQStyleControlElementData &ceData, const ControlElementFlags elementFlags, const TQToolBar *toolbar) const { if (!toolbar) return true; // not on a toolbar if (!toolbar->isMovingEnabled()) return true; // immobile toolbars are flat if (!toolbar->area()) return true; // not docked if (toolbar->place() == TQDockWindow::OutsideDock) return true; // ditto if (!toolbar->mainWindow()) return true; // not in a main window return false; } int Phase2Style::styleHint(StyleHint sh, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQStyleOption &opt, TQStyleHintReturn *returnData, const TQWidget *w) const { int ret; switch (sh) { case SH_MenuIndicatorColumnWidth: { int checkwidth = opt.maxIconWidth(); bool checkable = (elementFlags & CEF_IsCheckable); if (checkable) checkwidth = TQMAX(checkwidth, 20); ret = checkwidth; } break; default: ret = TDEStyle::styleHint(sh, ceData, elementFlags, opt, returnData, w); break; } return ret; } ////////////////////////////////////////////////////////////////////////////// // eventFilter() // ------------- // Grab events we are interested in. Most of this routine is to handle the // exceptions to the normal styling rules. bool Phase2Style::objectEventHandler( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void* source, TQEvent *event ) { if (ceData.widgetObjectTypes.contains(TQOBJECT_OBJECT_NAME_STRING)) { TQObject* object = reinterpret_cast(source); if (TDEStyle::objectEventHandler(ceData, elementFlags, source, event)) return true; if (!object->isWidgetType()) return false; bool horiz; int x, y, w, h; TQFrame *frame; TQToolBar *toolbar; TQWidget *widget; // painting events if (event->type() == TQEvent::Paint) { // make sure we do the most specific stuff first // TDE Toolbar Widget // patch by Daniel Brownlees if (object->parent() && !qstrcmp(object->name(), KTOOLBARWIDGET)) { if (0 == (widget = ::tqqt_cast(object))) return false; TQWidget *parent = ::tqqt_cast(object->parent()); int px = ceData.rect.x(), py = ceData.rect.y(); // find the toolbar while (parent && parent->parent() && !::tqqt_cast(parent)) { px += parent->x(); py += parent->y(); parent = ::tqqt_cast(parent->parent()); } if (!parent) return false; TQT_TQRECT_OBJECT(ceData.rect).rect(&x, &y, &w, &h); TQRect prect = parent->rect(); toolbar = ::tqqt_cast(parent); horiz = (toolbar) ? (toolbar->orientation() == Qt::Horizontal) : (prect.height() < prect.width()); TQPainter painter(widget); if (flatToolbar(ceData, elementFlags, toolbar)) { painter.fillRect(ceData.rect, parent->colorGroup().background()); } else { drawPhaseGradient(&painter, ceData.rect, parent->colorGroup().background(), !horiz, px, py, prect.width(), prect.height(), true); if (horiz && (h==prect.height()-2)) { painter.setPen(parent->colorGroup().mid()); painter.drawLine(x, h-1, w-1, h-1); } else if (!horiz && (w==prect.width()-2)) { painter.setPen(parent->colorGroup().mid()); painter.drawLine(w-1, y, w-1, h-1); } } } // TQToolBarExtensionWidget else if (object && object->isWidgetType() && object->parent() && (toolbar = ::tqqt_cast(object->parent()))) { if (0 == (widget = ::tqqt_cast(object))) return false; horiz = (toolbar->orientation() == Qt::Horizontal); TQPainter painter(widget); TQT_TQRECT_OBJECT(ceData.rect).rect(&x, &y, &w, &h); // draw the extension drawPhaseGradient(&painter, ceData.rect, toolbar->colorGroup().background(), !horiz, x, y, w-1, h-1, true); if (horiz) { painter.setPen(toolbar->colorGroup().dark()); painter.drawLine(w-1, 0, w-1, h-1); painter.setPen(toolbar->colorGroup().mid()); painter.drawLine(w-2, 0, w-2, h-2); painter.drawLine(x, h-1, w-2, h-1); painter.drawLine(x, y, x, h-2); painter.setPen(toolbar->colorGroup().midlight()); painter.drawLine(x+1, y, x+1, h-2); } else { painter.setPen(toolbar->colorGroup().dark()); painter.drawLine(0, h-1, w-1, h-1); painter.setPen(toolbar->colorGroup().mid()); painter.drawLine(0, h-2, w-2, h-2); painter.drawLine(w-1, y, w-1, h-2); painter.drawLine(x, y, w-2, y); painter.setPen(toolbar->colorGroup().midlight()); painter.drawLine(x, y+1, w-2, y+1); } } // TQFrame lines (do this guy last) else if (0 != (frame = ::tqqt_cast(object))) { TQFrame::Shape shape = frame->frameShape(); switch (shape) { case TQFrame::HLine: case TQFrame::VLine: { // NOTE: assuming lines have no content TQPainter painter(frame); TQT_TQRECT_OBJECT(frame->rect()).rect(&x, &y, &w, &h); painter.setPen(frame->colorGroup().dark()); if (shape == TQFrame::HLine) { painter.drawLine(0, h/2, w, h/2); } else if (shape == TQFrame::VLine) { painter.drawLine(w/2, 0, w/2, h); } return true; } default: break; } } } } return false; } ////////////////////////////////////////////////////////////////////////////// // GradientSet // ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // GradientSet() // ------------- // Constructor GradientSet::GradientSet(const TQColor &color, int size) : color_(color), size_(size) { for (int n=0; nresize(size_, 16); KPixmapEffect::gradient(*set[type], color_.light(contrast), color_.dark(contrast), KPixmapEffect::HorizontalGradient); break; case HorizontalReverse: set[type]->resize(size_, 16); KPixmapEffect::gradient(*set[type], color_.dark(contrast), color_.light(contrast), KPixmapEffect::HorizontalGradient); break; case Vertical: set[type]->resize(16, size_); KPixmapEffect::gradient(*set[type], color_.light(contrast), color_.dark(contrast), KPixmapEffect::VerticalGradient); break; case VerticalReverse: set[type]->resize(16, size_); KPixmapEffect::gradient(*set[type], color_.dark(contrast), color_.light(contrast), KPixmapEffect::VerticalGradient); break; default: break; } } return (set[type]); } ////////////////////////////////////////////////////////////////////////////// // Plugin Stuff // ////////////////////////////////////////////////////////////////////////////// class Phase2StylePlugin : public TQStylePlugin { public: Phase2StylePlugin(); TQStringList keys() const; TQStyle *create(const TQString &key); }; Phase2StylePlugin::Phase2StylePlugin() : TQStylePlugin() { ; } TQStringList Phase2StylePlugin::keys() const { return TQStringList() << "Phase2"; } TQStyle* Phase2StylePlugin::create(const TQString& key) { if (key.lower() == "phase2") return new Phase2Style(); return 0; } KDE_Q_EXPORT_PLUGIN(Phase2StylePlugin) #include "phase2style.moc"