TDE
/
tde-style-domino
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tde-style-domino
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8216f8447c'
${ noResults }
tde-style-domino/domino/domino.cpp

8175 lines
282 KiB
Raw Blame History Escape

/* Domino widget style for KDE 3
Copyright (C) 2006 Michael Lentner <michaell@gmx.net>
based on the KDE style "Plastik":
Copyright (C) 2003 Sandro Giessl <ceebx@users.sourceforge.net>
based on the KDE style "dotNET":
Copyright (C) 2001-2002, Chris Lee <clee@kde.org>
Carsten Pfeiffer <pfeiffer@kde.org>
Karol Szwed <gallium@kde.org>
Drawing routines completely reimplemented from KDE3 HighColor, which was
originally based on some stuff from the KDE2 HighColor.
based on drawing routines of the style "Keramik":
Copyright (c) 2002 Malte Starostik <malte@kde.org>
(c) 2002,2003 Maksim Orlovich <mo002j@mail.rochester.edu>
based on the KDE3 HighColor Style
Copyright (C) 2001-2002 Karol Szwed <gallium@kde.org>
(C) 2001-2002 Fredrik H<>glund <fredrik@kde.org>
Drawing routines adapted from the KDE2 HCStyle,
Copyright (C) 2000 Daniel M. Duley <mosfet@kde.org>
(C) 2000 Dirk Mueller <mueller@kde.org>
(C) 2001 Martijn Klingens <klingens@kde.org>
Progressbar code based on TDEStyle,
Copyright (C) 2001-2002 Karol Szwed <gallium@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <tdeglobalsettings.h>
#include <tqpainter.h>
#include <tqtabbar.h>
#include <tqprogressbar.h>
#include <tqcheckbox.h>
#include <tqlineedit.h>
#include <tqlistbox.h>
#include <tqstyleplugin.h>
#include <tqpushbutton.h>
#include <tqtoolbutton.h>
#include <tdepopupmenu.h>
#include <tqradiobutton.h>
#include <tqslider.h>
#include <tqsettings.h>
#include <kpixmap.h>
#include <tqgroupbox.h>
#include <tqmenudata.h>
#include <tqdockarea.h>
#include <tqobjectlist.h>
#include <tqheader.h>
#include <tdelistview.h>
#include <tqstatusbar.h>
#include <tqcombobox.h>
#include <tqtabwidget.h>
#include <tdetoolbar.h>
#include <tqlabel.h>
#include <tqsimplerichtext.h>
#include <tqiconview.h>
#include <tdeconfig.h>
#include <tqapplication.h>
#include <tqtoolbox.h>
#include <tqstylesheet.h>
// #include <tqsplitter.h>
#include <tqwidgetstack.h>
#include <tqtimer.h>
#include <tdemultitabbar.h>
#include <tqspinbox.h>
#include <tqcursor.h>
#include <tqtextedit.h>
#include <tdeversion.h>
#include <kimageeffect.h>
#include <X11/Xlib.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include "domino.h"
#include <X11/Xft/Xft.h>
// #include <X11/extensions/Xrender.h>
#include <X11/extensions/shape.h>
// popupmenu item constants...
static const int itemHMargin = 6;
static const int itemFrame = 7;
static const int arrowHMargin = 6;
ButtonContour::ButtonContour()
{
state = Contour_Default;
alpha_mode = false;
for(int t = 0; t < num_types; t++)
for(int s = 0; s < num_states; s++)
created[t][s] = 0;
for(int s = 0; s < num_states; s++)
shadowCreated[s] = 0;
ContourType ty;
ty = Contour_Sunken;
for(int s = 0; s < num_states; s++) {
c1[ty][s] = tqRgba(31, 31, 31, 32); // top first shadow line
c4[ty][s] = tqRgba(255, 255, 255, 78); // bottom first shadow line
c5[ty][s] = tqRgba(255, 255, 255, 30); // bottom second shadow line
c6[ty][s] = tqRgba(217, 217, 217, 34); // first left shadow line
}
ty = Contour_Raised;
for(int s = 0; s < num_states; s++) {
c1[ty][s] = tqRgba(0, 0, 0, 14); // top first shadow line
c4[ty][s] = tqRgba(0, 0, 0, 26); // bottom first shadow line
c5[ty][s] = tqRgba(0, 0, 0, 10); // bottom second shadow line
c6[ty][s] = tqRgba(0, 0, 0, 12); // first left shadow line
}
ty = Contour_Simple;
for(int s = 0; s < num_states; s++) {
c1[ty][s] = tqRgba(0, 0, 0, 0); // top first shadow line
c4[ty][s] = tqRgba(0, 0, 0, 0); // bottom first shadow line
c5[ty][s] = tqRgba(0, 0, 0, 0); // bottom second shadow line
c6[ty][s] = tqRgba(0, 0, 0, 0); // first left shadow line
}
drawButtonSunkenShadow = true;
}
ButtonContour::~ButtonContour()
{
for(int t = 0; t < num_types; t++) {
for(int s = 0; s < num_states; s++) {
if(created[t][s]) {
delete btnEdges[t][s];
delete btnVLines[t][s];
delete btnHLines[t][s];
}
}
}
for(int s = 0; s < num_states; s++) {
if(shadowCreated[s])
delete buttonShadowRectangular[s];
}
}
RubberWidget::RubberWidget(Window window )
: TQWidget()
{
setWState(WState_Disabled|WState_Polished);
TQWidget::create( window, true, true);
}
RubberWidget::~RubberWidget()
{
}
Rubber::Rubber(uint col)
{
rubber = 0;
parent = 0;
window = 0;
mask = TQRegion();
Display *dpy = tqt_xdisplay();
int screen = tqt_xscreen();
visual = 0;
colormap = 0;
int event_base, error_base;
if ( XRenderQueryExtension( dpy, &event_base, &error_base ) )
{
int nvi;
XVisualInfo templ;
templ.screen = screen;
templ.depth = 32;
templ.c_class = TrueColor;
XVisualInfo *xvi = XGetVisualInfo( dpy, VisualScreenMask | VisualDepthMask
| VisualClassMask, &templ, &nvi );
for ( int i = 0; i < nvi; i++ ) {
XRenderPictFormat *format = XRenderFindVisualFormat( dpy, xvi[i].visual );
if ( format->type == PictTypeDirect && format->direct.alphaMask ) {
visual = xvi[i].visual;
colormap = XCreateColormap( dpy, RootWindow( dpy, screen ), visual, AllocNone );
break;
}
}
}
wsa.border_pixel = 0;
wsa.colormap = colormap;
wsa.background_pixel = 0x00000000;
wsa.override_redirect = true;
color = col;
}
void Rubber::create(TQRect& r, TQRegion& m) {
if(parent)
return;
mask = m;
wsa.background_pixel = 0x00000000;
Window parentwin = XCreateWindow(tqt_xdisplay(), tqApp->desktop()->winId(), r.x(), r.y(), r.width(), r.height(), 0, 32, InputOutput, visual, CWBackPixel|CWColormap|CWBorderPixel|CWOverrideRedirect, &wsa);
parent = new RubberWidget(parentwin);
wsa.background_pixel = color;
window = XCreateWindow(tqt_xdisplay(), parentwin, 0, 0, r.width(), r.height(), 0, 32, InputOutput, visual, CWBackPixel|CWColormap|CWBorderPixel|CWOverrideRedirect, &wsa);
rubber = new RubberWidget(window);
#ifdef ShapeInput
TQBitmap bm(r.width(), r.height(), true);
XShapeCombineMask(tqt_xdisplay(), rubber->winId(), ShapeInput, 0, 0, bm.handle(), ShapeSet);
#endif
XShapeCombineRegion( tqt_xdisplay(), rubber->winId(), ShapeBounding, 0, 0, mask.handle(), ShapeSet );
rubber->show();
parent->show();
XFlush(tqt_xdisplay());
}
Rubber::~Rubber()
{
}
void Rubber::updateMask(TQRegion& m) {
if(mask != m)
XShapeCombineRegion( tqt_xdisplay(), rubber->winId(), ShapeBounding, 0, 0, m.handle(), ShapeSet );
}
// -- Style Plugin Interface -------------------------
class DominoStylePlugin : public TQStylePlugin
{
public:
DominoStylePlugin() {}
~DominoStylePlugin() {}
TQStringList keys() const {
return TQStringList() << "Domino";
}
TQStyle* create( const TQString& key ) {
if (key.lower() == "domino")
return new DominoStyle;
return 0;
}
};
KDE_Q_EXPORT_PLUGIN( DominoStylePlugin )
// -- end --
DominoStyle::DominoStyle() : TDEStyle( TDEStyle::Default /*AllowMenuTransparency*/, ThreeButtonScrollBar )
{
konsoleMode = false;
kickerMode = false;
konquerorMode = false;
flatMode = false;
viewPortPressed = false;
oldRubberRect = TQRect();
rubber = 0;
ignoreNextFocusRect = false;
#if TDE_VERSION < 0x30506
compositeManagerRunning = true;
#endif
configMode = "0"; // temporaly to avoid cache problems between the configs previewStyle and this style
spinWidgetDown = false;
popupTimer = new TQTimer(this);
TQColor background = tqApp->palette().active().background();
TQColor buttonColor = tqApp->palette().active().button();
TQColor highlight = tqApp->palette().active().highlight();
TQSettings settings;
// _contrast = settings.readNumEntry("/TQt/KDE/contrast", 0);
settings.beginGroup("/domino/Settings");
//konqTabBarContrast = 150;
konqTabBarContrast = settings.readNumEntry("/konqTabBarContrast", 15)+100;
_animateProgressBar = settings.readBoolEntry("/animateProgressBar", true);
_centerTabs = settings.readBoolEntry("/centerTabs", false);
_drawTriangularExpander = settings.readBoolEntry("/drawTriangularExpander", true);
_customCheckMarkColor = settings.readBoolEntry("/customCheckMarkColor", false);
_checkMarkColor.setNamedColor( settings.readEntry("/checkMarkColor", "black") );
groupBoxSettings.tintBackground = settings.readBoolEntry("/tintGroupBoxBackground", true);
groupBoxSettings.customColor = settings.readBoolEntry("/customGroupBoxBackgroundColor", false);
groupBoxSettings.brightness = settings.readNumEntry("/groupBoxBrightness", 10);
groupBoxSettings.color = settings.readEntry("/groupBoxBackgroundColor", darkenColor(background, 10).name());
bool customToolTipColor = settings.readBoolEntry("/customToolTipColor", false);
_toolTipColor = customToolTipColor? settings.readEntry("/toolTipColor", TQColor(218,218,179).name()) : TQColor(218,218,179);
//_toolTipColor = TQColor(255,255,220); // yellow
_smoothScrolling = settings.readBoolEntry("/smoothScrolling", true);
_buttonHeightAdjustment = settings.readNumEntry("/buttonHeightAdjustment", 0);
_customPopupMenuColor = settings.readBoolEntry("/customPopupMenuColor", false);
_popupMenuColor = _customPopupMenuColor ? settings.readEntry("/popupMenuColor", background.name()) : background.name();
_customSelMenuItemColor = settings.readBoolEntry("/customSelMenuItemColor", false);
_selMenuItemColor = _customSelMenuItemColor ? settings.readEntry("/selMenuItemColor", highlight.name()) : highlight.name();
_drawPopupMenuGradient = settings.readBoolEntry("/drawPopupMenuGradient", true);
_indentPopupMenuItems = settings.readBoolEntry("/indentPopupMenuItems", true);
_toolBtnAsBtn = settings.readBoolEntry("/drawToolButtonAsButton", true);
_highlightToolBtnIcon = settings.readBoolEntry("/highlightToolBtnIcon", false);
rubberBandType = (RubberType) settings.readNumEntry("/rubberBandType", DistRubber);
if(rubberBandType == ArgbRubber) {
int dummy;
if(XQueryExtension(tqt_xdisplay(), "Composite", &dummy, &dummy, &dummy)) {
TQColor c = settings.readEntry("/rubberBandColor", highlight.name());
int a = settings.readNumEntry("/rubberBandOpacity", 30)*255/100;
_argbRubberBandColor = tqRgba(c.red(), c.green(), c.blue(), a);
rubber = new Rubber(preMultiplyColor(_argbRubberBandColor));
}
else
rubberBandType = DistRubber;
}
focusIndicatorSettings.indicateFocus = settings.readBoolEntry("/indicateFocus", true);
if(focusIndicatorSettings.indicateFocus) {
focusIndicatorSettings.color = settings.readEntry("/indicatorColor", highlight.name());
focusIndicatorSettings.opacity = settings.readNumEntry("/indicatorColorOpacity", 60)*255/100;
focusIndicatorSettings.buttonColor = settings.readEntry("/indicatorButtonColor", highlight.name());
focusIndicatorSettings.buttonOpacity = settings.readNumEntry("/indicatorColorButtonOpacity", 60)*255/100;
}
focusIndicatorSettings.drawUnderline = settings.readBoolEntry("/drawFocusUnderline", true);
buttonContour = new ButtonContour();
buttonContour->setDefaultType((ContourType)settings.readNumEntry("/buttonContourType", Contour_Raised), false); // we need to know the ContourType to adjust the contour colors
buttonContour->setColor(Contour_Default, settings.readEntry("/buttonContourColor", background.dark(250).name()));
buttonContour->setColor(Contour_DefaultButton, settings.readEntry("/buttonDefaultContourColor", highlight.name()));
buttonContour->setColor(Contour_MouseOver, settings.readEntry("/buttonMouseOverContourColor", background.dark(250).name()));
buttonContour->setColor(Contour_Pressed, settings.readEntry("/buttonPressedContourColor", background.dark(250).name()));
buttonContour->drawButtonSunkenShadow = settings.readBoolEntry("/drawButtonSunkenShadow", true);
buttonContour->setDefaultType(buttonContour->defaultType); // create this time the tinted pixmaps
if(buttonContour->defaultType == Contour_Raised)
buttonContour->drawButtonSunkenShadow = false;
_customSliderHandleContourColor = settings.readBoolEntry("/customSliderHandleContourColor", false);
bool drawTextEffect = settings.readBoolEntry("/drawTextEffect", true);
if(drawTextEffect) {
textEffectSettings.mode = settings.readNumEntry("/textEffectMode", 0) ? TextEffect_Everywhere : TextEffect_OnlyButton;
textEffectSettings.color = settings.readEntry("/textEffectColor", TQt::white.name());
textEffectSettings.opacity = settings.readNumEntry("/textEffectOpacity", 60)*255/100;
textEffectSettings.buttonColor = settings.readEntry("/textEffectButtonColor", TQt::white.name());
textEffectSettings.buttonOpacity = settings.readNumEntry("/textEffectButtonOpacity", 60)*255/100;
int textEffectPos = settings.readNumEntry("/textEffectPos", 5);
switch(textEffectPos) {
case 0:
textEffectSettings.pos = TQPoint(-1,-1);
break;
case 1:
textEffectSettings.pos = TQPoint(0,-1);
break;
case 2:
textEffectSettings.pos = TQPoint(1,-1);
break;
case 3:
textEffectSettings.pos = TQPoint(1,0);
break;
case 4:
textEffectSettings.pos = TQPoint(1,1);
break;
case 5:
textEffectSettings.pos = TQPoint(0,1);
break;
case 6:
textEffectSettings.pos = TQPoint(-1,1);
break;
case 7:
textEffectSettings.pos = TQPoint(-1,0);
break;
default:
textEffectSettings.pos = TQPoint(0,1);
}
int textEffectButtonPos = settings.readNumEntry("/textEffectButtonPos", 5);
switch(textEffectButtonPos) {
case 0:
textEffectSettings.buttonPos = TQPoint(-1,-1);
break;
case 1:
textEffectSettings.buttonPos = TQPoint(0,-1);
break;
case 2:
textEffectSettings.buttonPos = TQPoint(1,-1);
break;
case 3:
textEffectSettings.buttonPos = TQPoint(1,0);
break;
case 4:
textEffectSettings.buttonPos = TQPoint(1,1);
break;
case 5:
textEffectSettings.buttonPos = TQPoint(0,1);
break;
case 6:
textEffectSettings.buttonPos = TQPoint(-1,1);
break;
case 7:
textEffectSettings.buttonPos = TQPoint(-1,0);
break;
default:
textEffectSettings.buttonPos = TQPoint(0,1);
}
}
else
textEffectSettings.mode = TextEffect_None;
btnSurface.numGradients = settings.readNumEntry("/btnSurface_numGradients", 2);
btnSurface.g1Color1 = settings.readEntry("/btnSurface_g1Color1", buttonColor.name());
btnSurface.g1Color2 = settings.readEntry("/btnSurface_g1Color2", buttonColor.dark(120).name());
btnSurface.g2Color1 = settings.readEntry("/btnSurface_g2Color1", buttonColor.dark(120).name());
btnSurface.g2Color2 = settings.readEntry("/btnSurface_g2Color2", buttonColor.dark(110).name());
btnSurface.background = settings.readEntry("/btnSurface_background", buttonColor.name());
btnSurface.g1Top = settings.readNumEntry("/btnSurface_g1Top", 0);
btnSurface.g1Bottom = settings.readNumEntry("/btnSurface_g1Bottom", 50);
btnSurface.g2Top = settings.readNumEntry("/btnSurface_g2Top", 50);
btnSurface.g2Bottom = settings.readNumEntry("/btnSurface_g2Bottom", 100);
activeTabTopSurface.numGradients = settings.readNumEntry("/activeTabTopSurface_numGradients", 2);
activeTabTopSurface.g1Color1 = settings.readEntry("/activeTabTopSurface_g1Color1", background.light(110).name());
activeTabTopSurface.g1Color2 = settings.readEntry("/activeTabTopSurface_g1Color2", background.name());
activeTabTopSurface.g2Color1 = settings.readEntry("/activeTabTopSurface_g2Color1", background.name());
activeTabTopSurface.g2Color2 = settings.readEntry("/activeTabTopSurface_g2Color2", background.name());
activeTabTopSurface.background = settings.readEntry("/activeTabTopSurface_background", background.name());
activeTabTopSurface.g1Top = settings.readNumEntry("/activeTabTopSurface_g1Top", 0);
activeTabTopSurface.g1Bottom = settings.readNumEntry("/activeTabTopSurface_g1Bottom", 50);
activeTabTopSurface.g2Top = settings.readNumEntry("/activeTabTopSurface_g2Top", 50);
activeTabTopSurface.g2Bottom = settings.readNumEntry("/activeTabTopSurface_g2Bottom", 100);
tabTopSurface.numGradients = settings.readNumEntry("/tabTopSurface_numGradients", 2);
tabTopSurface.g1Color1 = settings.readEntry("/tabTopSurface_g1Color1", background.light(110).name());
tabTopSurface.g1Color2 = settings.readEntry("/tabTopSurface_g1Color2", background.dark(110).name());
tabTopSurface.g2Color1 = settings.readEntry("/tabTopSurface_g2Color1", background.dark(110).name());
tabTopSurface.g2Color2 = settings.readEntry("/tabTopSurface_g2Color2", background.dark(110).name());
tabTopSurface.background = settings.readEntry("/tabTopSurface_background", background.dark(110).name());
tabTopSurface.g1Top = settings.readNumEntry("/tabTopSurface_g1Top", 0);
tabTopSurface.g1Bottom = settings.readNumEntry("/tabTopSurface_g1Bottom", 50);
tabTopSurface.g2Top = settings.readNumEntry("/tabTopSurface_g2Top", 50);
tabTopSurface.g2Bottom = settings.readNumEntry("/tabTopSurface_g2Bottom", 100);
activeTabBottomSurface.numGradients = settings.readNumEntry("/activeTabBottomSurface_numGradients", 2);
activeTabBottomSurface.g1Color1 = settings.readEntry("/activeTabBottomSurface_g1Color1", background.name());
activeTabBottomSurface.g1Color2 = settings.readEntry("/activeTabBottomSurface_g1Color2", background.name());
activeTabBottomSurface.g2Color1 = settings.readEntry("/activeTabBottomSurface_g2Color1", background.name());
activeTabBottomSurface.g2Color2 = settings.readEntry("/activeTabBottomSurface_g2Color2", background.dark(120).name());
activeTabBottomSurface.background = settings.readEntry("/activeTabBottomSurface_background", background.name());
activeTabBottomSurface.g1Top = settings.readNumEntry("/activeTabBottomSurface_g1Top", 0);
activeTabBottomSurface.g1Bottom = settings.readNumEntry("/activeTabBottomSurface_g1Bottom", 50);
activeTabBottomSurface.g2Top = settings.readNumEntry("/activeTabBottomSurface_g2Top", 50);
activeTabBottomSurface.g2Bottom = settings.readNumEntry("/activeTabBottomSurface_g2Bottom", 100);
tabBottomSurface.numGradients = settings.readNumEntry("/tabBottomSurface_numGradients", 2);
tabBottomSurface.g1Color1 = settings.readEntry("/tabBottomSurface_g1Color1", background.dark(110).name());
tabBottomSurface.g1Color2 = settings.readEntry("/tabBottomSurface_g1Color2", background.dark(110).name());
tabBottomSurface.g2Color1 = settings.readEntry("/tabBottomSurface_g2Color1", background.dark(110).name());
tabBottomSurface.g2Color2 = settings.readEntry("/tabBottomSurface_g2Color2", background.dark(120).name());
tabBottomSurface.background = settings.readEntry("/tabBottomSurface_background", background.dark(110).name());
tabBottomSurface.g1Top = settings.readNumEntry("/tabBottomSurface_g1Top", 0);
tabBottomSurface.g1Bottom = settings.readNumEntry("/tabBottomSurface_g1Bottom", 50);
tabBottomSurface.g2Top = settings.readNumEntry("/tabBottomSurface_g2Top", 50);
tabBottomSurface.g2Bottom = settings.readNumEntry("/tabBottomSurface_g2Bottom", 100);
scrollBarSurface.numGradients = settings.readNumEntry("/scrollBarSurface_numGradients", 2);
scrollBarSurface.g1Color1 = settings.readEntry("/scrollBarSurface_g1Color1", buttonColor.name());
scrollBarSurface.g1Color2 = settings.readEntry("/scrollBarSurface_g1Color2", buttonColor.dark(120).name());
scrollBarSurface.g2Color1 = settings.readEntry("/scrollBarSurface_g2Color1", buttonColor.dark(120).name());
scrollBarSurface.g2Color2 = settings.readEntry("/scrollBarSurface_g2Color2", buttonColor.dark(110).name());
scrollBarSurface.background = settings.readEntry("/scrollBarSurface_background", buttonColor.name());
scrollBarSurface.g1Top = settings.readNumEntry("/scrollBarSurface_g1Top", 0);
scrollBarSurface.g1Bottom = settings.readNumEntry("/scrollBarSurface_g1Bottom", 50);
scrollBarSurface.g2Top = settings.readNumEntry("/scrollBarSurface_g2Top", 50);
scrollBarSurface.g2Bottom = settings.readNumEntry("/scrollBarSurface_g2Bottom", 100);
scrollBarGrooveSurface.numGradients = settings.readNumEntry("/scrollBarGrooveSurface_numGradients", 0);
scrollBarGrooveSurface.g1Color1 = settings.readEntry("/scrollBarGrooveSurface_g1Color1", background.name());
scrollBarGrooveSurface.g1Color2 = settings.readEntry("/scrollBarGrooveSurface_g1Color2", background.dark(120).name());
scrollBarGrooveSurface.g2Color1 = settings.readEntry("/scrollBarGrooveSurface_g2Color1", background.dark(120).name());
scrollBarGrooveSurface.g2Color2 = settings.readEntry("/scrollBarGrooveSurface_g2Color2", background.dark(110).name());
scrollBarGrooveSurface.background = settings.readEntry("/scrollBarGrooveSurface_background", background.dark(150).name());
scrollBarGrooveSurface.g1Top = settings.readNumEntry("/scrollBarGrooveSurface_g1Top", 0);
scrollBarGrooveSurface.g1Bottom = settings.readNumEntry("/scrollBarGrooveSurface_g1Bottom", 50);
scrollBarGrooveSurface.g2Top = settings.readNumEntry("/scrollBarGrooveSurface_g2Top", 50);
scrollBarGrooveSurface.g2Bottom = settings.readNumEntry("/scrollBarGrooveSurface_g2Bottom", 100);
headerSurface.numGradients = settings.readNumEntry("/headerSurface_numGradients", 2);
headerSurface.g1Color1 = settings.readEntry("/headerSurface_g1Color1", background.name());
headerSurface.g1Color2 = settings.readEntry("/headerSurface_g1Color2", background.dark(120).name());
headerSurface.g2Color1 = settings.readEntry("/headerSurface_g2Color1", background.dark(120).name());
headerSurface.g2Color2 = settings.readEntry("/headerSurface_g2Color2", background.dark(110).name());
headerSurface.background = settings.readEntry("/headerSurface_background", background.name());
headerSurface.g1Top = settings.readNumEntry("/headerSurface_g1Top", 0);
headerSurface.g1Bottom = settings.readNumEntry("/headerSurface_g1Bottom", 50);
headerSurface.g2Top = settings.readNumEntry("/headerSurface_g2Top", 50);
headerSurface.g2Bottom = settings.readNumEntry("/headerSurface_g2Bottom", 100);
// checkBoxes + radioButtons
checkItemSurface.numGradients = settings.readNumEntry("/checkItemSurface_numGradients", 2);
checkItemSurface.g1Color1 = settings.readEntry("/checkItemSurface_g1Color1", buttonColor.name());
checkItemSurface.g1Color2 = settings.readEntry("/checkItemSurface_g1Color2", buttonColor.dark(120).name());
checkItemSurface.g2Color1 = settings.readEntry("/checkItemSurface_g2Color1", buttonColor.dark(120).name());
checkItemSurface.g2Color2 = settings.readEntry("/checkItemSurface_g2Color2", buttonColor.dark(110).name());
checkItemSurface.background = settings.readEntry("/checkItemSurface_background", buttonColor.name());
checkItemSurface.g1Top = settings.readNumEntry("/checkItemSurface_g1Top", 0);
checkItemSurface.g1Bottom = settings.readNumEntry("/checkItemSurface_g1Bottom", 50);
checkItemSurface.g2Top = settings.readNumEntry("/checkItemSurface_g2Top", 50);
checkItemSurface.g2Bottom = settings.readNumEntry("/checkItemSurface_g2Bottom", 100);
settings.endGroup();
if(!strcmp(tqApp->argv()[0], "konqueror")) {
TDEGlobal::config()->setGroup("General");
minTabLength = TDEGlobal::config()->readNumEntry("MinimumTabLength", 3);
}
else
minTabLength = 0;
if(!strcmp(tqApp->className(), "TDEApplication")) {
TQString oldgroup = TDEGlobal::config()->group();
TDEGlobal::config()->setGroup("KDE");
macStyleBar = TDEGlobal::config()->readBoolEntry("macStyle", false);
TDEGlobal::config()->setGroup(oldgroup); // reset the group, do not interfere with the application
TDEApplicationMode = true;
}
else {
macStyleBar = false;
TDEApplicationMode = false;
}
hoverWidget = 0;
horizontalLine = 0;
verticalLine = 0;
sideRepaint = 0;
hoveredToolBoxTab = 0;
checkMark = createCheckMark(_customCheckMarkColor? _checkMarkColor : tqApp->palette().active().foreground());
radioIndicator = createRadioIndicator(_customCheckMarkColor? _checkMarkColor : tqApp->palette().active().foreground());
popupFrame = new TQPixmap(tintImage(qembed_findImage("popup5"), _popupMenuColor.dark(150) ));
// setup pixmap cache...
pixmapCache = new TQIntCache<CacheEntry>(150000, 499);
pixmapCache->setAutoDelete(true);
if ( _animateProgressBar )
{
animationTimer = new TQTimer( this );
connect( animationTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(updateProgressPos()) );
}
scrollDistance = 0;
scrollWidget = 0;
scrollTimer = new TQTimer(this);
connect( scrollTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(updateScrollPos()) );
TQColor tabContour2 = tqApp->palette().active().background().dark(150);
border1= new TQPixmap(tintImage(qembed_findImage("border1"), tabContour2));
}
void DominoStyle::updateProgressPos()
{
TQProgressBar* pb;
//Update the registered progressbars.
TQMap<TQWidget*, int>::iterator iter;
bool visible = false;
for (iter = progAnimWidgets.begin(); iter != progAnimWidgets.end(); iter++)
{
if ( !dynamic_cast<TQProgressBar*>(iter.key()) )
continue;
pb = dynamic_cast<TQProgressBar*>(iter.key());
if ( iter.key() -> isEnabled() &&
pb->progress() != pb->totalSteps() && pb->progress())
{
// update animation Offset of the current Widget
iter.data() = (iter.data() + 1) % 20;
iter.key()->update();
}
if (iter.key()->isVisible())
visible = true;
}
if (!visible)
animationTimer->stop();
}
void DominoStyle::updateScrollPos()
{
if(dynamic_cast<TQScrollView*>(scrollWidget) && scrollDistance != 0) {
int scroll;
if(scrollDistance < 0) {
if(scrollDistance < -200)
scroll = +45;
else if(scrollDistance < -100)
scroll = +30;
else
scroll = +15;
scrollDistance += scroll;
scrollDistance = TQMIN(scrollDistance, 0);
}
else {
if(scrollDistance > 200)
scroll = -45;
else if(scrollDistance > 100)
scroll = -30;
else
scroll = -15;
scrollDistance += scroll;
scrollDistance = TQMAX(scrollDistance, 0);
}
if(scrollVertical)
scrollWidget->scrollBy(0, scroll);
else
scrollWidget->scrollBy(scroll, 0);
}
else if(scrollTimer->isActive()) {
scrollTimer->stop();
}
}
DominoStyle::~DominoStyle()
{
delete pixmapCache;
delete horizontalLine;
delete verticalLine;
delete checkMark;
delete radioIndicator;
delete border1;
delete popupFrame;
delete buttonContour;
}
void DominoStyle::applicationPolish( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr )
{
if (!ceData.widgetObjectTypes.contains("TQApplication")) {
return;
}
TQApplication *app = reinterpret_cast<TQApplication*>(ptr);
if(!qstrcmp(app->name(), "konsole"))
konsoleMode = true;
else if(!qstrcmp(app->name(), "konqueror"))
konquerorMode = true;
else if(!qstrcmp(app->name(), "kicker"))
kickerMode = true;
TQPixmapCache::clear();
}
void DominoStyle::polish(TQPalette &p) {
p.setBrush(TQColorGroup::Button, p.active().background());
if(!_customPopupMenuColor)
_popupMenuColor = tqApp->palette().active().background();
if(!_customSelMenuItemColor)
_selMenuItemColor = tqApp->palette().active().highlight();
TQColor tabContour2 = tqApp->palette().active().background().dark(150);
delete border1;
border1= new TQPixmap(tintImage(qembed_findImage("border1"), tabContour2));
delete popupFrame;
popupFrame = new TQPixmap(tintImage(qembed_findImage("popup5"), _popupMenuColor.dark(150)));
if(!_customCheckMarkColor) {
delete checkMark;
checkMark = createCheckMark(tqApp->palette().active().foreground());
delete radioIndicator;
radioIndicator = createRadioIndicator(tqApp->palette().active().foreground());
}
}
void DominoStyle::polish( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr )
{
if (!ceData.widgetObjectTypes.contains("TQWidget")) {
return;
}
TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);
if(!strcmp(widget->name(), "__tdehtml")) { // is it a tdehtml widget...?
tdehtmlWidgets[widget] = true;
connect(widget, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(tdehtmlWidgetDestroyed(TQObject*)));
}
else if((!strcmp(widget->name(), "tdefile button") || (widget->isA("KLineEdit") && widget->parentWidget())) && !strcmp(widget->parentWidget()->name(), "__tdehtml")) {
widget->setBackgroundMode(TQt::NoBackground);
widget->parentWidget()->setBackgroundMode(TQt::NoBackground);
tdehtmlWidgets[widget] = true;
connect(widget, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(tdehtmlWidgetDestroyed(TQObject*)));
}
if(dynamic_cast<TQPushButton*>(widget)) {
setDominoButtonPalette(widget, Palette_Widget);
if (widget->isA("KDockButton_Private"))
widget->setFixedSize(13, 13); // 12x12 pixmap + 1px top and right spacing
else {
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
if(widget->parentWidget() && widget->parentWidget()->paletteBackgroundPixmap() && !tdehtmlWidgets.contains(widget)) {
widget->setBackgroundMode(TQt::PaletteButton);
widget->setBackgroundPixmap(*widget->parentWidget()->paletteBackgroundPixmap());
widget->setBackgroundOrigin(setPixmapOrigin(widget->parentWidget()->backgroundOrigin()));
}
}
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQCheckBox*>(widget)) {
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TDEToolBarButton*>(widget)) {
TDEToolBarButton* tb = static_cast<TDEToolBarButton*>(widget);
//setDominoButtonPalette(widget); // ### changing the palette breaks them!
if(tb->popupDelay() < 1)
tb->setPopupDelay(5); // now we have time to draw a pressed button
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQToolButton*>(widget)) {
TQToolButton* tb = static_cast<TQToolButton*>(widget);
tb->setBackgroundMode(TQt::PaletteBackground);
tb->setPaletteForegroundColor(tb->palette().active().buttonText());
setDominoButtonPalette(widget, Palette_Widget);
if(tb->popupDelay() < 1) {
disconnect(tb, TQ_SIGNAL(pressed()), tb, TQ_SLOT(popupPressed()));
connect(tb, TQ_SIGNAL(pressed()), this, TQ_SLOT(toolPopupPressed()));
connect(tb, TQ_SIGNAL(released()), this, TQ_SLOT(toolPopupReleased()));
}
if(tb->popupDelay() < 1)
tb->setPopupDelay(5);
if(tb->parentWidget() && tb->parentWidget()->paletteBackgroundPixmap()) {
tb->setPaletteBackgroundPixmap(*tb->parentWidget()->paletteBackgroundPixmap());
tb->setBackgroundOrigin(setPixmapOrigin(tb->parentWidget()->backgroundOrigin()));
}
// if(widget->isA("TaskContainer"))
// ((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
// else
installObjectEventHandler(ceData, elementFlags, ptr, this);
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
}
else if(dynamic_cast<TQRadioButton*>(widget)) {
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQComboBox*>(widget)) {
TQComboBox* cb = static_cast<TQComboBox*>(widget);
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
if(widget->parentWidget() && widget->parentWidget()->paletteBackgroundPixmap() && !tdehtmlWidgets.contains(widget)) {
widget->setBackgroundMode(TQt::PaletteButton);
widget->setBackgroundOrigin(setPixmapOrigin(widget->parentWidget()->backgroundOrigin()));
}
setDominoButtonPalette(widget, Palette_Widget);
if(cb->listBox())
cb->listBox()->setFrameStyle(TQFrame::Panel|TQFrame::Sunken);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQGroupBox*>(widget)) {
TQGroupBox* gb = dynamic_cast<TQGroupBox*>(widget);
gb->setAlignment(TQt::AlignHCenter);
if(!gb->isFlat() && !gb->lineWidth() <= 0) {
if(gb->layout() && gb->layout()->margin() < 7)
gb->layout()->setMargin(7);
bool groupBoxFrame = gb->frameShape() == TQFrame::GroupBoxPanel;
if(groupBoxFrame)
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
if(groupBoxSettings.tintBackground && groupBoxFrame) {
TQColor color = getGroupBoxColor(gb);
TQPalette pal(widget->palette());
int h, s, v;
pal.active().foreground().hsv(&h, &s, &v);
pal.setColor(TQPalette::Active, TQColorGroup::Background, color);
pal.setColor(TQPalette::Inactive, TQColorGroup::Background, color);
pal.setColor(TQPalette::Disabled, TQColorGroup::Background, color);
pal.setColor(TQPalette::Disabled, TQColorGroup::Text, alphaBlendColors(pal.active().foreground(), color, 40));
gb->setPalette(pal);
if(gb->isCheckable()) {
((TQCheckBox*)gb->child("qt_groupbox_checkbox", 0, false))->setPaletteBackgroundColor(gb->parentWidget()->paletteBackgroundColor());
}
}
connect(widget, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(groupBoxDestroyed(TQObject*)));
}
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQSpinWidget*>(widget)) {
// Don't like this widget... too much private stuff and the spinBox/spinWidget mess.
// We check here if the spinBox has a backgroundPixmap. If it's a spinWidget without a spinBox, well, maybe we should fill the widget black then >:)
if(widget->parentWidget() && widget->parentWidget()->parentWidget() && widget->parentWidget()->parentWidget()->paletteBackgroundPixmap()) {
TQWidget::BackgroundOrigin origin = widget->parentWidget()->backgroundOrigin();
if(origin == TQWidget::WidgetOrigin) {
widget->parentWidget()->setBackgroundOrigin(TQWidget::ParentOrigin);
widget->setBackgroundOrigin(TQWidget::AncestorOrigin);
}
else
widget->setBackgroundOrigin(setPixmapOrigin(origin));
}
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
setDominoButtonPalette(widget, Palette_Widget);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQSpinBox*>(widget)) {
connect(dynamic_cast<TQSpinBox*>(widget), TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(spinBoxValueChanged(int)));
}
else if(dynamic_cast<TQLineEdit*>(widget)) {
TQLineEdit* le = dynamic_cast<TQLineEdit*>(widget);
TQRect r = le->rect();
le->setFrameRect(TQRect(r.x()+1, r.y(), r.width()-1, r.height()));
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQScrollBar*>(widget)) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQStatusBar*>(widget)) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQHeader*>(widget)) {
setDominoButtonPalette(widget, Palette_Widget);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQPopupMenu*>(widget)) {
widget->setBackgroundMode( NoBackground );
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQTabWidget*>(widget)) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQTabBar*>(widget)) {
TQTabBar* tb = dynamic_cast<TQTabBar*>(widget);
if(widget->parentWidget() && widget->parentWidget()->isA("KonqFrameTabs")) {
tb->setShape(TQTabBar::RoundedBelow);
widget->setEraseColor(widget->paletteBackgroundColor().dark(konqTabBarContrast));
}
connect(tb, TQ_SIGNAL(layoutChanged()), this, TQ_SLOT(updateTabWidgetFrame()));
connect(tb, TQ_SIGNAL(selected(int)), this, TQ_SLOT(updateTabWidgetFrame()));
setDominoButtonPalette(widget, Palette_Widget);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQIconView*>(widget)) {
((DominoTQWidget*)dynamic_cast<TQIconView*>(widget)->viewport())->setWFlags(TQt::WNoAutoErase);
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
installObjectEventHandler(ceData, elementFlags, dynamic_cast<TQIconView*>(widget)->viewport(), this); // rubberband
if(strcmp(widget->className(), "KDIconView"))
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQListView*>(widget)) {
installObjectEventHandler(ceData, elementFlags, dynamic_cast<TQListView*>(widget)->viewport(), this); // rubberband
if(widget->isA("KonqTreeViewWidget")) { // konqi frames
TQFrame* f = dynamic_cast<TQFrame*>(widget);
f->setFrameStyle(TQFrame::Box|TQFrame::Plain);
f->setLineWidth(1);
}
if(!widget->isA("KopeteContactListView") && !widget->isA("ViewTree")) // they have their own mousewheel handling
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(widget->isA("KActiveLabel")) { // before TQScrollView
if(dynamic_cast<TQGroupBox*>(widget->parentWidget()))
widget->setPaletteBackgroundColor(widget->parentWidget()->paletteBackgroundColor());
}
else if(dynamic_cast<TQTextEdit*>(widget)) {
installObjectEventHandler(ceData, elementFlags, dynamic_cast<TQTextEdit*>(widget)->viewport(), this);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQScrollView*>(widget)) {
TQFrame* f = dynamic_cast<TQFrame*>(widget);
if((konquerorMode && widget->isA("TDEHTMLView")) || f->parentWidget() && !strcmp(f->parentWidget()->name(), "KonqFrame")) { // konqi frames
f->setFrameStyle(TQFrame::Box|TQFrame::Plain);
f->setLineWidth(1);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(_smoothScrolling && !widget->isA("TaskBar") && !widget->isA("Gwenview::ImageView"))
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQSlider*>(widget)) {
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
}
else if(dynamic_cast<TQListBox*>(widget)) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TDEToolBarSeparator*>(widget) || dynamic_cast<TQToolBar*>(widget)) {
widget->setBackgroundMode(TQt::PaletteBackground);
}
else if(widget->isA("KonqCheckBox")) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(widget->isA("TQTipLabel")) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(widget->isA("TQWhatsThat")) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(widget->isA("KonqFileTip")) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQButton*>(widget) && widget->parentWidget() && widget->parentWidget()->isA("TQToolBox")) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if( dynamic_cast<TQProgressBar*>(widget) && _animateProgressBar)
{
setDominoButtonPalette(widget, Palette_Widget);
progAnimWidgets[widget] = 0;
connect(widget, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(progressBarDestroyed(TQObject*)));
// if (!animationTimer->isActive())
// animationTimer->start( 50, false );
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TDEPopupTitle*>(widget)) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(dynamic_cast<TQFrame*>(widget)) {
TQFrame* f = dynamic_cast<TQFrame*>(widget);
switch (f->frameShape()) {
case TQFrame::Box:
f->setFrameStyle(TQFrame::StyledPanel|TQFrame::Sunken);
f->setLineWidth(2);
break;
case TQFrame::Panel:
if(kickerMode && f->parentWidget() && f->parentWidget()->isA("ClockApplet")) {
f->setLineWidth(0);
break;
}
case TQFrame::WinPanel:
f->setLineWidth(1);
installObjectEventHandler(ceData, elementFlags, ptr, this);
break;
case TQFrame::LineEditPanel: {
installObjectEventHandler(ceData, elementFlags, ptr, this);
break;
}
case TQFrame::TabWidgetPanel:
if(dynamic_cast<TQWidgetStack*>(widget)) {
if(f->parentWidget() && f->parentWidget()->isA("KonqFrameTabs"))
break;
f->setLineWidth(4);
f->setFrameRect(TQRect(0, 0, f->width(), f->height()-1));
f->setMargin(0);
TQWidget* w = widget->parentWidget();
for(int i=0; i<3; i++) { // the third parentcheck is for the tabWidget on kcm tdehtml_plugins
if(!w) break;
if(dynamic_cast<TQGroupBox*>(w)) {
widget->setPaletteBackgroundColor(tqApp->palette().active().background());
break;
}
w = w->parentWidget();
}
if(dynamic_cast<TQWidgetStack*>(widget)->widget(0)) // only if it has contents
((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
}
case TQFrame::HLine:
case TQFrame::VLine: {
installObjectEventHandler(ceData, elementFlags, ptr, this);
break;
}
case TQFrame::StyledPanel:
if(dynamic_cast<TQDockWindow*>(widget)) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(widget->isA("TQWorkspaceChild")) {
f->setFrameStyle(TQFrame::Panel|TQFrame::Sunken);
f->setLineWidth(1);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(widget->isA("KAnimWidget"))
f->setLineWidth(0);
default:
break;
}
}
// else if (dynamic_cast<KDockSplitter*>(widget)) {
// installObjectEventHandler(ceData, elementFlags, ptr, this);
// } else if (dynamic_cast<KDockWidgetAbstractHeaderDrag*>(widget)) {
// installObjectEventHandler(ceData, elementFlags, ptr, this);
else if(widget->isA("TQDateTimeEditor")) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(widget->inherits("TQDockWindowHandle") || widget->isA("TQDockWindowResizeHandle") ||
widget->isA("AppletHandleDrag")) { // !qstrcmp(widget->name(), "qt_dockwidget_internal")
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
else if(widget->isA("KDockWidget") && widget->parentWidget() && widget->parentWidget()->parentWidget()
&& widget->parentWidget()->parentWidget()->isA("Sidebar_Widget")) {
widget->setEraseColor(widget->palette().active().base());
}
// installObjectEventHandler(ceData, elementFlags, ptr, this);
//tqDebug("className %s, name: %s", widget->className(), widget->name());
}
void DominoStyle::unPolish( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr )
{
if (!ceData.widgetObjectTypes.contains("TQWidget")) {
return;
}
TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);
if( !strcmp(widget->name(), "__tdehtml") || (!strcmp(widget->name(), "tdefile button") && !strcmp(widget->parentWidget()->name(), "__tdehtml"))) { // is it a tdehtml widget...?
tdehtmlWidgets.remove(widget);
}
if (dynamic_cast<TQPushButton*>(widget) ||
dynamic_cast<TQSpinWidget*>(widget) || dynamic_cast<TQSlider*>(widget) ||
dynamic_cast<TQRadioButton*>(widget) ||
dynamic_cast<TQListBox*>(widget) || dynamic_cast<TQListView*>(widget) ||
dynamic_cast<TQStatusBar*>(widget) || widget->isA("AppletHandleDrag") ||
widget->isA("TQDockWindowHandle"))
{
((DominoTQWidget*)widget)->clearWFlags(TQt::WNoAutoErase);
widget->removeEventFilter(this);
}
else if(widget->isA("KonqCheckBox") || widget->isA("TQWhatsThat") || widget->isA("TQTipLabel")) {
widget->removeEventFilter(this);
widget->setPaletteBackgroundColor(tqApp->palette().active().background());
widget->setBackgroundMode(TQt::PaletteBackground);
}
else if(dynamic_cast<TQTabWidget*>(widget) || dynamic_cast<TQTabBar*>(widget)) {
widget->removeEventFilter(this);
widget->setBackgroundMode(TQt::PaletteBackground);
}
else if(dynamic_cast<TQCheckBox*>(widget)) {
((DominoTQWidget*)widget)->clearWFlags(TQt::WNoAutoErase);
widget->removeEventFilter(this);
}
else if(dynamic_cast<TQComboBox*>(widget)) { // after KonqCheckBox
((DominoTQWidget*)widget)->clearWFlags(TQt::WNoAutoErase);
widget->removeEventFilter(this);
}
else if(dynamic_cast<TQHeader*>(widget)) {
widget->removeEventFilter(this);
widget->setBackgroundMode(TQt::PaletteButton);
}
else if(dynamic_cast<TQPopupMenu*>(widget)) {
widget->removeEventFilter(this);
widget->setBackgroundMode(TQt::PaletteBackground);
static_cast<TQFrame*>(widget)->setLineWidth(2);
widget->clearMask();
}
else if(dynamic_cast<TDEToolBarButton*>(widget)) {
widget->removeEventFilter(this);
widget->setBackgroundMode(TQt::PaletteBackground);
}
else if(dynamic_cast<TQGroupBox*>(widget)) {
widget->removeEventFilter(this);
((DominoTQWidget*)widget)->clearWFlags(TQt::WNoAutoErase);
TQGroupBox* gb = dynamic_cast<TQGroupBox*>(widget);
gb->setBackgroundMode(TQt::PaletteBackground);
gb->setPalette(tqApp->palette());
gb->setAlignment(TQt::AlignLeft|TQt::AlignBottom);
}
else if(dynamic_cast<TQLineEdit*>(widget)) {
widget->removeEventFilter(this);
widget->setBackgroundMode(TQt::PaletteBase);
TQLineEdit* le = dynamic_cast<TQLineEdit*>(widget);
TQRect r = le->rect();
le->setFrameRect(TQRect(r.x()-1, r.y(), r.width()+1, r.height()));
widget->clearMask();
}
else if(dynamic_cast<TQProgressBar*>(widget) ) {
progAnimWidgets.remove(widget);
}
else if(dynamic_cast<TDEToolBarSeparator*>(widget) || dynamic_cast<TQToolBar*>(widget) ) {
widget->removeEventFilter(this);
widget->setBackgroundMode(TQt::PaletteButton);
}
if(widget->isA("KonqFileTip")) {
widget->removeEventFilter(this);
widget->setPaletteBackgroundColor(widget->palette().active().background());
TQFrame* f = dynamic_cast<TQFrame*>(widget);
f->setMargin(1);
f->setFrameStyle(TQFrame::Plain|TQFrame::Box);
TQObjectList *list = const_cast<TQObjectList *>(widget->children());
TQObjectListIt it( *list );
TQObject * o;
while ( (o = it.current()) != 0 ) {
++it;
if(dynamic_cast<TQLabel*>(o)) {
TQLabel* l = dynamic_cast<TQLabel*>(o);
l->setBackgroundOrigin(TQWidget::WidgetOrigin);
l->setBackgroundMode(TQt::PaletteBackground);
l->setPaletteBackgroundColor(l->palette().active().background());
}
}
}
else if(dynamic_cast<TQScrollView*>(widget)) {
TQFrame* f = dynamic_cast<TQFrame*>(widget);
if((konquerorMode && widget->isA("TDEHTMLView")) || f->parentWidget() && !strcmp(f->parentWidget()->name(), "KonqFrame")) { // konqi frames
widget->removeEventFilter(this);
f->setFrameStyle(TQFrame::NoFrame|TQFrame::Plain);
f->setLineWidth(0);
}
}
else if(dynamic_cast<TDEPopupTitle*>(widget)) {
widget->removeEventFilter(this);
}
else if(dynamic_cast<TQFrame*>(widget)) {
widget->removeEventFilter(this);
TQFrame* f = dynamic_cast<TQFrame*>(widget);
switch(f->frameShape()) {
case TQFrame::Panel:
if(widget->isA("TQWorkspaceChild")) {
f->setFrameStyle(TQFrame::StyledPanel|TQFrame::Sunken);
f->setLineWidth(2);
}
break;
case TQFrame::WinPanel:
f->setLineWidth(2);
break;
case TQFrame::TabWidgetPanel:
f->setLineWidth(2);
f->setMargin(2);
f->setFrameRect(TQRect(0, 0, 0, 0));
break;
case TQFrame::StyledPanel:
if(widget->isA("KAnimWidget"))
f->setLineWidth(2);
break;
default:
break;
}
}
TDEStyle::unPolish( ceData, elementFlags, ptr );
}
void DominoStyle::tdehtmlWidgetDestroyed(TQObject* obj)
{
tdehtmlWidgets.remove(static_cast<TQWidget*>(obj));
}
void DominoStyle::groupBoxDestroyed(TQObject* obj)
{
groupBoxPixmaps.remove(static_cast<TQGroupBox*>(obj));
}
void DominoStyle::progressBarDestroyed(TQObject* obj)
{
progAnimWidgets.remove(static_cast<TQWidget*>(obj));
}
void DominoStyle::renderContour(TQPainter *p, const TQRect &r, const TQColor &backgroundColor, const TQColor &contour, const uint flags) const {
if((r.width() <= 0)||(r.height() <= 0))
return;
const bool drawLeft = flags&Draw_Left;
const bool drawRight = flags&Draw_Right;
const bool drawTop = flags&Draw_Top;
const bool drawBottom = flags&Draw_Bottom;
// const bool disabled = flags&Is_Disabled;
const bool alphaBlend = flags&Draw_AlphaBlend;
const bool roundUpperLeft = flags&Round_UpperLeft;
const bool roundUpperRight = flags&Round_UpperRight;
const bool roundBottomLeft = flags&Round_BottomLeft;
const bool roundBottomRight = flags&Round_BottomRight;
const bool isButton = flags&Is_Button;
const bool isHorizontal = flags&Is_Horizontal;
const bool isScrollBarBtn = flags&Is_ScrollBarBtn;
TQColor appButtonColor = tqApp->palette().active().button();
if(isButton) {
TQRect sr = TQRect(r.x(), r.y()+2, r.width(), r.height()-5); // surface rect
int top = sr.y()+sr.height()*btnSurface.g1Top/100;
int bottom = sr.height()*btnSurface.g1Bottom/100;
int top2 = sr.y()+sr.height()*btnSurface.g2Top/100;
int bottom2 = sr.y()+sr.height()*btnSurface.g2Bottom/100-top2;
int left = sr.x()+sr.width()*btnSurface.g1Top/100;
int width = sr.width()*btnSurface.g1Bottom/100;
int left2 = sr.x()+sr.width()*btnSurface.g2Top/100;
int width2 = sr.width()*btnSurface.g2Bottom/100-left2;
// darker surface colors for the inner part of the contour
TQColor insideBackground;
TQColor gr1TopColor;
TQColor gr1BottomColor;
TQColor gr2TopColor;
TQColor gr2BottomColor;
const int alphaInside = tqAlpha(buttonContour->color3());
insideBackground = alphaBlendColors(buttonContour->color3(),
((contour != appButtonColor) ? alphaBlendColors(contour, btnSurface.background, 127) : btnSurface.background), alphaInside);
switch (btnSurface.numGradients) {
case 2:{
gr1TopColor = alphaBlendColors(buttonContour->color3(),
((contour != appButtonColor) ? alphaBlendColors(contour, btnSurface.g1Color1, 127) : btnSurface.g1Color1), alphaInside);
gr1BottomColor = alphaBlendColors(buttonContour->color3(),
((contour != appButtonColor) ? alphaBlendColors(contour, btnSurface.g1Color2, 127) : btnSurface.g1Color2), alphaInside);
gr2TopColor = alphaBlendColors(buttonContour->color3(),
((contour != appButtonColor) ? alphaBlendColors(contour, btnSurface.g2Color1, 127) : btnSurface.g2Color1), alphaInside);
gr2BottomColor = alphaBlendColors(buttonContour->color3(),
((contour != appButtonColor) ? alphaBlendColors(contour, btnSurface.g2Color2, 127) : btnSurface.g2Color2), alphaInside);
break;
}
case 1: {
gr1TopColor = alphaBlendColors(buttonContour->color3(),
((contour != appButtonColor) ? alphaBlendColors(contour, btnSurface.g1Color1, 127) : btnSurface.g1Color1), alphaInside);
gr1BottomColor = alphaBlendColors(buttonContour->color3(),
((contour != appButtonColor) ? alphaBlendColors(contour, btnSurface.g1Color2, 127) : btnSurface.g1Color2), alphaInside);
break;
}
default: {
insideBackground = insideBackground;
gr1TopColor = insideBackground;
gr1BottomColor = insideBackground;
gr2TopColor = insideBackground;
gr2BottomColor = insideBackground;
break;
}
}
if(flags & Is_Down) {
gr1TopColor = darkenColor(gr1TopColor, 15);
gr1BottomColor = darkenColor(gr1BottomColor, 15);
gr2TopColor = darkenColor(gr2TopColor, 15);
gr2BottomColor = darkenColor(gr2BottomColor, 15);
insideBackground = darkenColor(insideBackground, 15);
}
TQRegion clip;
if(drawTop)
clip += TQRegion(r.left()+6, r.top()+2, r.width()-12, 1);
if(drawBottom)
clip += TQRegion(r.left()+6, r.bottom()-3, r.width()-12, 1);
if(drawLeft)
clip += TQRegion(r.left()+2, r.top()+6, 1, r.height()-13);
if(drawRight)
clip += TQRegion(r.right()-2, r.top()+6, 1, r.height()-13);
p->setClipRegion(clip);
p->fillRect(sr, insideBackground);
switch(btnSurface.numGradients) {
case 1:
if(isHorizontal)
renderGradient(p, TQRect(sr.x(), top, sr.width(), bottom), gr1TopColor, gr1BottomColor, true);
else
renderGradient(p, TQRect(left, sr.y(), width, sr.height()), gr1TopColor, gr1BottomColor, false);
break;
case 2:
if(isHorizontal) {
renderGradient(p, TQRect(r.x(), top, r.width(), bottom), gr1TopColor, gr1BottomColor, true);
renderGradient(p, TQRect(r.x(), top2, r.width(), bottom2), gr2TopColor, gr2BottomColor, true);
}
else {
renderGradient(p, TQRect(left, sr.y(), width, sr.height()), gr1TopColor,gr1BottomColor, false);
renderGradient(p, TQRect(left2, sr.y(), width2, sr.height()), gr2TopColor,gr2BottomColor, false);
}
default:
break;
}
p->setClipping(false);
const TQColor color1 = alphaBlendColors(buttonContour->color1(), backgroundColor, tqAlpha(buttonContour->color1())); // 1.top
const TQColor color4 = alphaBlendColors(buttonContour->color4(), backgroundColor, tqAlpha(buttonContour->color4())); // 3.bottom
const TQColor color5 = alphaBlendColors(buttonContour->color5(), backgroundColor, tqAlpha(buttonContour->color5())); // 4.bottom
const TQColor color2 = alphaBlendColors(buttonContour->color2(), backgroundColor, tqAlpha(buttonContour->color2())); // 2.top 2.left 2.bottom
const TQColor color6 = alphaBlendColors(buttonContour->color6(), backgroundColor, tqAlpha(buttonContour->color6())); // 1.left
if(roundUpperLeft)
p->drawPixmap(r.left(), r.top(), *buttonContour->buttonEdges(), 0, 0, 6, 6);
if(roundUpperRight)
p->drawPixmap(r.right()-5, r.top(), *buttonContour->buttonEdges(), 6, 0, 6, 6);
if(roundBottomLeft)
p->drawPixmap(r.left(), r.bottom()-6, *buttonContour->buttonEdges(), 0, 6, 6, 7);
if(roundBottomRight)
p->drawPixmap(r.right()-5, r.bottom()-6, *buttonContour->buttonEdges(), 6, 6, 6, 7);
if(drawTop) {
if(!alphaBlend) {
p->setPen(color1);
p->drawLine(r.left()+6, r.top(), r.right()-6, r.top());
p->setPen(color2);
p->drawLine(r.left()+6, r.top()+1, r.right()-6, r.top()+1);
}
else {
p->drawTiledPixmap(r.left()+6, r.top(), r.width()-12, 2, *buttonContour->buttonHLines(), 0, 0);
}
}
if(drawBottom) {
if(!alphaBlend) {
p->setPen(color2);
p->drawLine(r.left()+6, r.bottom()-2, r.right()-6, r.bottom()-2);
p->setPen(color4);
p->drawLine(r.left()+6, r.bottom()-1, r.right()-6, r.bottom()-1);
p->setPen(color5);
p->drawLine(r.left()+6, r.bottom(), r.right()-6, r.bottom());
}
else {
p->drawTiledPixmap(r.left()+6, r.bottom()-2, r.width()-12, 3, *buttonContour->buttonHLines(), 0, 4);
}
}
if(drawLeft) {
if(!alphaBlend) {
p->setPen(color6);
p->drawLine(r.left(), r.top()+6, r.left(), r.bottom()-7);
p->setPen(color2);
p->drawLine(r.left()+1, r.top()+6, r.left()+1, r.bottom()-7);
}
else {
p->drawTiledPixmap(r.left(), r.top()+6, 2, r.height()-13, *buttonContour->buttonVLines(), 0, 0);
}
}
if(drawRight) {
if(!alphaBlend) {
p->setPen(color2);
p->drawLine(r.right()-1, r.top()+6, r.right()-1, r.bottom()-7);
p->setPen(color6);
p->drawLine(r.right(), r.top()+6, r.right(), r.bottom()-7);
}
else {
p->drawTiledPixmap(r.right()-1, r.top()+6, 2, r.height()-13, *buttonContour->buttonVLines(), 4, 0);
}
}
}
else if(isScrollBarBtn) {
TQColor background;
TQColor gr1TopColor;
TQColor gr1BottomColor;
TQColor gr2TopColor;
TQColor gr2BottomColor;
if(contour != appButtonColor) {
gr1TopColor = alphaBlendColors(contour, scrollBarSurface.g1Color1, 127);
gr1BottomColor = alphaBlendColors(contour, scrollBarSurface.g1Color2, 127);
gr2TopColor = alphaBlendColors(contour, scrollBarSurface.g2Color1, 127);
gr2BottomColor = alphaBlendColors(contour, scrollBarSurface.g2Color2, 127);
background = alphaBlendColors(contour, scrollBarSurface.background, 127);
}
else {
gr1TopColor = scrollBarSurface.g1Color1;
gr1BottomColor = scrollBarSurface.g1Color2;
gr2TopColor = scrollBarSurface.g2Color1;
gr2BottomColor = scrollBarSurface.g2Color2;
background = scrollBarSurface.background;
}
TQColor btnContour = buttonContour->contourColor(Contour_Default);
TQColor whiteColor( tqRgba(TQt::white.red(), TQt::white.green(), TQt::white.blue(), 23)); // first white layer
TQColor blackColor( tqRgba(btnContour.red(), btnContour.green(), btnContour.blue(), 35)); // second contour layer
gr1TopColor = blendColors(gr1TopColor, whiteColor);
gr1TopColor = blendColors(gr1TopColor, blackColor);
gr1BottomColor = blendColors(gr1BottomColor, whiteColor);
gr1BottomColor = blendColors(gr1BottomColor, blackColor);
gr2TopColor = blendColors(gr2TopColor, whiteColor);
gr2TopColor = blendColors(gr2TopColor, blackColor);
gr2BottomColor = blendColors(gr2BottomColor, whiteColor);
gr2BottomColor = blendColors(gr2BottomColor, blackColor);
background = blendColors(background, whiteColor);
background = blendColors(background, blackColor);
TQRegion clip;
if(drawTop)
clip += TQRegion(r.left(), r.top()+1, r.width(), 1);
if(drawBottom)
clip += TQRegion(r.left(), r.bottom()-1, r.width(), 1);
if(drawLeft)
clip += TQRegion(r.left()+1, r.top(), 1, r.height());
if(drawRight)
clip += TQRegion(r.right()-1, r.top(), 1, r.height());
p->setClipRegion(clip);
TQRect sr = r;
int top = sr.y()+sr.height()*scrollBarSurface.g1Top/100;
int bottom = sr.height()*scrollBarSurface.g1Bottom/100;
int top2 = sr.y()+sr.height()*scrollBarSurface.g2Top/100;
int bottom2 = sr.height()*scrollBarSurface.g2Bottom/100-top2;
int left = sr.x()+sr.width()*scrollBarSurface.g1Top/100;
int width = sr.width()*scrollBarSurface.g1Bottom/100;
int left2 = sr.x()+sr.width()*scrollBarSurface.g2Top/100;
int width2 = sr.width()*scrollBarSurface.g2Bottom/100-left2;
p->fillRect(sr, background);
switch(scrollBarSurface.numGradients) {
case 1:
if(isHorizontal)
renderGradient(p, TQRect(sr.x(), top, sr.width(), bottom), gr1TopColor, gr1BottomColor, true);
else
renderGradient(p, TQRect(left, sr.y(), width, sr.height()), gr1TopColor, gr1BottomColor, false);
break;
case 2:
if(isHorizontal) {
renderGradient(p, TQRect(r.x(), top, r.width(), bottom), gr1TopColor, gr1BottomColor, true);
renderGradient(p, TQRect(r.x(), top2, r.width(), bottom2), gr2TopColor, gr2BottomColor, true);
}
else {
renderGradient(p, TQRect(left, sr.y(), width, sr.height()), gr1TopColor,gr1BottomColor, false);
renderGradient(p, TQRect(left2, sr.y(), width2, sr.height()), gr2TopColor,gr2BottomColor, false);
}
default:
break;
}
p->setClipping(false);
TQColor color1 = alphaBlendColors(buttonContour->contourColor(Contour_Default), backgroundColor, 203); // like btn contour
TQColor color2 = alphaBlendColors(TQColor(255, 255, 255), color1, 25);
p->setPen(color1);
if(drawTop) {
p->drawLine(r.left(), r.top(), r.right(), r.top()); // top
}
if(drawBottom) {
p->drawLine(r.left(), r.bottom(), r.right(), r.bottom()); // bottom
}
if(drawLeft) {
p->drawLine(r.left(), r.top(), r.left(), r.bottom()); // left
}
if(drawRight) {
p->drawLine(r.right(), r.top(), r.right(), r.bottom()); // right
}
color1 = blendColors(color1, whiteColor);
p->setPen(color2);
if(roundUpperLeft) {
renderPixel(p, TQPoint(r.x()+1, r.y()+1), 127, color1, color1, true);
p->drawPoint(r.x(), r.y());
}
if(roundUpperRight) {
renderPixel(p, TQPoint(r.right()-1, r.top()+1), 127, color1, color1, true);
p->drawPoint(r.right(), r.y());
}
if(roundBottomLeft) {
renderPixel(p, TQPoint(r.x()+1, r.bottom()-1), 127, color1, color1, true);
p->drawPoint(r.x(), r.bottom());
}
if(roundBottomRight) {
renderPixel(p, TQPoint(r.right()-1, r.bottom()-1), 127, color1, color1, true);
p->drawPoint(r.right(), r.bottom());
}
}
return;
}
void DominoStyle::renderSurface(TQPainter *p,
const TQRect &r,
const TQColor &backgroundColor,
const TQColor &buttonColor,
const TQColor &/*highlightColor*/,
const uint flags) const
{
if((r.width() <= 0)||(r.height() <= 0))
return;
const DSurface* ds = 0;
const bool isButton = flags&Is_Button;
const bool isScrollBarBtn = flags&Is_ScrollBarBtn;
const bool isScrollBarGroove = flags&Is_ScrollBarGroove;
const bool isCheckItem = flags&Is_CheckItem;
const bool isHeader = flags&Is_Header;
const bool isTabTop = flags&Is_TabTop;
const bool isActiveTabTop = flags&Is_ActiveTabTop;
const bool isTabBottom = flags&Is_TabBottom;
const bool isActiveTabBottom = flags&Is_ActiveTabBottom;
const bool horizontal = flags&Is_Horizontal;
const bool isDown = flags&Is_Down;
if(isButton)
ds = &btnSurface;
else if(isCheckItem)
ds = &checkItemSurface;
else if(isScrollBarBtn)
ds = &scrollBarSurface;
else if(isScrollBarGroove)
ds = &scrollBarGrooveSurface;
else if(isHeader)
ds = &headerSurface;
else if(isTabTop)
ds = &tabTopSurface;
else if(isActiveTabTop)
ds = &activeTabTopSurface;
else if(isTabBottom)
ds = &tabBottomSurface;
else if(isActiveTabBottom)
ds = &activeTabBottomSurface;
TQColor g1Color1;
TQColor g1Color2;
TQColor g2Color1;
TQColor g2Color2;
TQColor background;
if(buttonColor != tqApp->palette().active().button()) {
g2Color1 = alphaBlendColors(buttonColor, ds->g2Color1, 127);
g2Color2 = alphaBlendColors(buttonColor, ds->g2Color2, 127);
g1Color1 = alphaBlendColors(buttonColor, ds->g1Color1, 127);
g1Color2 = alphaBlendColors(buttonColor, ds->g1Color2, 127);
background = alphaBlendColors(buttonColor, ds->background, 127);
}
else {
g1Color1 = ds->g1Color1;
g1Color2 = ds->g1Color2;
g2Color1 = ds->g2Color1;
g2Color2 = ds->g2Color2;
background = ds->background;
}
if(isDown) {
g1Color1 = darkenColor(g1Color1, 15);
g1Color2 = darkenColor(g1Color2, 15);
g2Color1 = darkenColor(g2Color1, 15);
g2Color2 = darkenColor(g2Color2, 15);
background = darkenColor(background, 15);
}
if(isButton) { // button / toolButton / comboBox / spinWidget / slider / progressBar
if(!flatMode) {
TQRegion mask(r.x()+2, r.y(), r.width()-4, r.height());
mask += TQRegion(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
mask += TQRegion(r.x(), r.y()+2, r.width(), r.height()-4);
p->setClipRegion(mask, TQPainter::CoordPainter);
}
TQRect re = r;
if(re.x() < 0 ) {
re.setWidth(re.width()+TQABS(re.x()));
re.setX(0);
}
else if(re.y() < 0 ) {
re.setHeight(re.height()+TQABS(re.y()));
re.setY(0);
}
TQPixmap pix(re.width(), re.height());
pix.fill(background);
TQPainter painter(&pix);
int top = re.height()*btnSurface.g1Top/100;
int bottom = re.height()*btnSurface.g1Bottom/100;
int top2 = re.height()*btnSurface.g2Top/100;
int bottom2 = re.height()*btnSurface.g2Bottom/100-top2;
int left = re.width()*btnSurface.g1Top/100;
int width = re.width()*btnSurface.g1Bottom/100;
int left2 = re.width()*btnSurface.g2Top/100;
int width2 = re.width()*btnSurface.g2Bottom/100-left2;
switch (btnSurface.numGradients) {
case 1:{
if(horizontal) {
renderGradient(&painter, TQRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
}
else {
renderGradient(&painter, TQRect(left, 0, width, re.height()), g1Color1, g1Color2, false);
}
break;
}
case 2: {
if(horizontal) {
renderGradient(&painter, TQRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
renderGradient(&painter, TQRect(0, top2, re.width(), bottom2), g2Color1, g2Color2, true);
}
else {
renderGradient(&painter, TQRect(left, 0, width, re.height()), g1Color1, g1Color2, false);
renderGradient(&painter, TQRect(left2, 0, width2, re.height()), g2Color1, g2Color2, false);
}
}
default: break;
}
p->drawPixmap(r.x(), r.y(), pix);
p->setClipping(false);
}
else if(isTabTop || isActiveTabTop || isTabBottom || isActiveTabBottom) {
int top = r.y()+r.height()*ds->g1Top/100;
int bottom = r.height()*ds->g1Bottom/100;
int top2 = r.y()+r.height()*ds->g2Top/100;
int bottom2 = r.height()*ds->g2Bottom/100-top2;
p->fillRect(r, background);
switch (ds->numGradients) {
case 1:{
renderGradient(p, TQRect(r.x(), top, r.width(), bottom), g1Color1, g1Color2, true);
break;
}
case 2: {
renderGradient(p, TQRect(r.x(), top, r.width(), bottom), g1Color1, g1Color2, true);
renderGradient(p, TQRect(r.x(), top2, r.width(), bottom2), g2Color1, g2Color2, true);
}
default: break;
}
}
else if(isScrollBarBtn) {
int top = r.height()*scrollBarSurface.g1Top/100;
int bottom = r.height()*scrollBarSurface.g1Bottom/100;
int top2 = r.height()*scrollBarSurface.g2Top/100;
int bottom2 = r.height()*scrollBarSurface.g2Bottom/100-top2;
int left = r.width()*scrollBarSurface.g1Top/100;
int width = r.width()*scrollBarSurface.g1Bottom/100;
int left2 = r.width()*scrollBarSurface.g2Top/100;
int width2 = r.width()*scrollBarSurface.g2Bottom/100-left2;
p->fillRect(r, background);
switch (scrollBarSurface.numGradients) {
case 1: {
if(horizontal) {
renderGradient(p, TQRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
}
else {
renderGradient(p, TQRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
}
break;
}
case 2: {
if(horizontal) {
renderGradient(p, TQRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
renderGradient(p, TQRect(r.left(), top2, r.width(), bottom2), g2Color1, g2Color2, true);
}
else {
renderGradient(p, TQRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
renderGradient(p, TQRect(left2, r.top(), width2, r.height()), g2Color1, g2Color2, false);
}
}
default:
break;
}
}
else if(isScrollBarGroove) {
int top = r.height()*scrollBarGrooveSurface.g1Top/100;
int bottom = r.height()*scrollBarGrooveSurface.g1Bottom/100;
int top2 = r.height()*scrollBarGrooveSurface.g2Top/100;
int bottom2 = r.height()*scrollBarGrooveSurface.g2Bottom/100-top2;
int left = r.width()*scrollBarGrooveSurface.g1Top/100;
int width = r.width()*scrollBarGrooveSurface.g1Bottom/100;
int left2 = r.width()*scrollBarGrooveSurface.g2Top/100;
int width2 = r.width()*scrollBarGrooveSurface.g2Bottom/100-left2;
p->fillRect(r, background);
switch (scrollBarGrooveSurface.numGradients) {
case 1: {
if(horizontal) {
renderGradient(p, TQRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
}
else {
renderGradient(p, TQRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
}
break;
}
case 2: {
if(horizontal) {
renderGradient(p, TQRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
renderGradient(p, TQRect(r.left(), top2, r.width(), bottom2), g2Color1, g2Color2, true);
}
else {
renderGradient(p, TQRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
renderGradient(p, TQRect(left2, r.top(), width2, r.height()), g2Color1, g2Color2, false);
}
}
default:
break;
}
}
else if(isCheckItem) {
TQPixmap pix(r.width(), r.height());
pix.fill(background);
TQPainter painter(&pix);
int top = r.height()*checkItemSurface.g1Top/100;
int bottom = r.height()*checkItemSurface.g1Bottom/100;
int top2 = r.height()*checkItemSurface.g2Top/100;
int bottom2 = r.height()*checkItemSurface.g2Bottom/100-top2;
switch(checkItemSurface.numGradients) {
case 1:{
renderGradient(&painter, TQRect(0, top, r.width(), bottom), g1Color1, g1Color2, true);
break;
}
case 2: {
renderGradient(&painter, TQRect(0, top, r.width(), bottom), g1Color1, g1Color2, true);
renderGradient(&painter, TQRect(0, top2, r.width(), bottom2), g2Color1, g2Color2, true);
break;
}
default: break;
}
painter.end();
p->drawPixmap(TQRect(r.x(), r.y()+3, r.width(), r.height()-7), pix);
}
else if(isHeader) {
TQHeader* hdr = dynamic_cast<TQHeader*>(p->device());
bool needErasePixmap = false;
TQRect re = r;
bool horizontal = false;
bool drawTop = false;
if(hdr) {
if(hdr->orientation() == TQt::Horizontal) {
horizontal = true;
bool hasErasePixmap = hdr->erasePixmap();
if(hasErasePixmap && !isDown) {
hdr->erase(r);
return;
}
else if(!hasErasePixmap && !isDown) {
needErasePixmap = true;
re = TQRect(0, 0, 10, r.height());
}
}
else if(hdr->sectionAt(r.top()+hdr->offset()) == 0 && r.y() == 0)
drawTop = true;
}
TQPixmap pix(re.width(), re.height());
pix.fill(background);
TQPainter painter(&pix);
int top = re.height()*headerSurface.g1Top/100;
int bottom = re.height()*headerSurface.g1Bottom/100;
int top2 = re.height()*headerSurface.g2Top/100;
int bottom2 = re.height()*headerSurface.g2Bottom/100-top2;
switch (headerSurface.numGradients) {
case 1:{
renderGradient(&painter, TQRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
break;
}
case 2: {
renderGradient(&painter, TQRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
renderGradient(&painter, TQRect(0, top2, re.width(), bottom2), g2Color1, g2Color2, true);
break;
}
default: break;
}
painter.setPen(alphaBlendColors(buttonContour->contourColor(Contour_Default), backgroundColor, 179));
if(horizontal || drawTop)
painter.drawLine(0, re.y(), re.width(), re.y());
painter.drawLine(0, re.height()-1, re.width(), re.height()-1);
if(needErasePixmap) {
hdr->setUpdatesEnabled(false);
hdr->setErasePixmap(pix);
hdr->setUpdatesEnabled(true);
hdr->erase(r);
}
else {
// same problem as with the scrollbars, if we don't clip, the text above will be randomly erased.
p->setClipRect(re);
p->drawPixmap(r.x(), r.y(), pix);
p->setClipping(false);
}
}
}
void DominoStyle::renderPixel(TQPainter *p,
const TQPoint &pos,
const int alpha,
const TQColor &color,
const TQColor &background,
bool fullAlphaBlend) const
{
if(fullAlphaBlend)
// full alpha blend: paint into an image with alpha buffer and convert to a pixmap ...
{
TQRgb rgb = color.rgb();
// generate a quite unique key -- use the unused width field to store the alpha value.
CacheEntry search(cAlphaDot, alpha, 0, rgb);
int key = search.key();
CacheEntry *cacheEntry;
if( (cacheEntry = pixmapCache->find(key)) ) {
if( search == *cacheEntry ) { // match! we can draw now...
if(cacheEntry->pixmap)
p->drawPixmap(pos, *(cacheEntry->pixmap) );
return;
} else { //Remove old entry in case of a conflict!
pixmapCache->remove( key );
}
}
TQImage aImg(1,1,32); // 1x1
aImg.setAlphaBuffer(true);
aImg.setPixel(0,0,tqRgba(tqRed(rgb),tqGreen(rgb),tqBlue(rgb),alpha));
TQPixmap *result = new TQPixmap(aImg);
p->drawPixmap(pos, *result);
// add to the cache...
CacheEntry *toAdd = new CacheEntry(search);
toAdd->pixmap = result;
bool insertOk = pixmapCache->insert( key, toAdd, result->depth()/8);
if(!insertOk)
delete result;
} else
// don't use an alpha buffer: calculate the resulting color from the alpha value, the fg- and the bg-color.
{
TQRgb rgb_a = color.rgb();
TQRgb rgb_b = background.rgb();
int a = alpha;
if(a>255) a = 255;
if(a<0) a = 0;
int a_inv = 255 - a;
TQColor res = TQColor( tqRgb(tqRed(rgb_b)*a_inv/255 + tqRed(rgb_a)*a/255,
tqGreen(rgb_b)*a_inv/255 + tqGreen(rgb_a)*a/255,
tqBlue(rgb_b)*a_inv/255 + tqBlue(rgb_a)*a/255) );
p->setPen(res);
p->drawPoint(pos);
}
}
void DominoStyle::renderButtonShadow(TQPainter *p, const TQRect &r, const uint flags) const {
if((!buttonContour->drawButtonSunkenShadow && buttonContour->defaultType == Contour_Sunken) || (buttonContour->defaultType != Contour_Sunken && !flatMode))
return;
if(flags&Round_UpperLeft) {
bitBlt(p->device(), r.left(), r.top(), buttonContour->shadowRound(), 0, 0, 5, 5, TQt::CopyROP);
}
else if(flags&Rectangular_UpperLeft){
bitBlt(p->device(), r.left(), r.top(), buttonContour->shadowRectangular(), 0, 0, 5, 5, TQt::CopyROP);
}
if(flags&Round_UpperRight) {
bitBlt(p->device(), r.right()-6, r.top(), buttonContour->shadowRound(), 5, 0, 5, 5, TQt::CopyROP);
}
else if(flags&Rectangular_UpperRight){
bitBlt(p->device(), r.right()-6, r.top(), buttonContour->shadowRectangular(), 5, 0, 5, 5, TQt::CopyROP);
}
if(flags&Round_BottomLeft) {
bitBlt(p->device(), r.left(), r.bottom()-5, buttonContour->shadowRound(), 0, 5, 4, 4, TQt::CopyROP);
}
else if(flags&Rectangular_BottomLeft)
bitBlt(p->device(), r.left(), r.bottom()-5, buttonContour->shadowRectangular(), 0, 5, 4, 4, TQt::CopyROP);
if(flags&Round_BottomRight) {
bitBlt(p->device(), r.right()-5, r.bottom()-5, buttonContour->shadowRound(), 4, 5, 4, 4, TQt::CopyROP);
}
else if(flags&Rectangular_BottomRight)
bitBlt(p->device(), r.right()-5, r.bottom()-5, buttonContour->shadowRectangular(), 4, 5, 4, 4, TQt::CopyROP);
if(flags&Draw_Top)
p->drawTiledPixmap(r.left()+5, r.top(), r.width()-12, 3, *buttonContour->shadowHLines(), 0, 0);
if(flags&Draw_Left)
p->drawTiledPixmap(r.left(), r.top()+5, 3, r.height()-11, *buttonContour->shadowVLines(), 0, 0);
if(flags&Draw_Right)
p->drawTiledPixmap(r.right()-4, r.top()+5, 3, r.height()-11, *buttonContour->shadowVLines(), 3, 0);
if(flags&Draw_Bottom)
p->drawTiledPixmap(r.left()+4, r.bottom()-3, r.width()-10, 2, *buttonContour->shadowHLines(), 0, 3);
}
void DominoStyle::renderButton(TQPainter *p,
const TQRect &r,
const TQColorGroup &g,
bool sunken,
bool /*mouseOver*/,
bool horizontal,
bool enabled,
bool tdehtmlMode) const
{
uint contourFlags = Draw_Left|Draw_Right|Draw_Top|Draw_Bottom;
if(!enabled) contourFlags|=Is_Disabled;
if(tdehtmlMode || buttonContour->alphaMode() /* || kickerMode*/) {
contourFlags|=Draw_AlphaBlend;
}
uint surfaceFlags = Is_Button;
if(horizontal) {
surfaceFlags|=Is_Horizontal;
contourFlags|=Is_Horizontal;
}
if(!enabled)
surfaceFlags|=Is_Disabled;
else {
if(sunken) {
surfaceFlags|=Is_Down;
contourFlags|=Is_Down;
}
}
// TQColor buttonColor = tdehtmlMode ? g.button() : tqApp->palette().active().background();
if (!flatMode) {
contourFlags |= Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight|Is_Button;
renderSurface(p, TQRect(r.x()+2, r.y()+2, r.width()-4, r.height()-5), g.background(), g.button(), g.button(), surfaceFlags);
renderContour(p, r, g.background(), g.button(), contourFlags);
if(sunken) {
renderButtonShadow(p, TQRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3), contourFlags);
}
}
else {
renderSurface(p, TQRect(r.x()-3, r.y()-1, r.width()+6, r.height()+2), g.background(), g.button(), g.button(), surfaceFlags);
if(sunken) {
contourFlags |= Rectangular_UpperLeft|Rectangular_UpperRight|Rectangular_BottomLeft|Rectangular_BottomRight;
renderButtonShadow(p, TQRect(r.x()-2, r.y()-2, r.width()+4, r.height()+4), contourFlags);
}
}
}
void DominoStyle::renderHeader(TQPainter *p,
const TQRect &r,
const TQColorGroup &g,
bool sunken,
bool /*mouseOver*/,
bool /*horizontal*/,
bool /*enabled*/) const
{
p->save();
bool drawLeft = true;
TQHeader* hd = dynamic_cast<TQHeader*>(p->device());
if(hd && hd->orientation() == TQt::Horizontal)
drawLeft = r.x() == 0 && hd->sectionAt(r.left()+hd->offset()) == 0;
uint surfaceFlags = Is_Header|Is_Horizontal;
if(sunken)
surfaceFlags |= Is_Down;
renderSurface(p, TQRect(r.left(), r.top(), r.width(), r.height()), g.button(), g.button(), g.button(), surfaceFlags);
// p->setPen(buttonContour->contourColor(Contour_Default));
p->setPen(alphaBlendColors(buttonContour->contourColor(Contour_Default), g.background(), 179));
if(drawLeft)
p->drawLine(r.left(), r.top(), r.left(), r.bottom());
if(!hd)
p->drawLine(r.right(), r.top(), r.left(), r.top());
p->drawLine(r.right(), r.top(), r.right(), r.bottom());
p->restore();
}
void DominoStyle::renderGradient(TQPainter *painter,
const TQRect &rect,
const TQColor &c1,
const TQColor &c2,
bool horizontal) const
{
if((rect.width() <= 0)||(rect.height() <= 0))
return;
// generate a quite unique key for this surface.
CacheEntry search(cGradientTile,
horizontal ? 0 : rect.width(),
horizontal ? rect.height() : 0,
c1.rgb(), c2.rgb(), horizontal );
int key = search.key();
CacheEntry *cacheEntry;
if( (cacheEntry = pixmapCache->find(key)) ) {
if( search == *cacheEntry ) { // match! we can draw now...
if(cacheEntry->pixmap) {
painter->drawTiledPixmap(rect, *(cacheEntry->pixmap) );
}
return;
} else {
// Remove old entry in case of a conflict!
// This shouldn't happen very often, see comment in CacheEntry.
pixmapCache->remove(key);
}
}
// there wasn't anything matching in the cache, create the pixmap now...
TQPixmap *result = new TQPixmap(horizontal ? 10 : rect.width(),
horizontal ? rect.height() : 10);
TQPainter p(result);
int r_w = result->rect().width();
int r_h = result->rect().height();
int r_x, r_y, r_x2, r_y2;
result->rect().coords(&r_x, &r_y, &r_x2, &r_y2);
int rDiff, gDiff, bDiff;
int rc, gc, bc;
int x, y;
rDiff = ( c2.red()) - (rc = c1.red());
gDiff = ( c2.green()) - (gc = c1.green());
bDiff = ( c2.blue()) - (bc = c1.blue());
int rl = rc << 16;
int gl = gc << 16;
int bl = bc << 16;
int rdelta = ((1<<16) / (horizontal ? r_h : r_w)) * rDiff;
int gdelta = ((1<<16) / (horizontal ? r_h : r_w)) * gDiff;
int bdelta = ((1<<16) / (horizontal ? r_h : r_w)) * bDiff;
// these for-loops could be merged, but the if's in the inner loop
// would make it slow
if(horizontal) {
for ( y = 0; y < r_h; y++ ) {
rl += rdelta;
gl += gdelta;
bl += bdelta;
p.setPen(TQColor(rl>>16, gl>>16, bl>>16));
p.drawLine(r_x, r_y+y, r_x2, r_y+y);
}
} else {
for( x = 0; x < r_w; x++) {
rl += rdelta;
gl += gdelta;
bl += bdelta;
p.setPen(TQColor(rl>>16, gl>>16, bl>>16));
p.drawLine(r_x+x, r_y, r_x+x, r_y2);
}
}
p.end();
// draw the result...
painter->drawTiledPixmap(rect, *result);
// insert into cache using the previously created key.
CacheEntry *toAdd = new CacheEntry(search);
toAdd->pixmap = result;
bool insertOk = pixmapCache->insert( key, toAdd, result->width()*result->height()*result->depth()/8 );
if(!insertOk)
delete result;
}
void DominoStyle::renderTab(TQPainter *p,
const TQRect &r,
const TQColorGroup &g,
bool /*mouseOver*/,
const bool selected,
const bool bottom,
const TabPosition pos,
const bool /*triangular*/,
const bool /*cornerWidget*/,
const bool konqTab) const
{
const bool isFirst = (pos == First);
const bool isLast = (pos == Last);
const bool isSingle = (pos == Single);
TQPixmap buffer(r.width(), r.height());
TQPainter painter(&buffer);
TQColor tabContour2 = g.background().dark(150);
TQPixmap* tabEdges;
if(!(tabEdges = TQPixmapCache::find(TQString::number(tabContour2.pixel(), 16)+"tabEdges"))) {
TQImage img1 = tintImage(qembed_findImage("border1"), tabContour2);
TQImage img2 = qembed_findImage("tabInsideWhite");
blend(img1, img2, img2);
tabEdges = new TQPixmap(img2);
TQPixmapCache::insert(TQString::number(tabContour2.pixel(), 16)+"tabEdges", tabEdges);
}
TQPixmap* tabHLines;
if(!(tabHLines = TQPixmapCache::find("tabHLines"))) {
tabHLines = new TQPixmap(qembed_findImage("tabHLines"));
TQPixmapCache::insert("tabHLines", tabHLines);
}
TQPixmap* tabVLines;
if(!(tabVLines = TQPixmapCache::find("tabVLines"))) {
tabVLines = new TQPixmap(qembed_findImage("tabVLines"));
TQPixmapCache::insert("tabVLines", tabVLines);
}
if(konqTab) {
const TQColor background = g.background().dark(konqTabBarContrast);
if (selected) {
///painter.fillRect(0, r.height()-9, r.width(), 9, background); // rect below gradient
///painter.fillRect(0, 0, r.width(), r.height()-9, g.background()); // rect above gradient
painter.fillRect(0, 0, r.width(), 2, g.background()); // rect above gradient
painter.translate(0, 2);
renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-3), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
painter.translate(0, -2);
TQPixmap* tabEdges2;
TQString position = isFirst ? "first" : isLast ? "last" : isSingle ? "single" : "middle";
if(!(tabEdges2 = TQPixmapCache::find(position+"tabEdges2-k-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
tabEdges2 = new TQPixmap(16, 8);
tabEdges2->fill(background);
TQPainter painter2(tabEdges2);
// parts of the unselected tabs under the rounded edges
if(!isSingle) {
if(!isFirst) {
painter2.translate(0, -r.height()+12);
renderSurface(&painter2, TQRect(0, 0, 3, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
painter2.resetXForm();
painter2.drawTiledPixmap(0, 3, 3, 1, *tabHLines, 0, 2); // left
painter2.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
painter2.drawLine(0, 4, 1, 4);
painter2.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
painter2.drawPoint(2,4); // last point from bottomShadow1 a tad lighter (will be overpainted by the circle)
painter2.drawLine(0, 5, 3, 5);
}
if(!isLast) {
painter2.translate(0, -r.height()+12);
renderSurface(&painter2, TQRect(13, 0, 3, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
painter2.resetXForm();
painter2.drawTiledPixmap(13, 3, 3, 1, *tabHLines, 0, 2); // right
painter2.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
painter2.drawLine(14, 4, 15, 4);
painter2.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
painter2.drawPoint(13,4);
painter2.drawLine(12, 5, 15, 5);
}
}
// fill the rect under the gradients (faster as clipping the gradients)
painter2.fillRect(TQRect(0, 6, 16, 2), background);
painter2.end();
TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask"); // this fits because the tab frame is just an inverted groupbox frame, but pssst ;)
painter2.begin(&tabEdgesMask);
painter2.translate(0, -r.height()+19);
renderSurface(&painter2, TQRect(0, 0, 16, r.height()-3), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
painter2.end();
bitBlt(tabEdges2, 0, 0, &tabEdgesMask, 0, 8);
TQPixmap circle = qembed_findImage("tabWidget");
bitBlt(tabEdges2, 0, 0, &circle, 0, 8);
TQPixmapCache::insert(position+"tabEdges2-k-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
}
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
painter.drawLine(8, r.height()-3, r.width()-9, r.height()-3);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
painter.drawLine(8, r.height()-2, r.width()-9, r.height()-2);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 35));
painter.translate(0,3);
if(isFirst || isSingle)
painter.drawLine(0, -1, 0, r.height()-13); // left
else
renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5-3), g.button(), false);
if(isLast || isSingle)
painter.drawLine(r.width()-1, -1, r.width()-1, r.height()-13); // right
else
renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5-3), g.button(), false);
painter.translate(0,-3);
bitBlt(&buffer, 0, r.height()-9, tabEdges2, 0, 0, 8, 8);
bitBlt(&buffer, r.width()-8, r.height()-9, tabEdges2, 8, 0, 8, 8);
painter.drawTiledPixmap(8, r.height()-4, r.width()-16, 1, *tabHLines, 0, 2);
painter.drawTiledPixmap(1, 2, 1, r.height()-11, *tabVLines); // left
painter.drawTiledPixmap(r.width()-2, 2, 1, r.height()-11, *tabVLines); // right
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 20));
painter.drawPoint(0,1);
painter.drawPoint(r.width()-1,1);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 50));
painter.drawPoint(0,2);
painter.drawPoint(r.width()-1,2);
//TQColor tmp = alphaBlendColors(TQColor(255,255,255), g.background(), 14);
TQColor tmp = g.background();
painter.setPen(alphaBlendColors(tmp, activeTabBottomSurface.g1Top == 0 ? activeTabBottomSurface.g1Color1 : activeTabBottomSurface.background, 127));
// painter.drawPoint(1,2);
// painter.drawPoint(r.width()-2,2);
painter.drawLine(1,2, r.width()-2, 2);
// under the tab
painter.setPen(background);
painter.drawLine(0, r.height()-1, r.width(), r.height()-1);
}
else { // unselected
painter.setPen(g.background());// 0. tabbarline
painter.drawLine(0, 0, r.width(), 0);
painter.setPen(g.background().dark(120));//TQColor(110,110,110) // 1. tabbarline
painter.drawLine(0, 1, r.width(), 1);
painter.setPen(g.background().dark(konqTabBarContrast+20)); //TQColor(110,110,110)
// topline
// painter.setPen(g.background().dark(150-15));
painter.setPen(g.background().dark(150-15));
painter.drawLine(0, 2, r.width(), 2);
if(isFirst || isLast) {
painter.translate(0, 3);
renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
painter.translate(0, -3);
TQPixmap* tabEdges2;
if(!(tabEdges2 = TQPixmapCache::find("tabEdges2-k"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
tabEdges2 = new TQPixmap(16, 8);
tabEdges2->fill(background);
TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
TQPainter painter2(&tabEdgesMask);
painter2.translate(0, -r.height()+19+3);
renderSurface(&painter2, TQRect(1, 0, 14, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
painter2.end();
bitBlt(tabEdges2, 0, 0, &tabEdgesMask, 0, 8);
TQPixmap circle = qembed_findImage("tabWidget");
bitBlt(tabEdges2, 0, 0, &circle, 0, 8);
TQPixmapCache::insert("tabEdges2-k"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
}
if(isFirst) {
painter.translate(0,3);
renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5-3), g.button(), false);// right
painter.translate(0,-3);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
painter.drawLine(8, r.height()-5, r.width()-1, r.height()-5);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
painter.drawLine(8, r.height()-4, r.width()-1, r.height()-4);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 35));
painter.drawLine(0, 2, 0, r.height()-11); // left
bitBlt(&buffer, 0, r.height()-11, tabEdges2, 0, 0, 8, 8);
painter.drawTiledPixmap(8, r.height()-6, r.width()-8, 1, *tabHLines, 0, 2); // bottom
painter.drawTiledPixmap(1, 3, 1, r.height()-14, *tabVLines); // left
}
else {
painter.translate(0,3);
renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5-3), g.button(), false); // left
painter.translate(0,-3);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
painter.drawLine(0, r.height()-5, r.width()-8, r.height()-5);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
painter.drawLine(0, r.height()-4, r.width()-8, r.height()-4);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 35));
painter.drawLine(r.width()-1, 2, r.width()-1, r.height()-11); // right
bitBlt(&buffer, r.width()-8, r.height()-11, tabEdges2, 8, 0, 8, 8);
painter.drawTiledPixmap(0, r.height()-6, r.width()-8, 1, *tabHLines, 0, 2); // bottom
painter.drawTiledPixmap(r.width()-2, 3, 1, r.height()-14, *tabVLines); // right
}
}
else { // middle
painter.translate(0,3);
renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5-3), g.button(), false); // left
renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5-3), g.button(), false);// right
painter.translate(0,-3);
painter.translate(0, 3);
renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
painter.translate(0, -3);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
painter.drawLine(0, r.height()-5, r.width()-1, r.height()-5);
painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
painter.drawLine(0, r.height()-4, r.width()-1, r.height()-4);
painter.drawTiledPixmap(0, r.height()-6, r.width(), 1, *tabHLines, 0, 2); // bottom
}
painter.fillRect(TQRect(0, r.height()-3, r.width(), 3), background);
}
p->drawPixmap(r.left(), r.top(), buffer);
}
else { // standard tabs
if(bottom) {
if (selected) {
renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-2), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
TQPixmap* tabEdges2;
TQString position = isFirst ? "first" : isLast ? "last" : isSingle ? "single" : "middle";
if(!(tabEdges2 = TQPixmapCache::find(position+"tabEdges2-bottom-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
tabEdges2 = new TQPixmap(16, 8);
tabEdges2->fill(g.background());
TQPainter painter2(tabEdges2);
if(!isSingle) {
if(!isFirst) {
painter2.translate(0, -r.height()+8);
renderSurface(&painter2, TQRect(0, 0, 2, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
painter2.resetXForm();
painter2.drawTiledPixmap(0, 2, 2, 1, *tabHLines, 0, 2); // left
painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79));
painter2.drawLine(0, 3, 1,3);
painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30));
painter2.drawLine(0, 4, 3, 4);
}
if(!isLast) {
painter2.translate(0, -r.height()+8);
renderSurface(&painter2, TQRect(14, 0, 2, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
painter2.resetXForm();
painter2.drawTiledPixmap(14, 2, 2, 1, *tabHLines, 0, 2); // right
painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79));
painter2.drawLine(14, 3, 15, 3);
painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30));
painter2.drawLine(12, 4, 15, 4);
}
}
painter2.fillRect(TQRect(0, 5, 16, 3), g.background());
painter2.end();
TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
painter2.begin(&tabEdgesMask);
painter2.translate(0, -r.height()+16);
renderSurface(&painter2, TQRect(1, 0, 14, r.height()-2), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
painter2.end();
bitBlt(tabEdges2, 0, 0, &tabEdgesMask, 0, 8);
TQPixmap circle = qembed_findImage("tabWidget");
bitBlt(tabEdges2, 0, 0, &circle, 0, 8);
TQPixmapCache::insert(position+"tabEdges2-bottom-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
}
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79)); // bottomShadow1
painter.drawLine(8, r.height()-2, r.width()-9, r.height()-2);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30)); // bottomShadow2
painter.drawLine(8, r.height()-1, r.width()-9, r.height()-1);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
if(isFirst || isSingle)
painter.drawLine(0, 0, 0, r.height()-8); // left
else
renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5), g.button(), false);
if(isLast || isSingle)
painter.drawLine(r.width()-1, 0, r.width()-1, r.height()-8); // right
else
renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5), g.button(), false);
bitBlt(&buffer, 0, r.bottom()-7, tabEdges2, 0, 0, 8, 8);
bitBlt(&buffer, r.width()-8, r.bottom()-7, tabEdges2, 8, 0, 8, 8);
painter.drawTiledPixmap(8, r.height()-3, r.width()-16, 1, *tabHLines, 0, 2); // bottom
painter.drawTiledPixmap(1, 0, 1, r.height()-8, *tabVLines); // left
painter.drawTiledPixmap(r.width()-2, 0, 1, r.height()-8, *tabVLines); // right
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35)); // clip the first pixels of the separators
painter.drawPoint(0, 0);
painter.drawPoint(r.width()-1, 0);
}
else { // unselected
renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
if(isFirst || isLast) {
TQPixmap* tabEdges2;
if(!(tabEdges2 = TQPixmapCache::find("tabEdges2-bottom"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
tabEdges2 = new TQPixmap(16, 8);
tabEdges2->fill(g.background());
TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
TQPainter painter2(&tabEdgesMask);
painter2.translate(0, -r.height()+19);
renderSurface(&painter2, TQRect(1, 0, 14, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
painter2.end();
bitBlt(tabEdges2, 0, 0, &tabEdgesMask, 0, 8);
TQPixmap circle = qembed_findImage("tabWidget");
bitBlt(tabEdges2, 0, 0, &circle, 0, 8);
TQPixmapCache::insert("tabEdges2-bottom"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
}
if(isFirst) {
renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5), g.button(), false);// right
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79)); // bottomShadow1
painter.drawLine(8, r.height()-5, r.width()-1, r.height()-5);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30)); // bottomShadow2
painter.drawLine(8, r.height()-4, r.width()-1, r.height()-4);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
painter.drawLine(0, 1, 0, r.height()-12); // left
bitBlt(&buffer, 0, r.height()-11, tabEdges2, 0, 0, 8, 8);
painter.drawTiledPixmap(1, 1, 1, r.height()-12, *tabVLines); // left
painter.drawTiledPixmap(8, r.height()-6, r.width()-8, 1, *tabHLines, 0, 2); // bottom
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 55));
painter.drawLine(0, 0, r.width()-1, 0); // top
}
else {
renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5), g.button(), false); // left
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79)); // bottomShadow1
painter.drawLine(0, r.height()-5, r.width()-8, r.height()-5);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30)); // bottomShadow2
painter.drawLine(0, r.height()-4, r.width()-8, r.height()-4);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
painter.drawLine(r.width()-1, 1, r.width()-1, r.height()-12); // right
bitBlt(&buffer, r.width()-8, r.height()-11, tabEdges2, 8, 0, 8, 8);
painter.drawTiledPixmap(r.width()-2, 1, 1, r.height()-12, *tabVLines); // right
painter.drawTiledPixmap(0, r.height()-6, r.width()-8, 1, *tabHLines, 0, 2); // bottom
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 55));
painter.drawLine(0, 0, r.width()-1, 0); // top
}
}
else { // middle
renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5), g.button(), false); // left
renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5), g.button(), false);// right
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79)); // bottomShadow1
painter.drawLine(0, r.height()-5, r.width()-1, r.height()-5);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30)); // bottomShadow2
painter.drawLine(0, r.height()-4, r.width()-1, r.height()-4);
painter.drawTiledPixmap(0, r.height()-6, r.width(), 1, *tabHLines, 0, 2); // bottom
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 55));
painter.drawLine(0, 0, r.width()-1, 0); // top
}
painter.fillRect(TQRect(0, r.height()-3, r.width(), 3), g.background()); // rect under the tab, clips also the tabSeperator
}
}
else { // above
if (selected) {
renderSurface(&painter, TQRect(1, 1, r.width()-2, r.height()), g.background(), g.button(), g.button(), Is_ActiveTabTop);
TQPixmap* tabEdges2;
TQString position = isFirst ? "first" : isLast ? "last" : isSingle ? "single" : "middle";
if(!(tabEdges2 = TQPixmapCache::find(position+"tabEdges2-top-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
tabEdges2 = new TQPixmap(16,8);
tabEdges2->fill(g.background());
TQPainter painter2(tabEdges2);
if(!isSingle) {
painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
if(!isFirst) {
renderSurface(&painter2, TQRect(0, 4, 2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
painter2.drawLine(0, 3, 1, 3); // topLine
painter2.drawTiledPixmap(0, 4, 2, 2, *tabHLines);
}
if(!isLast) {
renderSurface(&painter2, TQRect(14, 4, 2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
painter2.drawLine(14, 3, 15, 3); // topLine
painter2.drawTiledPixmap(14, 4, 2, 2, *tabHLines);
}
}
painter2.end();
TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
painter2.begin(&tabEdgesMask);
renderSurface(&painter2, TQRect(1, 1, 14, r.height()), g.background(), g.button(), g.button(), Is_ActiveTabTop);
painter2.end();
bitBlt(tabEdges2, 0, 0, &tabEdgesMask);
TQPixmap circle = qembed_findImage("tabWidget");
bitBlt(tabEdges2, 0, 0, &circle);
TQPixmapCache::insert(position+"tabEdges2-top-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
}
///////////////////////////////////////////////
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
///painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 40));
if(isFirst || isSingle)
painter.drawLine(0, 8, 0, r.height()-1); // left
else
renderTabSeparator(&painter, TQRect(0, 4, 1, r.height()), g.button(), true);
if(isLast || isSingle)
painter.drawLine(r.width()-1, 8, r.width()-1, r.height()-1); // right
else
renderTabSeparator(&painter, TQRect(r.width()-1, 4, 1, r.height()), g.button(), true);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
painter.drawLine(8, 0, r.width()-9, 0); // top
bitBlt(&buffer, 0, 0, tabEdges2, 0, 0, 8, 8, TQt::CopyROP);
bitBlt(&buffer, r.width()-8, 0, tabEdges2, 8, 0, 8, 8, TQt::CopyROP);
painter.drawTiledPixmap(8, 1, r.width()-16, 2, *tabHLines); // top
painter.drawTiledPixmap(1, 8, 1, r.height()-1, *tabVLines); // left
painter.drawTiledPixmap(r.width()-2, 8, 1, r.height()-1, *tabVLines); // right
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35)); // clip the last pixels of the separators
painter.drawPoint(0, r.height()-1);
painter.drawPoint(r.width()-1, r.height()-1);
}
else { // unselected
painter.fillRect(0, 0, r.width(), 10, g.background());
painter.setPen(g.background().dark(150));
renderSurface(&painter, TQRect(1, 4, r.width()-2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
if(isFirst || isLast) {
TQPixmap* tabEdges2;
if(!(tabEdges2 = TQPixmapCache::find("tabEdges2-top"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
tabEdges2 = new TQPixmap(16, 8);
tabEdges2->fill(g.background());
TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
TQPainter painter2(&tabEdgesMask);
renderSurface(&painter2, TQRect(1, 1, r.width()-2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
painter2.end();
bitBlt(tabEdges2, 0, 0, &tabEdgesMask);
TQPixmap circle = qembed_findImage("tabWidget");
bitBlt(tabEdges2, 0, 0, &circle);
TQPixmapCache::insert("tabEdges2-top"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
}
if(isFirst) {
// darker separator
renderTabSeparator(&painter, TQRect(r.width()-1, 4, 1, r.height()), g.button(), true); // left
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
painter.drawLine(8, 3, r.width()-1, 3); // topLine
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
painter.drawLine(0, 10, 0, r.height()-1); // left
painter.drawLine(1, r.height()-1, r.width()-1, r.height()-1); // bottom
painter.drawTiledPixmap(8, 4, r.width()-1, 2, *tabHLines); // top
painter.drawTiledPixmap(1, 11, 1, r.height()-12, *tabVLines); // left
bitBlt(&buffer, 0, 3, tabEdges2, 0, 0, 8, 8);
}
else {
// darker separator
renderTabSeparator(&painter, TQRect(0, 4, 1, r.height()), g.button(), true); // right
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
painter.drawLine(0, 3, r.width()-9, 3); // topLine
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
painter.drawLine(r.width()-1, 10, r.width()-1, r.height()-1); // right
painter.drawLine(0, r.height()-1, r.width()-2, r.height()-1); // bottom
painter.drawTiledPixmap(0, 4, r.width()-8, 2, *tabHLines); // top
painter.drawTiledPixmap(r.width()-2, 11, 1, r.height()-12, *tabVLines); // right
bitBlt(&buffer, r.width()-8, 3, tabEdges2, 8, 0, 8, 8);
}
}
else { // middle
renderTabSeparator(&painter, TQRect(r.width()-1, 4, 1, r.height()), g.button(), true); // left
renderTabSeparator(&painter, TQRect(0, 4, 1, r.height()), g.button(), true); // right
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
painter.drawLine(0, 3, r.width()-1, 3); // top
painter.drawTiledPixmap(0, 4, r.width(), 2, *tabHLines);
painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
painter.drawLine(0, r.height()-1, r.width()-1, r.height()-1); // bottom
}
}
}
p->drawPixmap(r.left(), r.top(), buffer);
}
}
void DominoStyle::drawTDEStylePrimitive(TDEStylePrimitive kpe,
TQPainter *p,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQColorGroup &cg,
SFlags flags,
const TQStyleOption& opt,
const TQWidget* widget) const
{
//return TDEStyle::drawTDEStylePrimitive(kpe, p, ceData, elementFlags, r, cg, flags, opt, widget);
// SLIDER
// ------
switch( kpe ) {
case KPE_SliderGroove: {
bool horizontal = ((const TQSlider*)widget)->orientation() == Horizontal;
TQRect re;
if(horizontal)
re.setRect(r.left(), r.y()+r.height()/2-3, r.width(), 4);
else
re.setRect(r.x()+r.width()/2-3, r.top(), 4, r.height());
bool parentBgPix = widget->parentWidget() ? widget->parentWidget()->paletteBackgroundPixmap() : 0;
TQString hori = horizontal ? "1" : "0";
TQString trans = parentBgPix ? "1" : "0";
TQPixmap* sliderGroove;
if(!(sliderGroove = TQPixmapCache::find(TQString::number(cg.background().pixel(), 16)+"sliderGroove"+hori+trans))) {
if(parentBgPix) { // ### the pix are transparent!
if(!horizontal) {
TQWMatrix m;
m.rotate(-90);
sliderGroove = new TQPixmap(qembed_findImage("slGHBody").xForm(m));
}
else
sliderGroove = new TQPixmap(qembed_findImage("slGHBody"));
}
else {
const TQColor c1 = alphaBlendColors(TQColor(0,0,0), cg.background(), 11);
const TQColor c2 = alphaBlendColors(TQColor(53,53,53), cg.background(), 155);
const TQColor c3 = alphaBlendColors(TQColor(67,67,67), cg.background(), 146);
const TQColor c4 = alphaBlendColors(TQColor(83,83,83), cg.background(), 140);
const TQColor c5 = alphaBlendColors(TQColor(101,101,101), cg.background(), 134);
const TQColor c6 = alphaBlendColors(TQColor(254,254,254), cg.background(), 43);
const TQColor c7 = alphaBlendColors(TQColor(255,255,255), cg.background(), 9);
sliderGroove = new TQPixmap(7, 7);
TQPainter painter(sliderGroove);
TQRect rr = sliderGroove->rect();
if (horizontal) {
painter.setPen(c1);
painter.drawLine(0, 0, 7, 0);
painter.setPen(c2);
painter.drawLine(0, 1, 7, 1);
painter.setPen(c3);
painter.drawLine(0, 2, 7, 2);
painter.setPen(c4);
painter.drawLine(0, 3, 7, 3);
painter.setPen(c5);
painter.drawLine(0, 4, 7, 4);
painter.setPen(c6);
painter.drawLine(0, 5, 7, 5);
painter.setPen(c7);
painter.drawLine(0, 6, 7, 6);
}
else {
painter.setPen(c1);
painter.drawLine(0, 0, 0, 7);
painter.setPen(c2);
painter.drawLine(1, 0, 1 , 7);
painter.setPen(c3);
painter.drawLine(2, 0, 2 , 7);
painter.setPen(c4);
painter.drawLine(3, 0, 3, 7);
painter.setPen(c5);
painter.drawLine(4, 0, 4, 7);
painter.setPen(c6);
painter.drawLine(5, 0, 5, 7);
painter.setPen(c7);
painter.drawLine(6, 0, 6, 7);
}
}
TQPixmapCache::insert(TQString::number(cg.background().pixel(), 16)+"sliderGroove"+hori+trans, sliderGroove);
}
if (horizontal) {
TQPixmap* slGh;
if(parentBgPix || !(slGh = TQPixmapCache::find(TQString::number(cg.background().pixel(), 16)+"slGh"))) { // rounded edges
if(parentBgPix)
slGh = new TQPixmap(qembed_findImage("slGh"));
else {
slGh = new TQPixmap(6, 7);
slGh->fill(cg.background());
TQPixmap pix = qembed_findImage("slGh");
bitBlt(slGh, 0, 0, &pix, 0, 0, -1, -1, TQt::CopyROP);
}
TQPixmapCache::insert(TQString::number(cg.background().pixel(), 16)+"slGh",slGh );
}
bitBlt(p->device(), re.x(), re.y(), slGh, 0, 0, 3, 7, TQt::CopyROP);
bitBlt(p->device(), r.width()-3, re.y(), slGh, 3, 0, 3, 7, TQt::CopyROP);
p->drawTiledPixmap(re.x()+3, re.y(), r.width()-6, 7, *sliderGroove);
}
else {
TQPixmap* slGv;
if(parentBgPix || !(slGv = TQPixmapCache::find(TQString::number(cg.background().pixel(), 16)+"slGv"))) {
if(parentBgPix)
slGv = new TQPixmap(qembed_findImage("slGv"));
else {
slGv = new TQPixmap(7, 6);
slGv->fill(cg.background());
TQPixmap pix = qembed_findImage("slGv");
bitBlt(slGv, 0, 0, &pix, 0, 0, -1, -1, TQt::CopyROP);
}
TQPixmapCache::insert(TQString::number(cg.background().pixel(), 16)+"slGv",slGv );
}
bitBlt(p->device(), re.x(), re.y(), slGv, 0, 0, 7, 3, TQt::CopyROP);
bitBlt(p->device(), re.x(), re.height()-3, slGv, 0, 3, 7, 3, TQt::CopyROP);
p->drawTiledPixmap(re.x(), re.y()+3, 7, r.height()-6, *sliderGroove);
}
break;
}
case KPE_SliderHandle: {
const TQSlider* slider = (const TQSlider*)widget;
int y, x;
if(slider->orientation() == Horizontal) {
x = r.x();
y =r.y()+r.height()/2-8+1;
}
else {
y = r.y()+1;
x = r.x()+r.width()/2-8;
}
TQPixmap* handle;
if(!(handle = TQPixmapCache::find("sliderHandle"+TQString::number(cg.button().pixel(), 16)))) {
TQPixmap insidePix = qembed_findImage("sliderHandle2inside"); // a filled antialiased circle to draw the gradients on
TQPainter painter(&insidePix);
flatMode=true;
renderSurface(&painter, TQRect(1, 0, 13, 15), cg.background(), cg.button(), cg.button(), Is_Button|Is_Horizontal);
flatMode=false;
TQImage inside = insidePix.convertToImage();
TQImage circle = tintImage(qembed_findImage("sliderHandle2circle"),
_customSliderHandleContourColor ? buttonContour->contourColor(Contour_Default) : alphaBlendColors(black, cg.button(), 110));
TQImage shadow = qembed_findImage("sliderHandle2shadow");
blend(shadow, inside, inside);
blend(circle, inside, inside);
handle = new TQPixmap(inside);
TQPixmapCache::insert("sliderHandle"+TQString::number(cg.button().pixel(), 16), handle );
}
bitBlt(p->device(), x, y, handle, 0, 0, -1, -1, TQt::CopyROP);
break;
}
case KPE_ListViewExpander: {
TQWidget* w = dynamic_cast<TQWidget*>(p->device());
p->setPen( cg.text() );
TQColor bg = w ? w->paletteBackgroundColor() : cg.background();
TQString hasBgPix = w && w->paletteBackgroundPixmap() ? "1" : "0";
TQString expanded = flags & Style_Off ? "1" : "0";
TQPixmap* lve;
if(_drawTriangularExpander) {
if(!(lve = TQPixmapCache::find(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveT"+hasBgPix+expanded))) {
TQWMatrix m;
m.rotate(90);
if(w && !w->paletteBackgroundPixmap()) {
TQImage img = tintImage(qembed_findImage("lveTriangular"), cg.text());
int w=7, h=9;
if(flags & Style_Off) {
w=9, h=7;
img = img.xForm(m);
}
TQImage imgBG(w,h,32);
imgBG.fill(bg.rgb());
bitBlt(&imgBG, 0, 0, &img);
lve = new TQPixmap(imgBG);
}
else {
if(flags & Style_Off)
lve = new TQPixmap(tintImage(qembed_findImage("lveTriangular").xForm(m), cg.text()));
else
lve = new TQPixmap(tintImage(qembed_findImage("lveTriangular"), cg.text()));
}
TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveT"+hasBgPix+expanded, lve);
}
p->drawPixmap(r.x(), r.y(), *lve);
}
else {
if(!(lve = TQPixmapCache::find(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+expanded))) {
if(w && !w->paletteBackgroundPixmap()) {
lve = new TQPixmap(11,11);
lve->fill(bg);
TQPainter painter(lve);
painter.drawPixmap(0, 0, tintImage(qembed_findImage("lve"), cg.text()));
// plus or minus
painter.drawLine( 3, 5, 7, 5 );
if ( flags & Style_On ) // Collapsed = On
painter.drawLine( 5, 3, 5, 7 );
TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+expanded, lve);
}
else {
TQImage img = TQImage(11, 11, 32);
img.setAlphaBuffer(true);
for(int x=0; x < img.width(); ++x) {
for(int y=0; y < img.height(); ++y) {
img.setPixel(x, y, tqRgba(0, 0, 0, 0));
}
}
TQImage img2 = tintImage(qembed_findImage("lve"), cg.text());
bitBlt(&img, 0, 0, &img2);
int r, b, g;
int a = 255;
cg.text().getRgb(&r, &g, &b);
// minus
img.setPixel(3, 5, tqRgba(r, b, g, a));
img.setPixel(4, 5, tqRgba(r, b, g, a));
img.setPixel(5, 5, tqRgba(r, b, g, a));
img.setPixel(6, 5, tqRgba(r, b, g, a));
img.setPixel(7, 5, tqRgba(r, b, g, a));
if ( flags & Style_Off )
lve = new TQPixmap(img);
TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+"1", new TQPixmap(img));
// plus
img.setPixel(5, 3, tqRgba(r, b, g, a));
img.setPixel(5, 4, tqRgba(r, b, g, a));
img.setPixel(5, 6, tqRgba(r, b, g, a));
img.setPixel(5, 7, tqRgba(r, b, g, a));
if ( flags & Style_On )
lve = new TQPixmap(img);
TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+"0", new TQPixmap(img));
}
}
p->drawPixmap(r.x()-1,r.y()-1, *lve);
}
break;
}
// copied and slightly modified from TDEStyle.
case KPE_ListViewBranch: {
if(_drawTriangularExpander) break;
// Typical Windows style listview branch element (dotted line).
// Create the dotline pixmaps if not already created
if ( !verticalLine )
{
// make 128*1 and 1*128 bitmaps that can be used for
// drawing the right sort of lines.
verticalLine = new TQBitmap( 1, 129, true );
horizontalLine = new TQBitmap( 128, 1, true );
TQPointArray a( 64 );
TQPainter p2;
p2.begin( verticalLine );
int i;
for( i=0; i < 64; i++ )
a.setPoint( i, 0, i*2+1 );
p2.setPen( color1 );
p2.drawPoints( a );
p2.end();
TQApplication::flushX();
verticalLine->setMask( *verticalLine );
p2.begin( horizontalLine );
for( i=0; i < 64; i++ )
a.setPoint( i, i*2+1, 0 );
p2.setPen( color1 );
p2.drawPoints( a );
p2.end();
TQApplication::flushX();
horizontalLine->setMask( *horizontalLine );
}
p->setPen( cg.mid() );
if (flags & Style_Horizontal)
{
int point = r.x();
int other = r.y();
int end = r.x()+r.width();
int thickness = r.height();
while( point < end )
{
int i = 128;
if ( i+point > end )
i = end-point;
p->drawPixmap( point, other, *horizontalLine, 0, 0, i, thickness );
point += i;
}
} else {
int point = r.y();
int other = r.x();
int end = r.y()+r.height();
int thickness = r.width();
int pixmapoffset = (flags & Style_NoChange) ? 0 : 1; // ### Hackish
while( point < end )
{
int i = 128;
if ( i+point > end )
i = end-point;
p->drawPixmap( other, point, *verticalLine, 0, pixmapoffset, thickness, i );
point += i;
}
}
break;
}
default:
TDEStyle::drawTDEStylePrimitive( kpe, p, ceData, elementFlags, r, cg, flags, opt, widget );
}
}
void DominoStyle::drawPrimitive(PrimitiveElement pe,
TQPainter *p,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQColorGroup &cg,
SFlags flags,
const TQStyleOption &opt ) const
{
bool down = flags & Style_Down;
bool on = flags & Style_On;
bool sunken = flags & Style_Sunken;
bool horiz = flags & Style_Horizontal;
const bool enabled = flags & Style_Enabled;
const bool mouseOver = flags & Style_MouseOver;
// bool hasFocus = flags & Style_HasFocus;
int x = r.x();
int y = r.y();
int w = r.width();
int h = r.height();
//return TDEStyle::drawPrimitive(pe, p, ceData, elementFlags, r, cg, flags, opt);
switch(pe) {
case PE_FocusRect: {
if(rubberBandType == DistRubber || (rubberBandType == ArgbRubber && !compositeManagerRunning)) {
p->drawWinFocusRect( r );
break;
}
TQWidget* w = dynamic_cast<TQWidget*>(p->device());
if(rubberBandType == ArgbRubber && compositeManagerRunning && viewPortPressed && dynamic_cast<TQListView*>(w->parentWidget())) {
TQListView* lv = dynamic_cast<TQListView*>(w->parentWidget());
if(!lv->currentItem())
break;
TQRect sr = lv->itemRect(lv->currentItem());
TQRect rr = r.normalize();
int step = lv->rootIsDecorated() ? (lv->currentItem()->depth()+1)*lv->treeStepSize() : lv->currentItem()->depth()*lv->treeStepSize();
if(dynamic_cast<TQCheckListItem*>(lv->currentItem()))
step += 16+lv->itemMargin()+4;
// why is the focusrect misused as a rubberband!?
if((lv->selectionMode() == TQListView::Multi || lv->selectionMode() == TQListView::Extended) &&
!((sr.y() == rr.y()) && (sr.height() == rr.height()) && (sr.x()+step == rr.x()))) {
TQScrollView* sv = static_cast<TQScrollView*>(w);
TQPoint po = w->mapFrom(sv, r.topLeft());
TQRect re = TQRect(po.x(), po.y(), r.width(), r.height());
drawPrimitive(PE_RubberBand, p, ceData, elementFlags, r, cg, flags, opt);
break;
}
}
if(ignoreNextFocusRect) {
ignoreNextFocusRect= false;
break;
}
TQColor color = alphaBlendColors(cg.highlight(), cg.foreground(), 160);
if(w && (w->isA("TQViewportWidget") || dynamic_cast<TQWidget*>(p->device())->isA("RegionGrabber"))) { // TQListView, TQListBox, KSnapshot...
// we can't be sure if the pixamp edges will be erased, so only a simple rect.
p->setPen(TQPen(color, 1, TQt::SolidLine));
p->drawRect(r);
break;
}
TQPixmap* edges;
if(!(edges = TQPixmapCache::find("fre"+TQString::number(color.pixel(), 16)))) {
edges = new TQPixmap(tintImage(qembed_findImage("focusRectEdges"), color));
TQPixmapCache::insert("fre"+TQString::number(color.pixel(), 16), edges);
}
p->drawPixmap(r.left(), r.top(), *edges, 0, 0, 3, 3);
p->drawPixmap(r.left(), r.bottom()-2, *edges, 0, 3, 3, 3);
p->drawPixmap(r.right()-2, r.top(), *edges, 3, 0, 3, 3);
p->drawPixmap(r.right()-2, r.bottom()-2, *edges, 3, 3, 3, 3);
p->setPen(color);
p->drawLine(r.left()+3, r.top(), r.right()-2, r.y());
p->drawLine(r.left()+3, r.bottom(), r.right()-2, r.bottom());
p->drawLine(r.left(), r.top()+3, r.left(), r.bottom()-2);
p->drawLine(r.right(), r.top()+3, r.right(), r.bottom()-2);
break;
}
case PE_HeaderSection: { // also taskbar buttons
if(dynamic_cast<TQWidget*>(p->device()) && dynamic_cast<TQWidget*>(p->device())->isA("PanelKMenu")) {
TQWidget* w = dynamic_cast<TQWidget*>(p->device());
if(w->parentWidget() && w->parentWidget()->paletteBackgroundPixmap()) {
TQPixmap pix(w->width(), w->height());
TQPainter painter(&pix);
TQPoint point = TQPoint(w->geometry().x(), w->geometry().y());
painter.drawTiledPixmap( 0, 0, w->width(), w->height(),
*w->parentWidget()->backgroundPixmap(),
point.x(), point.y() );
// if the PopupTitle is hovered by the mouse, we don't have access to the parent background pixmap,
// so it must have have its own one.
w->setUpdatesEnabled(false);
w->setErasePixmap(pix);
w->setUpdatesEnabled(true);
w->erase();
}
else
w->erase(r);
break;
}
renderHeader(p, r, cg, (on||down||sunken), mouseOver, true, enabled );
break;
}
// BUTTONS
// -------
case PE_ButtonTool:
case PE_ButtonDropDown:
case PE_ButtonBevel:
case PE_ButtonCommand: {
// the above promitives are not called from within the style
if(dynamic_cast<TQPixmap*>(p->device())) // more likely a backgroundPixmap than a doublebuffer
buttonContour->setAlphaMode();
renderButton(p, r, cg, (on||down), mouseOver, true, enabled, tdehtmlWidgets.contains(opt.widget()) );
buttonContour->reset();
break;
}
case PE_ButtonDefault: {
break;
}
case PE_SpinWidgetPlus:
case PE_SpinWidgetMinus: {
p->setPen( cg.buttonText() );
int l = TQMIN( w-2, h-2 );
// make the length even so that we get a nice symmetric plus...
if(l%2 != 0)
--l;
TQPoint c = r.center();
p->drawLine( c.x()-l/2, c.y(), c.x()+l/2, c.y() );
if ( pe == PE_SpinWidgetPlus ) {
p->drawLine( c.x(), c.y()-l/2, c.x(), c.y()+l/2 );
}
break;
}
case PE_ScrollBarSlider: {
TQColor buttonColor = cg.button();
TQPixmap buffer;
if(horiz)
buffer.resize(r.width()-14, r.height());
else
buffer.resize(r.width(), r.height()-14);
if(buffer.isNull()) break;
TQRect br = buffer.rect();
TQPainter painter(&buffer);
if(horiz) {
uint surfaceFlags = Is_ScrollBarBtn|Is_Horizontal;
renderSurface(&painter, br, cg.button(), cg.button(), buttonColor, surfaceFlags);
uint contourFlags = Is_ScrollBarBtn|Is_Horizontal|Draw_Top|Draw_Bottom;
renderContour(&painter, TQRect(-2, 0, br.width()+4, br.height()), cg.button(), buttonColor, contourFlags);
p->drawPixmap(r.left()+7, r.y(), buffer);
}
else {
uint surfaceFlags = Is_ScrollBarBtn;
renderSurface(&painter, br, cg.button(), cg.button(), buttonColor, surfaceFlags);
uint contourFlags = Is_ScrollBarBtn|Draw_Left|Draw_Right;
renderContour(&painter, TQRect(0, -2, br.width(), br.height()+4), cg.button(), buttonColor, contourFlags);
bitBlt(p->device(), r.x(), r.y()+7, &buffer, 0, 0, -1, -1, TQt::CopyROP);
}
break;
}
case PE_ScrollBarAddPage: { // bottom / right
TQColor buttonColor = cg.button();
TQColor contourColor = alphaBlendColors(buttonContour->contourColor(Contour_Default), buttonColor, 203);
TQPixmap* addPageBtn;
TQPixmap buffer;
uint surfaceFlags = Is_ScrollBarBtn;
if(horiz)
surfaceFlags |= Is_Horizontal;
int sl = 6;
if(sliderlen < 14)
sl = sliderlen/2-1;
//// button part
if(horiz) {
buffer.resize(r.width()+sl, r.height());
if(buffer.isNull()) break;
if(!(addPageBtn = TQPixmapCache::find(TQString::number(buttonColor.pixel(), 16)+"ah"+configMode ))) {
TQPixmap gradientPix = qembed_findImage("scrollBtnHMask");
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollBtnHShadow");
TQImage img3 = tintImage(qembed_findImage("scrollBtnHContour"), contourColor);
blend(img2, img1, img1);
blend(img3, img1, img1);
addPageBtn = new TQPixmap(img1);
TQPixmapCache::insert(TQString::number(buttonColor.pixel(), 16)+"ah"+configMode, addPageBtn);
}
}
else {
buffer.resize(r.width(), r.height()+sl);
if(buffer.isNull()) break;
if(!(addPageBtn = TQPixmapCache::find(TQString::number(buttonColor.pixel(), 16)+"av"+configMode ))) {
TQPixmap gradientPix = qembed_findImage("scrollBtnVMask");
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollBtnVShadow");
TQImage img3 = tintImage(qembed_findImage("scrollBtnVContour"), contourColor);
blend(img2, img1, img1);
blend(img3, img1, img1);
addPageBtn = new TQPixmap(img1);
TQPixmapCache::insert(TQString::number(buttonColor.pixel(), 16)+"av"+configMode, addPageBtn);
}
}
TQRect br(buffer.rect() );
TQPainter bp(&buffer);
//// groove
if(sliderlen >= 10) {
surfaceFlags = Is_ScrollBarGroove;
if(horiz)
surfaceFlags |= Is_Horizontal;
TQColor grooveLine = alphaBlendColors(black, buttonColor, 80);
renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), grooveLine, grooveLine, grooveLine, surfaceFlags);
bp.setClipRegion(horiz ? TQRect(0, 1, br.width(), br.height()-2) : TQRect(1, 0, br.width()-2, br.height()));
renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
bp.setClipping(false);
}
else {
renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
uint contourFlags = Is_ScrollBarBtn;
contourFlags |= (horiz)? Draw_Top|Draw_Bottom : Draw_Left|Draw_Right;
renderContour(&bp, horiz?TQRect(-2, 0, br.width()+4, br.height()):TQRect(0, -2, br.width(), br.height()+4), buttonColor, buttonColor, contourFlags);
}
TQString docked = (!horiz && r.height() == 1) || (horiz && r.width() == 1) ? "1" : "0";
TQPixmap* sliderCap;
if(horiz) {
if(!(sliderCap = TQPixmapCache::find("sHCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode))) {
if(r.width() == 1) {
TQPixmap gradientPix(16, 15);
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollSliderHDockedShadow");
TQImage img3 = tintImage(qembed_findImage("scrollSliderHDockedContour"), contourColor);
bitBlt(&img1, 0, 0, &img2);
bitBlt(&img1, 0, 0, &img3);
sliderCap = new TQPixmap(img1);
}
else {
TQPixmap gradientPix = qembed_findImage("scrollSliderHMask");
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollSliderHShadow");
TQImage img3 = tintImage(qembed_findImage("scrollSliderHContour"), contourColor);
blend(img2, img1, img1);
blend(img3, img1, img1);
sliderCap = new TQPixmap(img1);
}
TQPixmapCache::insert("sHCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
}
}
else {
if(!(sliderCap = TQPixmapCache::find("sVCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode))) {
if(r.height() == 1) {
TQPixmap gradientPix(15, 16);
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollSliderVDockedShadow");
TQImage img3 = tintImage(qembed_findImage("scrollSliderVDockedContour"), contourColor);
bitBlt(&img1, 0, 0, &img2);
bitBlt(&img1, 0, 0, &img3);
sliderCap = new TQPixmap(img1);
}
else {
TQPixmap gradientPix = qembed_findImage("scrollSliderVMask");
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollSliderVShadow");
TQImage img3 = tintImage(qembed_findImage("scrollSliderVContour"), contourColor);
blend(img2, img1, img1);
blend(img3, img1, img1);
sliderCap = new TQPixmap(img1);
}
TQPixmapCache::insert("sVCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
}
}
////////////
if(horiz) {
if(sliderlen >= 10) {
bp.drawPixmap(br.right()-8, 0, *addPageBtn, 9, 0, 9, 15);
bp.drawPixmap(-6+sl, 0, *sliderCap, 8, 0, 8, 15);
}
bitBlt(p->device(), r.x()-sl, r.y(), &buffer, 0, 0, br.width(), br.height(), TQt::CopyROP);
}
else {
if(sliderlen >= 10) {
bp.drawPixmap(0, br.bottom()-8, *addPageBtn, 0, 9, 15, 9);
bp.drawPixmap(0, (br.height() <= 6)? br.bottom()-6 :br.top(), *sliderCap, 0, 8, 15, 8);
}
bitBlt(p->device(), r.x(), r.y()-sl, &buffer, 0, 0, br.width(), br.height(), TQt::CopyROP);
}
break;
}
case PE_ScrollBarSubPage: { // top / left
TQColor buttonColor = cg.button();
TQColor contourColor = alphaBlendColors(buttonContour->contourColor(Contour_Default), buttonColor, 203);
TQPixmap* subPageBtn;
TQPixmap buffer;
uint surfaceFlags = Is_ScrollBarBtn;
if(horiz)
surfaceFlags |= Is_Horizontal;
int sl = 6;
if(sliderlen < 14)
sl = sliderlen/2;
//// button part
if(horiz) {
buffer.resize(r.width()+sl, r.height());
if(buffer.isNull()) break;
if(!(subPageBtn = TQPixmapCache::find(TQString::number(buttonColor.pixel(), 16)+"sh"+configMode ))) {
TQPixmap gradientPix = qembed_findImage("scrollBtnHMask");
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollBtnHShadow");
TQImage img3 = tintImage(qembed_findImage("scrollBtnHContour"), contourColor);
blend(img2, img1, img1);
blend(img3, img1, img1);
subPageBtn = new TQPixmap(img1);
TQPixmapCache::insert(TQString::number(buttonColor.pixel(), 16)+"sh"+configMode, subPageBtn);
}
}
else {
buffer.resize(r.width(), r.height()+sl);
if(buffer.isNull()) break;
if(!(subPageBtn = TQPixmapCache::find(TQString::number(buttonColor.pixel(), 16)+"sv"+configMode ))) {
TQPixmap gradientPix = qembed_findImage("scrollBtnVMask");
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollBtnVShadow");
TQImage img3 = tintImage(qembed_findImage("scrollBtnVContour"), contourColor);
blend(img2, img1, img1);
blend(img3, img1, img1);
subPageBtn = new TQPixmap(img1);
TQPixmapCache::insert(TQString::number(buttonColor.pixel(), 16)+"sv"+configMode, subPageBtn);
}
}
TQRect br(buffer.rect());
TQPainter bp(&buffer);
//// groove
if(sliderlen >= 10) {
surfaceFlags = Is_ScrollBarGroove;
if(horiz)
surfaceFlags |= Is_Horizontal;
TQColor grooveLine = alphaBlendColors(black, buttonColor, 80);
renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), grooveLine, grooveLine, grooveLine, surfaceFlags);
bp.setClipRegion(horiz ? TQRect(0, 1, br.width(), br.height()-2) : TQRect(1, 0, br.width()-2, br.height()));
renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
bp.setClipping(false);
}
else {
renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
uint contourFlags = Is_ScrollBarBtn;
contourFlags |= (horiz)? Draw_Top|Draw_Bottom : Draw_Left|Draw_Right;
renderContour(&bp, horiz?TQRect(-2, 0, br.width()+4, br.height()):TQRect(0, -2, br.width(), br.height()+4), buttonColor, buttonColor, contourFlags);
}
TQString docked = (!horiz && r.bottom() == 15) || (horiz && r.right() == 15) ? "1" : "0";
TQPixmap* sliderCap;
if(horiz) {
if(!(sliderCap = TQPixmapCache::find("sHCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode))) {
if(r.right() == 15) {
TQPixmap gradientPix(16, 15);
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollSliderHDockedShadow");
TQImage img3 = tintImage(qembed_findImage("scrollSliderHDockedContour"), contourColor);
bitBlt(&img1, 0, 0, &img2);
bitBlt(&img1, 0, 0, &img3);
sliderCap = new TQPixmap(img1);
}
else {
TQPixmap gradientPix = qembed_findImage("scrollSliderHMask");
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollSliderHShadow");
TQImage img3 = tintImage(qembed_findImage("scrollSliderHContour"), contourColor);
blend(img2, img1, img1);
blend(img3, img1, img1);
sliderCap = new TQPixmap(img1);
}
TQPixmapCache::insert("sHCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
}
}
else {
if(!(sliderCap = TQPixmapCache::find("sVCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode))) {
if(r.bottom() == 15) {
TQPixmap gradientPix(15, 16);
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollSliderVDockedShadow");
TQImage img3 = tintImage(qembed_findImage("scrollSliderVDockedContour"), contourColor);
bitBlt(&img1, 0, 0, &img2);
bitBlt(&img1, 0, 0, &img3);
sliderCap = new TQPixmap(img1);
}
else {
TQPixmap gradientPix = qembed_findImage("scrollSliderVMask");
TQPainter painter(&gradientPix);
renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
TQImage img1 = gradientPix.convertToImage();
TQImage img2 = qembed_findImage("scrollSliderVShadow");
TQImage img3 = tintImage(qembed_findImage("scrollSliderVContour"), contourColor);
blend(img2, img1, img1);
blend(img3, img1, img1);
sliderCap = new TQPixmap(img1);
}
TQPixmapCache::insert("sVCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
}
}
if(horiz) {
if(sliderlen >= 10) {
bp.drawPixmap(0, 0, *subPageBtn, 0, 0, 9, 15);
bp.drawPixmap((br.width() <= 6)? -2 : br.width()-8, 0, *sliderCap, 0, 0, 8, 15);
}
}
else {
if(sliderlen >= 10) {
bp.drawPixmap(0, 0, *subPageBtn, 0, 0, 15, 9);
bp.drawPixmap(0, br.bottom()-sl-2+1, *sliderCap, 0, 0, 15, 8);
}
}
bitBlt(p->device(), r.x(), r.y(), &buffer, 0, 0, br.width(), br.height(), TQt::CopyROP);
break;
}
// SCROLLBAR BUTTONS
// -----------------
case PE_ScrollBarSubLine: { // top / left button
uint contourFlags = Is_ScrollBarBtn;
TQRect cr = r;
TQRect ar = r;
TQRect sr = r;
if(horiz) {
contourFlags |= Is_Horizontal|Draw_Top|Draw_Bottom;
if(r.x() == 0) { // = single Button
sr.setX(2);
sr.setWidth(13);
ar.setX(3);
contourFlags |= Draw_Left|Round_BottomLeft|Round_UpperLeft;
}
else {
cr.setWidth(17);
cr.setX(cr.x()-2);
}
}
else {
ar.setX(1);
contourFlags |= Draw_Left|Draw_Right;
if(r.y() == 0) {
sr.setY(2);
sr.setHeight(13);
ar.setY(3);
contourFlags |= Draw_Top|Round_UpperLeft|Round_UpperRight;
}
else {
cr.setHeight(17);
cr.setY(cr.y()-2);
}
}
if(horiz) {
renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn|Is_Horizontal);
renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
}
else {
p->setClipRegion(TQRect(sr.x()+2, sr.y(), sr.width()-4, sr.height()));
renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn);
p->setClipping(false);
renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
}
TQColor color = dynamic_cast<TQWidget*>(p->device()) ? dynamic_cast<TQWidget*>(p->device())->palette().active().buttonText() : cg.buttonText();
p->setPen(color);
drawPrimitive((horiz ? PE_ArrowLeft : PE_ArrowUp), p, ceData, elementFlags, ar, cg, flags);
break;
}
case PE_ScrollBarAddLine: { // bottom / right button
TQRect cr = r;
TQRect ar = r;
TQRect sr = r;
if(horiz) {
sr.setWidth(13);
ar.setX(r.x()-4);
}
else {
sr.setHeight(13);
ar.setY(r.y()-2);
ar.setX(r.x()+1);
}
if(horiz) {
uint contourFlags = Is_ScrollBarBtn|Is_Horizontal|Draw_Top|Draw_Bottom|Draw_Right|Round_UpperRight|Round_BottomRight;
renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn|Is_Horizontal);
renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
}
else {
p->setClipRegion(TQRect(sr.x()+2, sr.y(), sr.width()-4, sr.height()));
renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn);
p->setClipping(false);
uint contourFlags = Is_ScrollBarBtn|Draw_Bottom|Draw_Left|Draw_Right|Round_BottomLeft|Round_BottomRight;
renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
}
TQColor color = dynamic_cast<TQWidget*>(p->device()) ? dynamic_cast<TQWidget*>(p->device())->palette().active().buttonText() : cg.buttonText();
p->setPen(color);
drawPrimitive((horiz ? PE_ArrowRight : PE_ArrowDown), p, ceData, elementFlags, ar, cg, flags);
break;
}
case PE_ScrollBarSubLine2: { // second top / left button // ### remove
uint contourFlags = Is_ScrollBarBtn;
TQRect cr = r;
TQRect ar = r;
TQRect sr = r;
if(horiz) {
contourFlags |= Is_Horizontal|Draw_Top|Draw_Bottom;
}
else {
ar.setX(1);
contourFlags |= Draw_Left|Draw_Right;
}
if(horiz) {
renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn|Is_Horizontal);
renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
}
else {
p->setClipRegion(TQRect(sr.x()+2, sr.y(), sr.width()-4, sr.height()));
renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn);
p->setClipping(false);
renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
}
TQColor color = dynamic_cast<TQWidget*>(p->device()) ? dynamic_cast<TQWidget*>(p->device())->palette().active().buttonText() : cg.buttonText();
p->setPen(color);
drawPrimitive((horiz ? PE_ArrowLeft : PE_ArrowUp), p, ceData, elementFlags, ar, cg, flags);
break;
}
// CHECKBOXES
// ----------
case PE_Indicator: {
break;
}
case PE_IndicatorMask: {
p->fillRect (r.x()+3, r.y()+3, r.width()-6, r.height()-7, color1);
break;
}
// RADIOBUTTONS
// ------------
case PE_ExclusiveIndicator: {
break;
}
case PE_ExclusiveIndicatorMask: {
TQPointArray pa(8);
pa.setPoint(0, 3,6);
pa.setPoint(1, 6,3);
pa.setPoint(2, 10,3);
pa.setPoint(3, 13,6);
pa.setPoint(4, 13,10);
pa.setPoint(5, 10,13);
pa.setPoint(6, 6,13);
pa.setPoint(7, 3,10);
p->setBrush(color1);
p->setPen(color1);
p->drawPolygon(pa);
break;
}
// GENERAL PANELS
// --------------
case PE_Splitter: {
p->fillRect(r, cg.background());
int ch, cs, cv;
cg.background().getHsv(ch, cs, cv);
if(cv < 100)
p->setPen(alphaBlendColors(cg.background(), white, 120));
else
p->setPen(alphaBlendColors(cg.background(), black, 180));
p->setPen(dGetColor(cg.background(), 55));
if (w > h) {
int ycenter = r.height()/2;
for(int k =r.width()/2-5; k < r.width()/2+5; k+=3) {
p->drawRect(k, ycenter-1, 2,2);
}
}
else {
int xcenter = r.width()/2;
for(int k =r.height()/2-5; k < r.height()/2+5; k+=3) {
p->drawRect( xcenter-1, k, 2,2);
}
}
break;
}
case PE_GroupBoxFrame:
case PE_PanelGroupBox: { // TQFrame::GroupBoxPanel
break;
}
case PE_WindowFrame: {
if ( opt.isDefault() || opt.lineWidth() <= 0 )
break;
p->setPen(cg.background().dark(120));
p->drawRect(r);
p->setPen(cg.background().light(110));
p->drawRect(TQRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2));
break;
}
case PE_Panel: { // TQFrame::StyledPanel
if(kickerMode)
break;
p->save();
// inside rect
p->setPen(cg.background().dark(120));
p->drawLine(r.x()+1, r.y()+1, r.right()-1, r.y()+1); //top
p->drawLine(r.x()+1, r.bottom()-1, r.right()-1, r.bottom()-1);
p->drawLine(r.x()+1, r.y()+1, r.x()+1, r.bottom()-1);
p->drawLine(r.right()-1, r.y()+1, r.right()-1, r.bottom()-1);
// outside rect
p->setPen(cg.background());
p->drawLine(r.x(), r.y(), r.right(), r.y()); //top
p->setPen(alphaBlendColors(white, cg.background(), 30));
p->drawLine(r.x(), r.y()+1, r.x(), r.bottom());
p->drawLine(r.right(), r.y()+1, r.right(), r.bottom());
p->setPen(alphaBlendColors(white, cg.background(), 50));
p->drawLine(r.x()+1, r.bottom(), r.right()-1, r.bottom());
p->restore(); // maybe we are a KArrowButton and need to draw the arrow
break;
}
case PE_PanelLineEdit: { // TQFrame::LineEditPanel
break;
}
case PE_PanelTabWidget: { // TQFrame::TabWidgetPanel
// we get a wrong clip rect
p->setClipping(false);
bool roundTopLeft = true;
bool roundTopRight = true;
bool roundBottomLeft = true;
bool roundBottomRight = true;
bool tabsAbove = true;
// p->fillRect(TQRect(r.x()-10, r.y()-10, r.width()+20, r.height()+20), yellow);
TQRect tr;
TQWidget* w = dynamic_cast<TQWidget*>(p->device());
TQTabWidget* tw = w ? dynamic_cast<TQTabWidget*>(w->parentWidget()) : 0;
bool tabBarHidden = tw && !((DominoTQTabWidget*)tw)->tabBar()->isVisible();
if(tw && !tabBarHidden) {
tabsAbove = tw->tabPosition() == TQTabWidget::Top;
if(tw->count() != 0) {
TQTabBar* tb = ((DominoTQTabWidget*)tw)->tabBar();
TQRect gr = tb->geometry();
if(tb->isVisible()) {
tr = tb->tabAt(tw->currentPageIndex())->rect();
tr.setHeight(3);
tr.moveBy(gr.x(), tabsAbove ? 0 : r.height()-2);
}
if(!tw->cornerWidget(TQt::TopLeft) && gr.x() < 7) {
if(tabsAbove)
roundTopLeft = false;
else
roundBottomLeft = false;
}
if(!tw->cornerWidget(TQt::TopRight) && gr.x()+gr.width() > tw->width()-7) {
if(tabsAbove)
roundTopRight = false;
else
roundBottomRight = false;
}
}
}
TQBrush background = tw ? tw->colorGroup().brush(TQColorGroup::Background) : cg.brush(TQColorGroup::Background);
TQColor bottomGradient = alphaBlendColors(TQColor(0,0,0), cg.background(), 11);
TQColor topGradient = alphaBlendColors(TQColor(255,255,255), cg.background(), 15);
TQColor tabContour2 = cg.background().dark(150);
TQString tabPos = tabsAbove ? "1" : "0";
TQPixmap* tabWEdges;
if(!(tabWEdges = TQPixmapCache::find("tabWEdges"+tabPos+TQString::number(background.color().pixel(), 16)+TQString::number(cg.background().pixel(), 16)))) {
tabWEdges = new TQPixmap(16,16);
TQPainter painter(tabWEdges);
painter.fillRect(tabWEdges->rect(), background);
painter.end();
TQPixmap tabWEdgesMask = qembed_findImage("groupBoxMask");
painter.begin(&tabWEdgesMask);
painter.fillRect(tabWEdgesMask.rect(), cg.brush(TQColorGroup::Background));
painter.end();
bitBlt(tabWEdges, 0, 0, &tabWEdgesMask);
TQPixmap circle = qembed_findImage("tabWidget");
bitBlt(tabWEdges, 0, 0, &circle);
TQPixmapCache::insert("tabWEdges"+tabPos+TQString::number(background.color().pixel(), 16)+TQString::number(cg.background().pixel(), 16), tabWEdges);
}
TQRect re = TQRect(r.x(), r.y(), r.width(), r.height()+1);
TQColor bg = cg.background();
TQColor bg2 = background.color(); // parent color
// top
TQColor c1 = alphaBlendColors(TQColor(0,0,0), bg2, 25);
TQColor c2 = alphaBlendColors(TQColor(255,255,255), bg, 70);
TQColor c3 = alphaBlendColors(TQColor(255,255,255), bg, 30);
// left + right
TQColor c4 = alphaBlendColors(TQColor(0,0,0), bg2, 40);
// TQColor c5 = alphaBlendColors(TQColor(255,255,255), bg, 30);
TQColor c6 = alphaBlendColors(TQColor(255,255,255), bg, 4);
// bottom
TQColor c7 = alphaBlendColors(TQColor(249,249,249), bg, 25);
TQColor c8 = alphaBlendColors(TQColor(0,0,0), bg2, 79);
TQColor c9 = alphaBlendColors(TQColor(0,0,0), bg2, 30);
// top
p->setPen(c1);
p->drawLine(re.left(), re.y(), re.right(), re.y());
p->setPen(c2);
p->drawLine(re.left(), re.y()+1, re.right(), re.y()+1);
p->setPen(c3);
p->drawLine(re.left(), re.y()+2, re.right(), re.y()+2);
// bottom
p->setPen(c7);
p->drawLine(re.left()+1, re.bottom()-2, re.right(), re.bottom()-2);
p->setPen(c8);
p->drawLine(re.left()+1, re.bottom()-1, re.right(), re.bottom()-1);
p->setPen(c9);
p->drawLine(re.left(), re.bottom(), re.right(), re.bottom());
// left
p->setPen(c4);
p->drawLine(re.left(), re.y()+1, re.left(), re.bottom()-1);
p->setPen(c3);
p->drawLine(re.left()+1, re.y()+2, re.left()+1, re.bottom()-2);
p->setPen(c6);
p->drawLine(re.left()+2, re.y()+3, re.left()+2, re.bottom()-3);
// right
p->drawLine(re.right()-2, re.y()+3, re.right()-2, re.bottom()-3);
p->setPen(c3);
p->drawLine(re.right()-1, re.y()+2, re.right()-1, re.bottom()-2);
p->setPen(c4);
p->drawLine(re.right(), re.y()+1, re.right(), re.bottom()-1);
// unpainted area
p->setPen(bg);
p->drawLine(re.left()+3, re.y()+3, re.right()-3, re.y()+3);
p->drawLine(re.left()+3, re.bottom()-4, re.right()-3, re.bottom()-4);
p->drawLine(re.left()+3, re.bottom()-3, re.right()-3, re.bottom()-3);
p->drawLine(re.left()+3, re.y()+3, re.left()+3, re.bottom()-4);
p->drawLine(re.right()-3, re.y()+3, re.right()-3, re.bottom()-4);
if(roundTopLeft) {
bitBlt(p->device(), re.x(), re.y(), tabWEdges, 0, 0, 8, 8, TQt::CopyROP);
}
if(roundTopRight) {
bitBlt(p->device(), re.width()-8, re.y(), tabWEdges, 8, 0, 8, 8, TQt::CopyROP);
}
if(roundBottomLeft) {
bitBlt(p->device(), re.x(), re.height()-8, tabWEdges, 0, 8, 8, 8, TQt::CopyROP);
}
if(roundBottomRight) {
bitBlt(p->device(), re.width()-8, re.height()-8, tabWEdges, 8, 8, 8, 8, TQt::CopyROP);
}
// paint over the frame to not disturb the transition from the tabWidget to the current tab
if(tr.isValid()) {
p->fillRect(tr, cg.background()); // ### shrink
if(tabsAbove) {
TQColor p1 = alphaBlendColors(TQColor(255,255,255), bg, 50);
TQColor p2 = alphaBlendColors(TQColor(255,255,255), bg, 25);
TQColor p3 = alphaBlendColors(TQColor(255,255,255), bg, 10);
p->setPen(p1);
p->drawPoint(tr.left(), tr.top()+1);
p->drawPoint(tr.right(), tr.top()+1);
p->setPen(p2);
p->drawPoint(tr.left()+1, tr.top()+1);
p->drawPoint(tr.left(), tr.top()+2);
p->drawPoint(tr.right()-1, tr.top()+1);
p->drawPoint(tr.right(), tr.top()+2);
p->setPen(p3);
p->drawPoint(tr.left()+1, tr.top()+2);
p->drawPoint(tr.right()-1, tr.top()+2);
}
else {
TQColor p1 = alphaBlendColors(TQColor(255,255,255), bg, 17);
TQColor p2 = alphaBlendColors(TQColor(255,255,255), bg, 10);
p->setPen(p1);
p->drawPoint(tr.left(), tr.top());
p->drawPoint(tr.right(), tr.top());
p->setPen(p2);
p->drawPoint(tr.left()+1, tr.top());
p->drawPoint(tr.right()-1, tr.top());
}
}
break;
}
case PE_PanelPopup: { // TQFrame::PopupPanel
TQPopupMenu* pm = dynamic_cast<TQPopupMenu*>(p->device());
TQColor background = dynamic_cast<TQListBox*>(p->device()) ? cg.base() : _customPopupMenuColor ? _popupMenuColor : cg.background();
TQRegion mask(x, y+5, w, h-10);
mask += TQRegion(x+5, y, w-10, h);
mask += TQRegion(x+1, y+2, w-2, h-4);
mask += TQRegion(x+2, y+1, w-4, h-2);
if(_drawPopupMenuGradient) {
TQPixmap buffer(r.width(), r.height());
TQPainter bp(&buffer);
renderGradient(&bp, r, lightenColor(background, 18), darkenColor(background, 12), true);
if(pm) {
pm->setUpdatesEnabled(false);
pm->setPaletteBackgroundPixmap(buffer);
pm->setUpdatesEnabled(true);
}
else {
p->setClipRegion(mask);
p->drawPixmap(r, buffer);
p->setClipping(false);
}
}
else {
if(pm) {
pm->setUpdatesEnabled(false);
pm->setPaletteBackgroundColor(background);
pm->setUpdatesEnabled(true);
}
}
if(pm) {
if(pm->isA("PrettyPopupMenu") || pm->isA("Amarok::Menu") || pm->isA("Digikam::DPopupMenu")) {
// these popups have a side pixmap and are drawing the frame after the contents
TQRect cr = pm->contentsRect();
if(TQApplication::reverseLayout())
pm->erase(mask-TQRegion(cr.width()+3, cr.y(), r.width()-cr.width()-6, cr.height()-1));
else
pm->erase(mask-TQRegion(r.x()+3, cr.y(), r.width()-cr.width()-6, cr.height()-1));
((DominoTQFrame*)pm)->drawContents(p );
}
else
pm->erase(mask);
}
bitBlt(p->device(), r.x(), r.y(), popupFrame, 0, 0, 5, 5, TQt::CopyROP);
bitBlt(p->device(), r.width()-5, r.y(), popupFrame, 5, 0, 5, 5, TQt::CopyROP);
bitBlt(p->device(), r.x(), r.bottom()-4, popupFrame, 0, 5, 5, 5, TQt::CopyROP);
bitBlt(p->device(), r.width()-5, r.bottom()-4, popupFrame, 5, 5, 5, 5, TQt::CopyROP);
p->setPen(background.dark(150));
p->drawLine(r.x()+5, r.y(), r.width()-6, r.y());
p->drawLine(r.x()+5, r.bottom(), r.width()-6, r.bottom());
p->drawLine(r.x(), r.y()+5, r.x(), r.bottom()-5);
p->drawLine(r.width()-1, r.y()+5, r.width()-1, r.bottom()-5);
break;
}
// MENU / TOOLBAR PANEL
// --------------------
case PE_PanelMenuBar: // TQFrame::MenuBarPanel
case PE_PanelDockWindow: { // TQFrame::ToolBarPanel
p->setPen(cg.background());
// overpainting the menus leads to flicker so we draw only the frame here.
if(dynamic_cast<TQWidget*>(p->device()))
p->drawRect(r);
else
p->fillRect(r, cg.brush(TQColorGroup::Background)); // colorpreview in kcontrol
break;
}
case PE_StatusBarSection: {
break;
}
case PE_TabBarBase: {
break;
}
// TOOLBAR/DOCK WINDOW HANDLE
// --------------------------
case PE_DockWindowResizeHandle: {
TQWidget* w = dynamic_cast<TQWidget*>(p->device()); // TQDockWindowResizeHandle
if(w && !w->erasePixmap()) {
TQPixmap pix(r.size());
TQPainter painter(&pix);
renderGradient(&painter, r, lightenColor(cg.background(), 40), darkenColor(cg.background(), 30), horiz);
w->setErasePixmap(pix);
}
break;
}
case PE_DockWindowHandle: {
TQWidget* widget = dynamic_cast<TQWidget*>(p->device()); // qt_dockwidget_internal - TQDockWindowHandle
int ch, cs, cv;
cg.background().getHsv(ch, cs, cv);
if(cv < 100)
p->setPen(alphaBlendColors(cg.background(), white, 120));
else
p->setPen(alphaBlendColors(cg.background(), black, 180));
if(widget && widget == hoverWidget) {
if (w > h) {
int ycenter = r.height()/2;
for(int k = r.width()/2-5; k < r.width()/2+5; k+=3) {
p->drawRect(k, ycenter-1, 2, 2);
}
}
else {
int xcenter = r.width()/2;
for(int k = r.height()/2-5; k < r.height()/2+5; k+=3) {
p->drawRect(xcenter-1, k, 2, 2);
}
}
}
break;
}
// TOOLBAR SEPARATOR
// -----------------
case PE_DockWindowSeparator: {
if(!_toolBtnAsBtn) {
int ch, cs, cv;
cg.background().getHsv(ch, cs, cv);
if(cv < 100)
p->setPen(alphaBlendColors(cg.background(), white, 150));
else
p->setPen(alphaBlendColors(cg.background(), black, 150));
if(horiz) {
int x = r.width()/2;
for(int i = 2; i < r.height()-4; i += 3)
p->drawPoint(x, i);
}
else {
int y = r.height()/2;
for(int i = 2; i < r.width()-4; i += 3)
p->drawPoint(i, y);
}
}
break;
}
case PE_CheckMark: {
if( flags & Style_On ) {
if(flags & Style_Enabled)
p->drawPixmap(r.x()+1, r.y()+1, *checkMark, 0, 0, 16, 17);
else
p->drawPixmap(r.x()+1, r.y()+1, *checkMark, 16, 0, 16, 17);
}
else if ( flags & Style_Off ) {
}
else {// tristate
p->setPen(_customCheckMarkColor ? _checkMarkColor : tqApp->palette().active().foreground());
p->drawLine(6,6,11,6);
p->drawLine(6,8,11,8);
p->drawLine(6,10,11,10);
}
break;
}
case PE_SpinWidgetUp:
case PE_SpinWidgetDown: {
TQPixmap* arrow;
bool isEnabled = (flags & Style_Enabled);
TQString enabled = isEnabled ? "1" : "0";
TQColor color = p->pen().color();
if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"spinArrows"+enabled))) {
TQImage ar = tintImage(qembed_findImage("spinBoxArrows"), color);
if(!isEnabled) { // make it transparent
ar = setImageOpacity(ar, 25);
}
arrow = new TQPixmap(ar);
TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"spinArrows"+enabled, arrow);
}
if(textEffectSettings.mode) {
TQPixmap* effectArrow;
if(!(effectArrow = TQPixmapCache::find(TQString::number(textEffectSettings.buttonColor.pixel(), 16)+"spinEArrows"+enabled))) {
TQImage img = tintImage(qembed_findImage("spinBoxArrows"), textEffectSettings.buttonColor);
int opacity = textEffectSettings.buttonOpacity*100/255;
effectArrow = new TQPixmap(setImageOpacity(img, !isEnabled ? opacity*25/100 : opacity));
TQPixmapCache::insert(TQString::number(textEffectSettings.buttonColor.pixel(), 16)+"spinEArrows"+enabled, effectArrow);
}
bitBlt(p->device(), r.x()+7/2+1+textEffectSettings.buttonPos.x(), r.y()+r.height()/2-3+textEffectSettings.buttonPos.y(), effectArrow, 0, pe == PE_SpinWidgetDown ? 5 : 0, 7, 5);
}
bitBlt(p->device(), r.x()+7/2+1, r.y()+r.height()/2-3, arrow, 0, pe == PE_SpinWidgetDown ? 5 : 0, 7, 5);
break;
}
case PE_HeaderArrow:
case PE_ArrowUp:
case PE_ArrowDown:
case PE_ArrowLeft:
case PE_ArrowRight: {
TQRect re = r;
int x2, w2, h2;
int x = -4;
switch (pe) {
case PE_ArrowUp: {
x2 = 10;
w2 = 7;
h2 = 5;
break;
}
case PE_ArrowDown: {
x2 = 17;
w2 = 7;
h2 = 5;
break;
}
case PE_ArrowLeft: {
x += 1;
x2 = 0;
w2 = 5;
h2 = 7;
break;
}
case PE_ArrowRight: {
x += 2;
x2 = 5;
w2 = 5;
h2 = 7;
break;
}
default: {
if(flags & Style_Up) {
x2 = 10;
w2 = 7;
h2 = 5;
}
else {
x2 = 17;
w2 = 7;
h2 = 5;
}
break;
}
}
TQPixmap* arrow;
bool isEnabled = (flags & Style_Enabled);
TQString enabled = isEnabled ? "1" : "0";
TQColor color = p->pen().color();
if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"scrollBarArrows"+enabled))) {
TQImage ar = tintImage(qembed_findImage("scrollBarArrows"), color);
if(!isEnabled) {
ar = setImageOpacity(ar, 25);
}
arrow = new TQPixmap(ar);
TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"scrollBarArrows"+enabled, arrow);
}
if(/*pe == PE_HeaderArrow &&*/ textEffectSettings.mode) {
TQPixmap* effectArrow;
if(!(effectArrow = TQPixmapCache::find(TQString::number(textEffectSettings.buttonColor.pixel(), 16)+"scrollBarEArrows"+enabled))) {
TQImage img = tintImage(qembed_findImage("scrollBarArrows"), textEffectSettings.buttonColor);
int opacity = textEffectSettings.buttonOpacity*100/255;
effectArrow = new TQPixmap(setImageOpacity(img, !isEnabled ? opacity*25/100 : opacity));
TQPixmapCache::insert(TQString::number(textEffectSettings.buttonColor.pixel(), 16)+"scrollBarEArrows"+enabled, effectArrow);
}
p->drawPixmap(re.x()+re.width()/2+x+textEffectSettings.buttonPos.x(), re.y()+re.height()/2-3+textEffectSettings.buttonPos.y(), *effectArrow, x2, 0, w2, h2);
}
p->drawPixmap(re.x()+re.width()/2+x, re.y()+re.height()/2-3, *arrow, x2, 0, w2, h2);
break;
}
case PE_CheckListIndicator: {
// the rect in not correctly calculated in TQt, so the controller rect is 2px above the drawn rect.
TQCheckListItem *item = opt.checkListItem();
TQListView *lv = item->listView();
if(!item)
return;
TQString state = flags& Style_On ? "1" : "0";
state += flags& Style_Selected ? "1" : "0";
state += flags& Style_NoChange ? "1" : "0";
TQColor background = flags& Style_Selected ? cg.highlight() : cg.base();
TQColor foreground = cg.text();
TQPixmap* pix;
if(!(pix = TQPixmapCache::find(TQString::number(background.pixel(), 16)+TQString::number(foreground.pixel(), 16)+"checkListIndicator"+state))) {
pix = new TQPixmap(r.x()+lv->itemMargin()+r.width()+4, item->height());
pix->fill(background);
TQPainter painter(pix);
painter.setPen(alphaBlendColors(foreground, background, 127));
painter.drawLine(r.x()+1, r.y()+1, r.x()+12, r.y()+1); // t
painter.drawLine(r.x()+1, r.y()+14, r.x()+12, r.y()+14); // b
painter.drawLine(r.x(), r.y()+2, r.x(), r.y()+13); // l
painter.drawLine(r.x()+13, r.y()+2, r.x()+13, r.y()+13); // r
painter.setPen(alphaBlendColors(foreground, background, 80));
painter.drawPoint(r.x(), r.y()+1);
painter.drawPoint(r.x()+13, r.y()+1);
painter.drawPoint(r.x(), r.y()+14);
painter.drawPoint(r.x()+13, r.y()+14);
if(flags& Style_NoChange) {
painter.fillRect(r.x()+1, r.y()+2, 12, 12, dGetColor(background, 30));
painter.drawPixmap(r.x()-1, r.y(), tintImage(qembed_findImage("checkmark"), foreground));
}
if(flags& Style_On)
painter.drawPixmap(r.x()-1, r.y(), tintImage(qembed_findImage("checkmark"), foreground));
TQPixmapCache::insert(TQString::number(background.pixel(), 16)+TQString::number(foreground.pixel(), 16)+"checkListIndicator"+state, pix);
}
p->drawPixmap(0, 0, *pix);
break;
}
case PE_CheckListExclusiveIndicator: {
TQColor background = flags& Style_Selected ? cg.highlight() : cg.base();
p->drawPixmap(r.left()+3, r.top()+1, tintImage(qembed_findImage("checkListExclusiveIndicator"), alphaBlendColors(cg.text(), background, 127)));
if(flags&Style_On)
p->drawPixmap(r.x()+7, r.y()+5, tintImage(qembed_findImage("rb-dot"),cg.text()));
break;
}
case PE_SizeGrip: {
bool parentBgPix = cg.brush(TQColorGroup::Background).pixmap();
TQString trans = parentBgPix ? "1" : "0";
TQPixmap* grip;
if(!(grip = TQPixmapCache::find(TQString::number(cg.background().pixel(), 16)+"sizeGrip"+trans))) {
if(parentBgPix)
grip = new TQPixmap(qembed_findImage("sizeGrip"));
else {
grip = new TQPixmap(4, 4);
grip->fill(cg.background());
TQPixmap tmpPix = qembed_findImage("sizeGrip");
bitBlt(grip, 0, 0, &tmpPix, 0, 0, -1, -1, TQt::CopyROP);
}
TQPixmapCache::insert(TQString::number(cg.background().pixel(), 16)+"sizeGrip"+trans, grip);
}
bitBlt(p->device(), r.width()-(TQApplication::reverseLayout() ? 12 : 6), r.height()-12, grip, 0, 0, -1, -1, TQt::CopyROP);
bitBlt(p->device(), r.width()-6, r.height()-6, grip, 0, 0, -1, -1, TQt::CopyROP);
bitBlt(p->device(), r.width()-12, r.height()-6, grip, 0, 0, -1, -1, TQt::CopyROP);
break;
}
case PE_RubberBand: {
#if TDE_VERSION >= 0x30506
if(rubberBandType != ArgbRubber || !compositeManagerRunning) {
#else
if(rubberBandType != ArgbRubber) {
#endif
if(rubberBandType == LineRubber) {
p->save();
p->setPen(TQPen(black, 1, TQt::SolidLine));
p->drawRect(r);
p->restore();
}
else {
TDEStyle::drawPrimitive(pe, p, ceData, elementFlags, r, cg, flags, opt);
}
break;
}
bool normalized = r.width() < 0 || r.height() < 0;
TQRect re = normalized? r.normalize(): r;
if(re.y() < 0)
re.setY(-3);
if(re.x() < 0)
re.setX(-3);
if(!viewPortPressed || re == oldRubberRect || re.width() == 0 || re.height() == 0) {
break;
}
TQColor fg = alphaBlendColors(_argbRubberBandColor, black, 127);
const TQWidget* w = dynamic_cast<TQWidget*>(p->device());
if(!w)
w = rubberViewPort;
TQPoint po = w->mapToGlobal(TQPoint(0,0));
TQRect gr = TQRect(po.x(), po.y(), w->width(), w->height());
TQRegion mask(re.x()+1, re.y(), re.width()-2, re.height());
mask += TQRegion(re.x(), re.y()+1, re.width(), re.height()-2);
rubber->create(gr, mask);
GC gc2 = XCreateGC(tqt_xdisplay(), rubber->window, 0, 0);
/////// erasing
XRectangle xrect;
XRectangle outline[4];
int num = 0;
if(re.y() < oldRubberRect.y()) {// ^ top
outline[num].x = oldRubberRect.x();
outline[num].y = oldRubberRect.y();
outline[num].width = oldRubberRect.width();
outline[num].height = 1;
num += 1;
}
if(oldRubberRect.y()+oldRubberRect.height() < re.y()+re.height()) {// v bottom
outline[num].x = oldRubberRect.x();
outline[num].y = oldRubberRect.y()+oldRubberRect.height()-1;
outline[num].width = oldRubberRect.width();
outline[num].height = 1;
num += 1;
}
if(re.x() < oldRubberRect.x()) {// < left
outline[num].x = oldRubberRect.x();
outline[num].y = oldRubberRect.y();
outline[num].width = 1;
outline[num].height = oldRubberRect.height()-1;
num += 1;
}
if(oldRubberRect.x()+oldRubberRect.width() < re.x()+re.width()) {// > right
outline[num].x = oldRubberRect.x()+oldRubberRect.width()-1;
outline[num].y = oldRubberRect.y();
outline[num].width = 1;
outline[num].height = oldRubberRect.height()-1;
num += 1;
}
for(int i = 0; i<num; i++)
XClearArea(tqt_xdisplay(), rubber->window, outline[i].x, outline[i].y, outline[i].width, outline[i].height, false);
xrect.x = oldRubberRect.x()+1;
xrect.y = oldRubberRect.y()+1;
xrect.width = 2;
xrect.height = 2;
XClearArea(tqt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
xrect.x = oldRubberRect.x()+1;
xrect.y = oldRubberRect.y()+oldRubberRect.height()-3;
xrect.width = 2;
xrect.height = 2;
XClearArea(tqt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
xrect.x = oldRubberRect.x()+oldRubberRect.width()-3;
xrect.y = oldRubberRect.y()+1;
xrect.width = 2;
xrect.height = 2;
XClearArea(tqt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
xrect.x = oldRubberRect.x()+oldRubberRect.width()-3;
xrect.y = oldRubberRect.y()+oldRubberRect.height()-3;
xrect.width = 2;
xrect.height = 2;
XClearArea(tqt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
rubber->updateMask(mask);
///////////// painting
XSetForeground(tqt_xdisplay(), gc2, preMultiplyColor(tqRgba(fg.red(), fg.green(), fg.blue(),153)));
XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x(), re.y(), re.width()-1, re.height()-1);
// inside
XRectangle xrects[8];
// top left
xrects[0].x = re.x()+2;
xrects[0].y = re.y()+1;
xrects[0].width = 1;
xrects[0].height = 1;
xrects[1].x = re.x()+1;
xrects[1].y = re.y()+2;
xrects[1].width = 1;
xrects[1].height = 1;
// top right
xrects[2].x = re.x()+re.width()-3;
xrects[2].y = re.y()+1;
xrects[2].width = 1;
xrects[2].height = 1;
xrects[3].x = re.x()+re.width()-2;
xrects[3].y = re.y()+2;
xrects[3].width = 1;
xrects[3].height = 1;
// bottom left
xrects[4].x = re.x()+1;
xrects[4].y = re.y()+re.height()-3;
xrects[4].width = 1;
xrects[4].height = 1;
xrects[5].x = re.x()+2;
xrects[5].y = re.y()+re.height()-2;
xrects[5].width = 1;
xrects[5].height = 1;
// bottom right
xrects[6].x = re.x()+re.width()-2;
xrects[6].y = re.y()+re.height()-3;
xrects[6].width = 1;
xrects[6].height = 1;
xrects[7].x = re.x()+re.width()-3;
xrects[7].y = re.y()+re.height()-2;
xrects[7].width = 1;
xrects[7].height = 1;
TQColor blendc = tqRgba(fg.red(), fg.green(), fg.blue(), 36);
XSetForeground(tqt_xdisplay(), gc2, preMultiplyColor(blendColors(_argbRubberBandColor, blendc).rgb()));
XSetClipRectangles(tqt_xdisplay(), gc2, 0, 0, xrects, 8, Unsorted);
XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x()+1, re.y()+1, re.width()-3, re.height()-3);
XRectangle xrects2[8];
// top left
xrects2[0].x = re.x()+2;
xrects2[0].y = re.y();
xrects2[0].width = 1;
xrects2[0].height = 1;
xrects2[1].x = re.x()+1;
xrects2[1].y = re.y()+1;
xrects2[1].width = 1;
xrects2[1].height = 1;
xrects2[2].x = re.x();
xrects2[2].y = re.y()+2;
xrects2[2].width = 1;
xrects2[2].height = 1;
// top right
xrects2[3].x = re.x()+re.width()-3;
xrects2[3].y = re.y();
xrects2[3].width = 1;
xrects2[3].height = 1;
xrects2[4].x = re.x()+re.width()-2;
xrects2[4].y = re.y()+1;
xrects2[4].width = 1;
xrects2[4].height = 1;
xrects2[5].x = re.x()+re.width()-1;
xrects2[5].y = re.y()+2;
xrects2[5].width = 1;
xrects2[5].height = 1;
// bottom left
xrects2[6].x = re.x()+2;
xrects2[6].y = re.y()+re.height()-1;
xrects2[6].width = 1;
xrects2[6].height = 1;
xrects2[7].x = re.x()+1;
xrects2[7].y = re.y()+re.height()-2;
xrects2[7].width = 1;
xrects2[7].height = 1;
xrects2[8].x = re.x();
xrects2[8].y = re.y()+re.height()-3;
xrects2[8].width = 1;
xrects2[8].height = 1;
// bottom right
xrects2[9].x = re.x()+re.width()-3;
xrects2[9].y = re.y()+re.height()-1;
xrects2[9].width = 1;
xrects2[9].height = 1;
xrects2[10].x = re.x()+re.width()-2;
xrects2[10].y = re.y()+re.height()-2;
xrects2[10].width = 1;
xrects2[10].height = 1;
xrects2[11].x = re.x()+re.width()-1;
xrects2[11].y = re.y()+re.height()-3;
xrects2[11].width = 1;
xrects2[11].height = 1;
XSetForeground(tqt_xdisplay(), gc2, preMultiplyColor(tqRgba(fg.red(), fg.green(), fg.blue(), 121)));
XSetClipRectangles(tqt_xdisplay(), gc2, 0, 0, xrects2, 12, Unsorted);
XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x()+1, re.y()+1, re.width()-3, re.height()-3);
XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x(), re.y(), re.width()-1, re.height()-1);
// outermost pixels
XRectangle xrects3[8];
// top left
xrects3[0].x = re.x()+1;
xrects3[0].y = re.y();
xrects3[0].width = 1;
xrects3[0].height = 1;
xrects3[1].x = re.x();
xrects3[1].y = re.y()+1;
xrects3[1].width = 1;
xrects3[1].height = 1;
// top right
xrects3[2].x = re.x()+re.width()-2;
xrects3[2].y = re.y();
xrects3[2].width = 1;
xrects3[2].height = 1;
xrects3[3].x = re.x()+re.width()-1;
xrects3[3].y = re.y()+1;
xrects3[3].width = 1;
xrects3[3].height = 1;
// bottom left
xrects3[4].x = re.x()+1;
xrects3[4].y = re.y()+re.height()-1;
xrects3[4].width = 1;
xrects3[4].height = 1;
xrects3[5].x = re.x();
xrects3[5].y = re.y()+re.height()-2;
xrects3[5].width = 1;
xrects3[5].height = 1;
// bottom right
xrects3[6].x = re.x()+re.width()-2;
xrects3[6].y = re.y()+re.height()-1;
xrects3[6].width = 1;
xrects3[6].height = 1;
xrects3[7].x = re.x()+re.width()-1;
xrects3[7].y = re.y()+re.height()-2;
xrects3[7].width = 1;
xrects3[7].height = 1;
XSetForeground(tqt_xdisplay(), gc2, preMultiplyColor(tqRgba(fg.red(), fg.green(), fg.blue(), 37)));
XSetClipRectangles(tqt_xdisplay(), gc2, 0, 0, xrects3, 8, Unsorted);
XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x(), re.y(), re.width()-1, re.height()-1);
XFlush(tqt_xdisplay());
XFreeGC(tqt_xdisplay(),gc2);
oldRubberRect = re;
break;
}
default: {
return TDEStyle::drawPrimitive(pe, p, ceData, elementFlags, r, cg, flags, opt);
}
}
}
void DominoStyle::drawControl(ControlElement element,
TQPainter *p,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQColorGroup &cg,
SFlags flags,
const TQStyleOption& opt,
const TQWidget *widget) const
{
const bool enabled = (flags & Style_Enabled);
//return TDEStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
switch (element) {
case CE_ToolButtonLabel: {
if(widget->isA("TDEToolBarButton")) {
DominoKToolBarButton* tb= (DominoKToolBarButton *) widget;
TQStyle::SFlags flags = TQStyle::Style_Default;
TQStyle::SCFlags active = TQStyle::SC_None;
if (tb->isDown()) {
flags |= TQStyle::Style_Down;
active |= TQStyle::SC_ToolButton;
}
if (tb->isEnabled()) flags |= TQStyle::Style_Enabled;
if (tb->isOn()) flags |= TQStyle::Style_On;
if (tb->isEnabled() && tb->hasMouse()) flags |= TQStyle::Style_Raised;
if (tb->hasFocus()) flags |= TQStyle::Style_HasFocus;
int dx, dy;
TQFont tmp_font(TDEGlobalSettings::toolBarFont());
TQFontMetrics fm(tmp_font);
TQRect textRect;
int textFlags = 0;
TQPixmap pixmap;
if (tb->iconTextMode() != TDEToolBar::TextOnly) {
pixmap =tb->iconSet().pixmap( TQIconSet::Automatic,
tb->isEnabled() ? (tb->isActive() ? TQIconSet::Active : TQIconSet::Normal) :
TQIconSet::Disabled,
tb->isOn() ? TQIconSet::On : TQIconSet::Off );
TQImage img = pixmap.convertToImage();
if((_toolBtnAsBtn || tb->isToggleButton()) && (tb->isDown() || tb->isOn()))
pixmap = KImageEffect::fade(img, 0.10, black);
else if(tb->isDown() || tb->isOn())
pixmap = KImageEffect::fade(img, 0.15, black);
else if(_highlightToolBtnIcon && tb->hasMouse() && tb->isEnabled())
pixmap = KImageEffect::fade(img, 0.25, white);
}
TQPixmap outlinePixmap = 0;
bool drawOutlinePixmap = false;
if(flags &TQStyle::Style_HasFocus && focusIndicatorSettings.indicateFocus && !pixmap.isNull()) {
outlinePixmap = renderOutlineIcon(&pixmap);
drawOutlinePixmap = true;
}
if (tb->iconTextMode() == TDEToolBar::IconOnly) // icon only
{
if( !pixmap.isNull())
{
dx = ( tb->width() - pixmap.width() ) / 2;
dy = ( tb->height()-1 - pixmap.height() ) / 2;
if(drawOutlinePixmap) {
p->drawPixmap( dx-1, dy-1, outlinePixmap );
}
p->drawPixmap( dx, dy, pixmap );
}
}
else if (tb->iconTextMode() == TDEToolBar::IconTextRight) // icon and text (if any)
{
if( !pixmap.isNull())
{
dx = 4;
dy = ( tb->height()-1 - pixmap.height() ) / 2;
if(drawOutlinePixmap) {
p->drawPixmap( dx-1, dy-1, outlinePixmap );
}
p->drawPixmap( dx, dy, pixmap );
}
if (!tb->textLabel().isNull())
{
textFlags = AlignVCenter|AlignLeft;
if (!pixmap.isNull())
dx = 4 + pixmap.width() + 2;
else
dx = 4;
dy = 0;
textRect = TQRect(dx, dy, tb->width()-dx, tb->height()-1);
}
}
else if (tb->iconTextMode() == TDEToolBar::TextOnly)
{
if (!tb->textLabel().isNull())
{
textFlags = AlignVCenter|AlignLeft;
dx = (tb->width() - fm.width(tb->textLabel())) / 2;
dy = (tb->height()-1 - fm.lineSpacing()) / 2;
textRect = TQRect( dx, dy, fm.width(tb->textLabel()), fm.lineSpacing() );
}
}
else if (tb->iconTextMode() == TDEToolBar::IconTextBottom)
{
if( !pixmap.isNull())
{
dx = (tb->width() - pixmap.width()) / 2;
dy = (tb->height()-1 - fm.lineSpacing() - pixmap.height()) / 2;
if(drawOutlinePixmap) {
p->drawPixmap( dx-1, dy-1, outlinePixmap );
}
p->drawPixmap( dx, dy, pixmap );
}
if (!tb->textLabel().isNull())
{
textFlags = AlignBottom|AlignHCenter;
dx = (tb->width() - fm.width(tb->textLabel())) / 2;
dy = tb->height()-1 - fm.lineSpacing() - 4;
textRect = TQRect( dx, dy, fm.width(tb->textLabel()), fm.lineSpacing() );
}
}
if (!tb->textLabel().isNull() && !textRect.isNull())
{
p->setFont(TDEGlobalSettings::toolBarFont());
TQColor pencolor;
if (!tb->isEnabled())
pencolor = tb->palette().disabled().dark();
// replaced through icon highlights
// else if(tb->isRaised())
// pencolor = TDEGlobalSettings::toolBarHighlightColor();
else
pencolor = tb->colorGroup().buttonText();
dominoDrawItem( p, textRect, textFlags, cg, enabled, 0, tb->textLabel(), -1, &pencolor, textEffectSettings.mode > 0 ? 1 : 0);
}
}
else { // TQToolButton - bye bye win95 iconset mode :)
const TQToolButton *toolbutton = (const TQToolButton *) widget;
TQRect rect = r;
TQt::ArrowType arrowType = opt.isDefault() ? TQt::DownArrow : opt.arrowType();
if (!opt.isDefault()) {
PrimitiveElement pe;
switch (arrowType) {
case TQt::LeftArrow: pe = PE_ArrowLeft; break;
case TQt::RightArrow: pe = PE_ArrowRight; break;
case TQt::UpArrow: pe = PE_ArrowUp; break;
default:
case TQt::DownArrow: pe = PE_ArrowDown; break;
}
drawPrimitive(pe, p, ceData, elementFlags, rect, cg, flags, opt);
}
else {
TQColor btext = toolbutton->paletteForegroundColor();
if (toolbutton->iconSet().isNull() && ! toolbutton->text().isNull() && ! toolbutton->usesTextLabel()) {
int alignment = AlignCenter | ShowPrefix;
if (!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget))
alignment |= NoAccel;
dominoDrawItem( p, rect, alignment, cg, enabled, 0, toolbutton->text(), toolbutton->text().length(), &btext, textEffectSettings.mode > 0 ? 1 : 0);
}
else {
TQPixmap pm;
TQIconSet::Size size = toolbutton->usesBigPixmap() ? TQIconSet::Large : TQIconSet::Small;
TQIconSet::State state = toolbutton->isOn() ? TQIconSet::On : TQIconSet::Off;
TQIconSet::Mode mode;
/* if (!toolbutton->isEnabled())
mode = TQIconSet::Disabled;
else*/ if (flags & (Style_Down | Style_On) || (flags & Style_Raised) && (flags & Style_AutoRaise))
mode = TQIconSet::Active;
else
mode = TQIconSet::Normal;
pm = toolbutton->iconSet().pixmap( size, mode, state );
if(!toolbutton->isEnabled())
pm = disableIcon(&pm);
TQImage img = pm.convertToImage();
if((_toolBtnAsBtn || toolbutton->isToggleButton()) && (toolbutton->isDown() || toolbutton->isOn()))
pm = KImageEffect::fade(img, 0.10, black);
else if(toolbutton->isDown() || toolbutton->isOn())
pm = KImageEffect::fade(img, 0.15, black);
else if(_highlightToolBtnIcon && toolbutton->hasMouse() && toolbutton->isEnabled())
pm = KImageEffect::fade(img, 0.25, white);
TQPixmap outlinePixmap = 0;
bool drawOutlinePixmap = false;
if(flags &TQStyle::Style_HasFocus && focusIndicatorSettings.indicateFocus) {
outlinePixmap = renderOutlineIcon(&pm);
drawOutlinePixmap = true;
}
if ( toolbutton->usesTextLabel() ) {
p->setFont( toolbutton->font() );
TQRect pr = rect, tr = rect;
int alignment = ShowPrefix;
if (!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget))
alignment |= NoAccel;
if ( toolbutton->textPosition() == TQToolButton::Under ) {
int fh = p->fontMetrics().height();
pr.addCoords( 0, 1, 0, -fh-3 );
tr.addCoords( 0, pr.bottom(), 0, -3 );
if(drawOutlinePixmap)
drawItem( p, pr, AlignCenter, cg, TRUE, &outlinePixmap, TQString::null );
drawItem( p, pr, AlignCenter, cg, TRUE, &pm, TQString::null );
alignment |= AlignCenter;
} else {
pr.setWidth( pm.width() + 8 );
tr.addCoords( pr.right(), 0, 0, 0 );
if(drawOutlinePixmap)
drawItem( p, pr, AlignCenter, cg, TRUE, &outlinePixmap, TQString::null );
drawItem( p, pr, AlignCenter, cg, TRUE, &pm, TQString::null );
alignment |= AlignLeft | AlignVCenter;
}
dominoDrawItem( p, tr, alignment, cg, enabled, 0, toolbutton->textLabel(), toolbutton->textLabel().length(), &btext, textEffectSettings.mode > 0 ? 1 : 0);
}
else {
if(drawOutlinePixmap)
drawItem( p, rect, AlignCenter, cg, TRUE, &outlinePixmap, TQString::null );
drawItem( p, rect, AlignCenter, cg, TRUE, &pm, TQString::null );
}
}
}
}
break;
}
// PROGRESSBAR
// -----------
case CE_ProgressBarGroove: {
drawPrimitive(PE_Panel, p, ceData, elementFlags, r, cg, flags, opt);
break;
}
case CE_ProgressBarContents: {
const TQProgressBar *pb = dynamic_cast<const TQProgressBar*>(widget);
int steps = pb->totalSteps();
const TQColor bg = enabled? cg.base(): cg.background(); // background
const TQColor fg = cg.background();
bool reverseLayout = TQApplication::reverseLayout();
TQPixmap* prBgShadow;
int h, s, v, bv;
bg.getHsv(&h, &s, &v);
cg.background().getHsv(&h, &s, &bv);
int diff = KMAX(v-bv, 0);
// if we don't adjust the shadow to the background, it will look strange
TQColor tintColor = alphaBlendColors(TQt::black, bg, diff+30);
if(!(prBgShadow = TQPixmapCache::find(TQString::number(bg.pixel(), 16)+TQString::number(cg.background().pixel(), 16)+"prBgShadow"))) {
prBgShadow = new TQPixmap(4,4);
prBgShadow->fill(bg);
TQPainter painter(prBgShadow);
painter.drawPixmap(0, 0, tintImage(qembed_findImage("progressShadow2"), tintColor));
TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.background().pixel(), 16)+"prBgShadow", prBgShadow);
}
TQRect surface;
TQRect rightBg;
TQRect leftBg;
p->setClipRegion(r);
if( steps == 0 ) { // Busy indicator
static const int barWidth = 10;
int progress = pb->progress() % (2*(r.width()-barWidth));
if( progress < 0)
progress = 0;
if( progress > r.width()-barWidth )
progress = (r.width()-barWidth)-(progress-(r.width()-barWidth));
surface = TQRect(reverseLayout? r.right()-progress+1: r.x()+progress+1, r.top(), barWidth-2, r.height());
rightBg = reverseLayout ? TQRect(r.x(), r.y(), r.width()-(progress-1), r.height()) :
TQRect(r.x()+progress+barWidth-1, r.y(), r.width()-(progress+barWidth-1), r.height());
if(rightBg.width()+surface.width() < r.width()) {
leftBg = reverseLayout ? TQRect(rightBg.width()+surface.width(), r.y(), r.width()-(rightBg.width()+surface.width()-2), r.height()) :
TQRect(r.x(), r.y(), r.x()+progress+1, r.height());
}
}
else {
double percent = static_cast<double>(pb->progress()) / static_cast<double>(steps);
int w = static_cast<int>(r.width() * percent);
if(w < 0)
w = 0;
int w2 = r.width()-(r.width()-w);
rightBg = TQRect(reverseLayout? r.left(): r.left()+w, r.top(), r.width()-w, r.height());
surface = TQRect(reverseLayout? r.right()-w2+1: r.left(), r.top(), w2, r.height());
}
TQPixmap* surfaceTile;
if(!(surfaceTile = TQPixmapCache::find("prTile"+TQString::number(surface.height())+TQString::number(bg.pixel(), 16)))) {
surfaceTile = new TQPixmap(20, surface.height());
TQPainter tilePainter(surfaceTile);
flatMode=true;
renderSurface(&tilePainter, TQRect(0, 0, 20, surface.height()), fg, cg.background(), fg , Is_Button|Is_Horizontal);
flatMode=false;
TQPixmap pix = qembed_findImage("progressTile");
tilePainter.drawTiledPixmap(0,0, 20, surface.height(), pix);
TQPixmapCache::insert("prTile"+TQString::number(surface.height())+TQString::number(bg.pixel(), 16), surfaceTile);
}
int staticShift = 0;
int animShift = 0;
// find the animation Offset for the current Widget
TQWidget* nonConstWidget = const_cast<TQWidget*>(widget);
TQMapConstIterator<TQWidget*, int> iter = progAnimWidgets.find(nonConstWidget);
if (iter != progAnimWidgets.end())
animShift = iter.data();
int counter = 0;
while(counter < (surface.width()+20)) {
counter += 20;
if (reverseLayout) {
p->drawPixmap(surface.right()-counter+animShift+staticShift+1, r.top(), *surfaceTile);
}
else {
p->drawPixmap(surface.left()+counter-20-animShift+staticShift, r.top(), *surfaceTile);
}
}
// empty area
TQColor color_d = alphaBlendColors(tintColor, bg, 170);
TQColor color_m = alphaBlendColors(tintColor, bg, 85);
TQColor color_l = alphaBlendColors(tintColor, bg, 25);
if(leftBg.isValid()) {
p->setClipRegion(leftBg);
p->fillRect(leftBg, bg);
p->setPen(color_d);
p->drawLine(leftBg.x()+2, leftBg.y(), leftBg.right()-2, leftBg.y());
p->setPen(color_m);
p->drawLine(leftBg.x()+2, leftBg.y()+1, leftBg.right()-2, leftBg.y()+1);
p->setPen(color_l);
p->drawLine(leftBg.x()+2, leftBg.y()+2, leftBg.right()-2, leftBg.y()+2);
p->drawLine(leftBg.x()+2, leftBg.bottom(), leftBg.right()-2, leftBg.bottom());
//p->setPen(color_l);
p->drawLine(leftBg.x()+1, leftBg.y()+3, leftBg.x()+1, leftBg.bottom()-1); // l
p->drawLine(leftBg.right()-1, leftBg.y()+3, leftBg.right()-1, leftBg.bottom()-1); // r
p->setPen(color_m);
p->drawLine(leftBg.x(), leftBg.y()+3, leftBg.x(), leftBg.bottom()-1); // l
p->drawLine(leftBg.right(), leftBg.y()+3, leftBg.right(), leftBg.bottom()-1); // r
p->drawPixmap(leftBg.right()-1, leftBg.y(), *prBgShadow, 2, 0, 2, 3); // tr
p->drawPixmap(leftBg.x(), leftBg.y(), *prBgShadow, 0, 0, 2, 3);
p->drawPixmap(leftBg.right()-1, leftBg.bottom(), *prBgShadow, 2, 3, 2, 1); // br
p->drawPixmap(leftBg.x(), leftBg.bottom(), *prBgShadow, 0, 3, 2, 1);
}
p->setClipRegion(rightBg);
p->fillRect(rightBg, bg);
p->setPen(color_d);
p->drawLine(rightBg.x()+2, rightBg.y(), rightBg.right()-2, rightBg.y());
p->setPen(color_m);
p->drawLine(rightBg.x()+2, rightBg.y()+1, rightBg.right()-2, rightBg.y()+1);
p->setPen(color_l);
p->drawLine(rightBg.x()+2, rightBg.y()+2, rightBg.right()-2, rightBg.y()+2);
p->drawLine(rightBg.x()+2, rightBg.bottom(), rightBg.right()-2, rightBg.bottom());
//p->setPen(color_l);
p->drawLine(rightBg.x()+1, rightBg.y()+3, rightBg.x()+1, rightBg.bottom()-1); // l
p->drawLine(rightBg.right()-1, rightBg.y()+3, rightBg.right()-1, rightBg.bottom()-1); // r
p->setPen(color_m);
p->drawLine(rightBg.x(), rightBg.y()+3, rightBg.x(), rightBg.bottom()-1); // l
p->drawLine(rightBg.right(), rightBg.y()+3, rightBg.right(), rightBg.bottom()-1); // r
p->drawPixmap(rightBg.right()-1, rightBg.y(), *prBgShadow, 2, 0, 2, 3); // tr
p->drawPixmap(rightBg.x(), rightBg.y(), *prBgShadow, 0, 0, 2, 3);
p->drawPixmap(rightBg.right()-1, rightBg.bottom(), *prBgShadow, 2, 3, 2, 1); // br
p->drawPixmap(rightBg.x(), rightBg.bottom(), *prBgShadow, 0, 3, 2, 1);
if(rightBg.width() == 2) { // must overpaint two lighter pixel
p->drawPixmap(rightBg.right(), rightBg.y()+2, *prBgShadow, 0, 3, 1, 1); // br
p->drawPixmap(rightBg.right(), rightBg.bottom(), *prBgShadow, 0, 3, 1, 1); // br
}
p->setClipping(false);
break;
}
case CE_ProgressBarLabel: {
const TQProgressBar *progressbar = (const TQProgressBar *) widget;
TQFont font = p->font();
font.setBold(false);
p->setFont(font);
p->setPen(cg.buttonText());
//p->drawText(r, AlignCenter | SingleLine, progressbar->progressString());
dominoDrawItem( p, r, AlignCenter | SingleLine, cg, false, 0, progressbar->progressString(), -1,&cg.buttonText(), false);
break;
}
case CE_CheckBox: {
TQColorGroup g = cg;
if(!tdehtmlWidgets.contains(widget))
g.setColor(TQColorGroup::Button, tqApp->palette().active().background());
TQPixmap insidePix = qembed_findImage("checkbox2inside");
TQPainter painter(&insidePix);
renderSurface(&painter, TQRect(3, 0, 14, 19), g.background(), g.button(), g.button(), Is_CheckItem);
painter.end();
TQImage inside = insidePix.convertToImage();
TQImage checkbox;
TQImage shadow = qembed_findImage("checkbox2shadow");
TQImage circle = tintImage(qembed_findImage("checkbox2rect"), buttonContour->contourColor(Contour_Default));
blend(shadow, inside, checkbox);
blend(circle, checkbox, checkbox);
if(flags&Style_Down) {
TQImage pressed = tintImage(qembed_findImage("checkbox2pressed"), buttonContour->contourColor(Contour_Pressed));
blend(pressed, checkbox, checkbox);
}
TQPixmap pix = TQPixmap(checkbox);
if(flags&Style_On || flags&Style_NoChange) {
painter.begin(&pix);
drawPrimitive(PE_CheckMark, &painter, ceData, elementFlags, r, cg, flags);
painter.end();
}
p->drawPixmap(r.left(), r.top(), pix);
break;
}
case CE_CheckBoxLabel: {
const TQCheckBox *cb = (const TQCheckBox *) widget;
int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
if (!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget))
alignment |= NoAccel;
TQRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_CheckBoxFocusRect, ceData, elementFlags, cb) : r;
if (flags& Style_HasFocus && focusIndicatorSettings.indicateFocus)
drawFocusIndicator(p, re, alignment | AlignVCenter |ShowPrefix, cg, flags & Style_Enabled, cb->pixmap(), cb->text(), -1, focusIndicatorSettings.color, focusIndicatorSettings.drawUnderline);
drawItem(p, r, alignment | AlignVCenter | ShowPrefix, cg,
flags & Style_Enabled, cb->pixmap(), cb->text());
break;
}
// RADIOBUTTONS
// ------------
case CE_RadioButton: {
TQColorGroup g = cg;
if(!tdehtmlWidgets.contains(widget))
g.setColor(TQColorGroup::Button, tqApp->palette().active().background());
TQString down = flags& Style_Down ? "1" : "0";
TQPixmap* radio;
if((flags & Domino_noCache) || !(radio = TQPixmapCache::find("tabEdges"+down))) {
TQImage radioImg;
TQPixmap insidePix = qembed_findImage("radio3inside");
TQPainter painter(&insidePix);
renderSurface(&painter, TQRect(r.left(), r.top(), r.width(), r.height()+1), g.background(), g.button(), g.background(), Is_CheckItem);
TQImage inside = insidePix.convertToImage();
TQImage shadow = qembed_findImage("radio3shadow");
TQImage circle = tintImage(qembed_findImage("radio3circle"), buttonContour->contourColor(Contour_Default));
blend(shadow, inside, inside);
blend(circle, inside, radioImg);
if(flags&Style_Down) {
TQImage pressed = tintImage(qembed_findImage("radio3pressed"), buttonContour->contourColor(Contour_Default));
blend(pressed, radioImg, radioImg);
}
radio = new TQPixmap(radioImg);
if(!(flags & Domino_noCache))
TQPixmapCache::insert("radio"+down, radio);
}
if(flags & Style_On) {
if(flags & Style_Enabled)
bitBlt(radio, 6, 6, radioIndicator, 0, 0, 5, 5);
else
bitBlt(radio, 6, 6, radioIndicator, 5, 0, 5, 5);
}
bitBlt(p->device(), r.x(), r.y(), radio);
break;
}
case CE_RadioButtonLabel: {
const TQRadioButton *radiobutton = (const TQRadioButton *) widget;
int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
if (!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget))
alignment |= NoAccel;
TQRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_RadioButtonFocusRect, ceData, elementFlags, radiobutton) : r;
if (flags& Style_HasFocus && focusIndicatorSettings.indicateFocus)
drawFocusIndicator(p, re, alignment | AlignVCenter |ShowPrefix, cg, flags & Style_Enabled, radiobutton->pixmap(), radiobutton->text(), -1, focusIndicatorSettings.color, focusIndicatorSettings.drawUnderline);
drawItem(p, r, alignment | AlignVCenter | ShowPrefix, cg,
flags & Style_Enabled, radiobutton->pixmap(), radiobutton->text());
break;
}
// TABS
// ----
case CE_TabBarTab: {
TQTabBar * tb = (TQTabBar *) widget;
bool konqTab = false;
bool kickoffTab = false;
if(tb->parentWidget()) {
const TQWidget* w = tb->parentWidget();
if(w->isA("KonqFrameTabs"))
konqTab = true;
else if(!strcmp(w->name(), "SUSE::Kickoff::KMenu"))
kickoffTab = true;
}
TQTabBar::Shape tbs = tb->shape();
bool selected = false;
bool reverseLayout = TQApplication::reverseLayout();
if (flags & Style_Selected) selected = true;
TabPosition pos;
if (tb->count() == 1) {
pos = Single;
} else if ((tb->indexOf(opt.tab()->identifier()) == 0)) {
pos = reverseLayout?Last:First;
} else if (tb->indexOf(opt.tab()->identifier()) == tb->count() - 1) {
pos = reverseLayout?First:Last;
} else {
pos = Middle;
}
switch (tbs) {
case TQTabBar::TriangularAbove:
renderTab(p, r, cg, (flags & Style_MouseOver), selected, false, pos, true, false, konqTab);
break;
case TQTabBar::RoundedAbove:
renderTab(p, r, cg, (flags & Style_MouseOver), selected, false, pos, false, false, konqTab);
break;
case TQTabBar::TriangularBelow:
renderTab(p, r, cg, (flags & Style_MouseOver), selected, true, pos, true, false, konqTab);
break;
case TQTabBar::RoundedBelow:
renderTab(p, r, cg, (flags & Style_MouseOver), selected, true, pos, false, false, konqTab);
break;
default:
TDEStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
}
// TQt3 uses this painter to draw the iconSet between CE_TabBarTab and CE_TabBarLabel. If we clip the painter here
// we will have a clean area to draw the icon at the right position in CE_TabBarLabel.
if(!kickoffTab)
p->setClipRect(TQRect());
break;
}
case CE_PushButton: {
TQPushButton *button = (TQPushButton *)widget;
bool tdehtmlMode = tdehtmlWidgets.contains(button);
bool isDefault = enabled && button->isDefault();
bool isHoverWidget = enabled && button == hoverWidget;
bool isSunken = flags & Style_On || flags & Style_Down;
uint contourFlags = Draw_Left|Draw_Right|Draw_Top|Draw_Bottom;
uint surfaceFlags = Is_Button|Is_Horizontal;
flatMode = button->isFlat();
TQColor bg;
if(!tdehtmlMode && !button->paletteBackgroundPixmap()) {
if(dynamic_cast<TQGroupBox*>(button->parentWidget())) {
bg = button->parentWidget()->paletteBackgroundColor();
}
else {
bg = cg.background();
}
p->fillRect(TQRect(r.x(), r.y(), 6, 6), bg);
p->fillRect(TQRect(r.width()-6, r.y(), 6, 6), bg);
p->fillRect(TQRect(r.width()-6, r.height()-7, 6,7), bg);
p->fillRect(TQRect(r.x(), r.height()-7, 6, 7), bg);
}
else {
buttonContour->setAlphaMode();
contourFlags|=Draw_AlphaBlend;
}
if(tdehtmlMode) contourFlags|=Draw_AlphaBlend;
if(!enabled) {
contourFlags|=Is_Disabled;
surfaceFlags|=Is_Disabled;
}
if(isSunken) {
surfaceFlags|=Is_Down;
contourFlags|=Is_Down;
}
if(button->isDown())
buttonContour->setState(Contour_Pressed);
else if(isHoverWidget)
buttonContour->setState(Contour_MouseOver);
else if(isDefault)
buttonContour->setState(Contour_DefaultButton);
if(!flatMode) {
renderSurface(p, TQRect(r.x()+2, r.y()+2, r.width()-4, r.height()-5), cg.background(), cg.button(), cg.button(), surfaceFlags);
contourFlags |= Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight|Is_Button|Is_Horizontal;
renderContour(p, r, bg, cg.button(), contourFlags);
if(isSunken) {
renderButtonShadow(p, TQRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3), contourFlags);
}
}
else {
renderSurface(p, TQRect(r.x()-3, r.y()-1, r.width()+6, r.height()+2), cg.background(), cg.button(), cg.button(), surfaceFlags);
TQColor contourColor = alphaBlendColors(buttonContour->contourColor(buttonContour->state), cg.background(), 179);
p->setPen(contourColor);
if(dynamic_cast<KMultiTabBarTab*>(button)) {
const TQWidget* parent = button->parentWidget();
bool horizontal = parent->width() >= parent->height();
KMultiTabBar* tabBar = static_cast<KMultiTabBar*>(widget->parentWidget()->parentWidget()->parentWidget()->parentWidget());
KMultiTabBarTab* tab;
TQPtrList<KMultiTabBarTab>* list = tabBar->tabs();
for(tab = list->first(); tab; tab = list->next()) {
if(horizontal && tab->x()+tab->width() == widget->x())
break;
else if(tab->y()+tab->height() == widget->y())
break;
}
if(tab) {
TQPainter painter(tab);
painter.setPen(contourColor);
TQRect re = tab->rect();
if(horizontal)
painter.drawLine(re.right(), re.y(), re.right(), re.bottom()); // right lines
else
painter.drawLine(re.x(), re.bottom(), re.right(), re.bottom());
}
if(horizontal) {
if(button->x() == parent->x())
p->drawLine(r.x(), r.y(), r.x(), r.bottom()); // first left line
p->drawLine(r.right(), r.y(), r.right(), r.bottom()); // right lines
}
else {
if(button->y() == parent->y())
p->drawLine(r.right(), r.y(), r.right(), r.bottom());
p->drawLine(r.x(), r.y(), r.x(), r.bottom());
}
// middle lines
p->drawLine(r.x(), r.y(), r.right(), r.y());
p->drawLine(r.x(), r.bottom(), r.right(), r.bottom());
// if(isSunken) {
// contourFlags = Draw_Top|Draw_Left|Draw_Right|Draw_Bottom|Rectangular_UpperLeft|Rectangular_UpperRight|Rectangular_BottomLeft|Rectangular_BottomRight;
// renderButtonShadow(p, TQRect(r.x()-1, r.y()-1, r.width()+5, r.height()+2), contourFlags);
// renderButtonShadow(p, re), contourFlags);
// }
}
else {
p->drawRect(r);
}
flatMode = false;
}
buttonContour->reset();
break;
}
case CE_PushButtonLabel:
{
int x, y, w, h;
r.rect( &x, &y, &w, &h );
const TQPushButton* button = static_cast<const TQPushButton *>( widget );
bool cornArrow = false;
bool hasFocus = button->hasFocus();
p->setPen(button->colorGroup().buttonText());
// Does the button have a popup menu?
if ( button->popup() )
{
int dx = pixelMetric( PM_MenuButtonIndicator, ceData, elementFlags, widget );
if ( button->iconSet() && !button->iconSet()->isNull() &&
(dx + button->iconSet()->pixmap (TQIconSet::Small, TQIconSet::Normal, TQIconSet::Off ).width()) >= w )
{
cornArrow = true; //To little room. Draw the arrow in the corner, don't adjust the widget
}
else
{
drawPrimitive( PE_ArrowDown, p, ceData, elementFlags, visualRect( TQRect(x + w - dx - 8, y + 3, dx, h - 3), r ), cg, flags, opt );
w -= dx;
}
}
// Draw the icon if there is one
if ( button->iconSet() && !button->iconSet()->isNull() )
{
TQIconSet::Mode mode = TQIconSet::Disabled;
TQIconSet::State state = TQIconSet::Off;
if (button->isEnabled())
mode = button->hasFocus() ? TQIconSet::Active : TQIconSet::Normal;
if (button->isToggleButton() && button->isOn())
state = TQIconSet::On;
TQPixmap pixmap = button->iconSet()->pixmap( TQIconSet::Small, mode, state );
bool focusIcon = hasFocus && focusIndicatorSettings.indicateFocus && !focusIndicatorSettings.drawUnderline;
int pw = pixmap.width();
if(button->text().isEmpty()) {
int bpw = button->pixmap() ? button->pixmap()->width() : 0;
if(focusIcon) {
TQPixmap outlinePixmap = renderOutlineIcon(&pixmap);
p->drawPixmap( x + (w - bpw -outlinePixmap.width())/2, y + (h - outlinePixmap.height())/ 2, outlinePixmap );
}
p->drawPixmap( x + (w - bpw - pw)/2, y + (h- pixmap.height()) / 2, pixmap );
}
else {
int cw = p->fontMetrics().size(TQt::ShowPrefix, button->text()).width()+pw;
if(focusIcon) {
TQPixmap outlinePixmap = renderOutlineIcon(&pixmap);
p->drawPixmap( x + (w - cw)/2 - 1 , y + (h - outlinePixmap.height())/ 2, outlinePixmap );
}
p->drawPixmap( x + (w - cw)/2 , y + (h - pixmap.height())/ 2, pixmap );
}
if (cornArrow) //Draw over the icon
drawPrimitive( PE_ArrowDown, p, ceData, elementFlags, visualRect( TQRect(x + w - 6, x + h - 6, 7, 7), r ), cg, flags, opt );
x += pw + 4;
w -= pw + 4;
}
TQRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_PushButtonFocusRect, ceData, elementFlags, button) : TQRect(x, y, w, h);
if(hasFocus && focusIndicatorSettings.indicateFocus && !button->text().isNull())
drawFocusIndicator(p, re, AlignCenter|ShowPrefix, cg, button->isEnabled(), 0, button->text(), -1, focusIndicatorSettings.buttonColor, focusIndicatorSettings.drawUnderline, true);
TQPixmap buttonPixmap;
if(button->pixmap()) {
if(!enabled)
buttonPixmap = disableIcon(button->pixmap());
else
buttonPixmap = *button->pixmap();
}
dominoDrawItem( p, TQRect(x, y, w, h), AlignCenter|ShowPrefix, button->colorGroup(),
enabled, button->pixmap() ? &buttonPixmap : 0, button->text(), -1, &button->colorGroup().buttonText(), textEffectSettings.mode > 0 ? 1 : 0 );
break;
}
case CE_TabBarLabel: {
p->setClipping(false); // was set in CE_TabBarTab to clip the icon drawing
if ( opt.isDefault() )
break;
const TQTabBar * tb = (const TQTabBar *) widget;
TQTab * t = opt.tab();
bool konqTab = false;
bool kickoffTab = false;
int shift, cshift;
switch (tb->shape()) {
case TQTabBar::RoundedAbove:
shift = 4;
cshift = 3;
break;
case TQTabBar::RoundedBelow:
if((konqTab = tb->parentWidget() && tb->parentWidget()->isA("KonqFrameTabs")) ||
(kickoffTab = tb->parentWidget() && !strcmp(tb->parentWidget()->name(), "SUSE::Kickoff::KMenu"))) {
shift = 0;
cshift = 0;
}
else {
shift = -3;
cshift = -1;
}
break;
case TQTabBar::TriangularAbove:
shift = 4;
cshift = 3;
break;
case TQTabBar::TriangularBelow:
shift = -5;
cshift = -3;
break;
default:
shift = 0;
cshift = 0;
}
TQRect tr = r;
bool currentTab = t->identifier() == tb->currentTab();
if (!currentTab)
tr.setTop( tr.top() +shift );
else
tr.setTop( tr.top() +cshift );
int alignment = AlignCenter | ShowPrefix;
if (flags& Style_HasFocus && focusIndicatorSettings.indicateFocus && !t->text().isEmpty())
drawFocusIndicator(p, TQRect(tr.x(), tr.y(), tr.width(), tr.height()), alignment, cg, flags & Style_Enabled, 0, t->text(), -1, focusIndicatorSettings.buttonColor, focusIndicatorSettings.drawUnderline, true);
if(t->iconSet() && !tb->isA("KickoffTabBar")) {
bool enabled = t->isEnabled() && tb->isEnabled();
TQPixmap pixmap;
if(!TDEApplicationMode) {
TQIconSet::Mode mode = (t->identifier() && tb->keyboardFocusTab()) ? TQIconSet::Active : TQIconSet::Normal;
pixmap = t->iconSet()->pixmap( TQIconSet::Small, mode );
if(!enabled)
pixmap = disableIcon(&pixmap);
}
else {
TQIconSet::Mode mode = enabled ? TQIconSet::Normal : TQIconSet::Disabled;
if ( mode == TQIconSet::Normal && (t->identifier() && tb->keyboardFocusTab()) )
mode = TQIconSet::Active;
pixmap = t->iconSet()->pixmap( TQIconSet::Small, mode );
}
int pixw = pixmap.width();
int pixh = pixmap.height();
TQRect ir = r;
ir.setLeft( tr.left() - pixw - 4 );
ir.setRight( tr.right() - 2 );
int yoff = 0;
if(!currentTab) {
yoff = pixelMetric(TQStyle::PM_TabBarTabShiftVertical, ceData, elementFlags, tb);
}
switch(tb->shape()) {
case TQTabBar::RoundedAbove:
case TQTabBar::TriangularAbove:
ir.setHeight(ir.height()+4);
break;
default:
if(!konqTab)
ir.setHeight(ir.height()-2);
}
p->drawPixmap( ir.left() + 2, ir.center().y()-pixh/2+ yoff, pixmap );
}
TQColor textColor = cg.foreground();
if(konqTab)
textColor = cg.foreground() != tb->palette().active().foreground() ? cg.foreground() : tb->palette().active().foreground();
else if(konsoleMode)
textColor = tb->palette().active().foreground();
dominoDrawItem( p, tr, alignment, cg, flags & Style_Enabled, 0, t->text(), -1, &textColor/*&cg.foreground()*/, textEffectSettings.mode > 0 ? 1 : 0);
break;
}
case CE_MenuBarItem: {
bool active = flags & Style_Active;
bool focused = flags & Style_HasFocus;
bool down = flags & Style_Down;
if (active && focused) {
if(!macStyleBar)
p->fillRect(r, cg.background()); // gtk-qt engine fix
TQColor c = down ? dGetColor(cg.background(), 15) : dGetColor(cg.background(), 25);
p->fillRect(TQRect(r.left()+3,r.y()+1, r.width()-7, r.height()), c);
p->fillRect(TQRect(r.left(),r.top()+4, 3, r.height()-7), c);
p->fillRect(TQRect(r.right()-3, r.y()+4, 3, r.height()-7), c);
TQPixmap pix = tintImage(qembed_findImage("menuItem"), c);
p->drawPixmap(r.left(),r.y()+1, pix, 0, 0, 3, 3);
p->drawPixmap(r.left(),r.bottom()-2, pix, 0, 3, 3, 3);
p->drawPixmap(r.right()-3,r.y()+1, pix, 3, 0, 3, 3);
p->drawPixmap(r.right()-3,r.bottom()-2, pix, 3, 3, 3, 3);
}
p->setPen(cg.foreground() );
drawItem(p, r, AlignVCenter | AlignHCenter | ShowPrefix | DontClip | SingleLine, cg, true, 0,
opt.menuItem()->text(), -1, &cg.foreground() );
break;
}
// POPUPMENU ITEM (highlighted on mouseover)
// ------------------------------------------
case CE_PopupMenuItem: {
const TQPopupMenu *popupmenu = static_cast< const TQPopupMenu * >( widget );
TQMenuItem *mi = opt.menuItem();
if ( !mi )
break;
bool checked = popupmenu->isCheckable() && mi->isChecked();
int tab = opt.tabWidth();
int maxpmw = mi->iconSet() || _indentPopupMenuItems ? opt.maxIconWidth() : 0;
int cmwidth = _indentPopupMenuItems ? maxpmw ? 0 : 12 : 16; // checkmark, visible 10
if(!_indentPopupMenuItems && checked)
maxpmw += cmwidth-1;
bool enabled = mi->isEnabled();
bool active = flags & Style_Active;
bool reverse = TQApplication::reverseLayout();
bool separator = mi->isSeparator();
TQColor color;
if(separator || (active && enabled)) {
color = separator ? dGetColor(_popupMenuColor, 20) : _selMenuItemColor;
float val = 0;
int ph = popupmenu->rect().height()/2;
int part = separator ? TQMAX(1, ph/r.y()+r.height()) : TQMAX(1, ph/r.height());
if(_drawPopupMenuGradient) {
if(r.y()+r.height()/2 < ph) {
for( int i=r.y(); i < ph; i += part) {
val += 0.5;
}
color = lightenColor(color, (int)val);
}
else {
for( int i=0; i < r.y()-ph; i += part) {
val += 0.5;
}
color = darkenColor(color, (int)val);
}
}
}
// Draw the menu item background
if (active) {
if (enabled) {
TQColor c = color;
p->fillRect(TQRect(r.x()+3, r.y(), r.width()-6, r.height()), c);
p->fillRect(TQRect(r.x(), r.y()+3, 3, r.height()-6), c);
p->fillRect(TQRect(r.x()+r.width()-3, r.y()+3, 3, r.height()-6), c);
TQPixmap pix = tintImage(qembed_findImage("menuItem"), c);
bitBlt(p->device(), r.x(), r.y(), &pix, 0, 0, 3, 3, TQt::CopyROP);
bitBlt(p->device(), r.x(), r.bottom()-2, &pix, 0, 3, 3, 3, TQt::CopyROP);
bitBlt(p->device(), r.x()+r.width()-3, r.y(), &pix, 3, 0, 3, 3, TQt::CopyROP);
bitBlt(p->device(), r.x()+r.width()-3, r.bottom()-2, &pix, 3, 3, 3, 3, TQt::CopyROP);
}
}
// Are we a menu item separator?
if(separator) {
p->setPen(color);
p->drawLine(r.x(), r.y()+2, r.right(), r.y()+2);
break;
}
if(checked) {
// We only have to draw the background if the menu item is inactive -
// if it's active the "pressed" background is already drawn
TQRect cmr = visualRect( TQRect( r.x()+itemFrame , r.y() + 1, TQMIN(TQMAX(maxpmw, cmwidth), r.height() - 2), r.height() - 2 ), r );
// Draw the checkmark
SFlags cflags = Style_On;
if (enabled)
cflags |= Style_Enabled;
if(reverse && _indentPopupMenuItems)
drawPrimitive( PE_CheckMark, p, ceData, elementFlags, TQRect(cmr.x() + (maxpmw ? (maxpmw-16)/2-4 : -1), cmr.y(), cmr.width(), cmr.height()), cg, cflags );
else if(_indentPopupMenuItems)
drawPrimitive( PE_CheckMark, p, ceData, elementFlags, TQRect(cmr.x() + (maxpmw ? (maxpmw-16)/2-3 : -6), cmr.y(), cmr.width(), cmr.height()), cg, cflags );
else
drawPrimitive( PE_CheckMark, p, ceData, elementFlags, TQRect(reverse ? cmr.x()+cmr.width()-15 : cmr.x()-3, cmr.y(), cmr.width(), cmr.height()), cg, cflags );
}
if(!(_indentPopupMenuItems && checked) && mi->iconSet()) {
TQRect cr = visualRect( TQRect( (reverse ? r.x()-2 : r.x()) + itemFrame, r.y() + 1, maxpmw -1 , r.height() - 2 ), r );
TQIconSet::Mode mode;
// Select the correct icon from the iconset
TQPixmap pixmap;
if(TDEApplicationMode) {
if (active)
mode = enabled ? TQIconSet::Active : TQIconSet::Disabled;
else
mode = enabled ? TQIconSet::Normal : TQIconSet::Disabled;
pixmap = mi->iconSet()->pixmap(TQIconSet::Small, mode);
}
else {
pixmap = mi->iconSet()->pixmap(TQIconSet::Small, active ? TQIconSet::Active : TQIconSet::Normal);
if(!enabled)
pixmap = disableIcon(&pixmap);
}
if(checked && !reverse)
cr.setX(cr.x()+cmwidth);
p->drawPixmap( cr.x(), cr.y(), pixmap );
}
// Time to draw the menu item label...
int xm = itemFrame + maxpmw; // X position margin
if(_indentPopupMenuItems)
xm += cmwidth;
int xp = reverse ? // X position
r.x() + tab+ itemFrame*2 + itemHMargin + maxpmw +cmwidth + (_indentPopupMenuItems ? 16 : 0) - xm:
r.x() + xm;
// Label width (minus the width of the accelerator portion)
int tw = r.width() - xm - tab - arrowHMargin - itemHMargin * 3 - itemFrame + 1;
// Set the color for enabled and disabled text
// (used for both active and inactive menu items)
p->setPen( enabled ? cg.buttonText() : cg.mid() );
// This color will be used instead of the above if the menu item
// is active and disabled at the same time. (etched text)
TQColor discol = cg.mid();
// Does the menu item draw it's own label?
if(mi->custom()) {
int m = 2;
// Save the painter state in case the custom
// paint method changes it in some way
mi->custom()->paint( p, cg, active, enabled, xp, r.y()+m, tw, r.height()-2*m );
}
else {
// The menu item doesn't draw it's own label
TQString s = mi->text();
// Does the menu item have a text label?
if ( !s.isNull() ) {
int t = s.find( '\t' );
int m = 2;
int text_flags = AlignVCenter | ShowPrefix | DontClip | SingleLine;
text_flags |= reverse ? AlignRight : AlignLeft;
TQColor draw = (active && enabled) ? cg.highlightedText() : cg.foreground();
p->setPen(draw);
// Does the menu item have a tabstop? (for the accelerator text)
if ( t >= 0 ) {
int arrowMargin = (mi->popup() || _indentPopupMenuItems ) ? itemHMargin + arrowHMargin : 0;
int tabx = reverse ? r.x() + arrowMargin + itemFrame : r.x() + r.width() - tab - arrowMargin- itemFrame;
// Draw the right part of the label (accelerator text)
//p->drawText( tabx, r.y()+m, tab, r.height()-2*m, text_flags, s.mid( t+1 ) );
dominoDrawItem( p, TQRect(tabx, r.y()+m, tab, r.height()-2*m), text_flags, cg, flags & Style_Enabled, 0, s.mid( t+1 ), -1, &draw);
s = s.left( t );
}
// Draw the left part of the label (or the whole label
// if there's no accelerator)
//p->drawText( xp, r.y()+m, tw, r.height()-2*m, text_flags, s, t );
dominoDrawItem( p, TQRect(xp, r.y()+m, tw, r.height()-2*m), text_flags, cg, flags & Style_Enabled, 0, s, t, &draw);
p->setPen(cg.text());
}
// The menu item doesn't have a text label
// Check if it has a pixmap instead
else if ( mi->pixmap() ) {
TQPixmap *pixmap = mi->pixmap();
// Draw the pixmap
if ( pixmap->depth() == 1 )
p->setBackgroundMode( OpaqueMode );
int diffw = ( ( r.width() - pixmap->width() ) / 2 )
+ ( ( r.width() - pixmap->width() ) % 2 );
p->drawPixmap( r.x()+diffw, r.y()+1, *pixmap );
if ( pixmap->depth() == 1 )
p->setBackgroundMode( TransparentMode );
}
}
// Does the menu item have a submenu?
if ( mi->popup() ) {
PrimitiveElement arrow = reverse ? PE_ArrowLeft : PE_ArrowRight;
int dim = pixelMetric(PM_MenuButtonIndicator, ceData, elementFlags) - 1;
TQRect vr = visualRect( TQRect( r.x() + r.width() - 5 - 1 - dim,
r.y() + r.height() / 2 - dim / 2, dim, dim), r );
TextEffect textEffectMode_save = textEffectSettings.mode;
if(textEffectSettings.mode == TextEffect_OnlyButton)
textEffectSettings.mode = TextEffect_None;
if(enabled) {
p->setPen(active? cg.highlightedText(): cg.foreground());
drawPrimitive( arrow, p, ceData, elementFlags, vr, cg, Style_Enabled);
}
else {
p->setPen(cg.mid());
drawPrimitive( arrow, p, ceData, elementFlags, vr, cg, Style_Default);
}
textEffectSettings.mode = textEffectMode_save;
}
break;
}
case CE_ToolBoxTab: {
bool selected= (flags & Style_Selected && ((TQToolBox*)widget)->currentItem());
TQPixmap pix(widget->size());
TQPainter painter(&pix);
TQColor background = (flags&Style_Down && !selected) ? darkenColor(cg.background(), 15) : cg.background();
painter.fillRect(TQRect(5, 0, r.width()-10, r.height()), background);
renderGradient(&painter, TQRect(r.x(), r.y(), 5, r.height()), background.light(120), background, false);
renderGradient(&painter, TQRect(r.width()-5, r.y(), 5, r.height()), background, background.light(115), false);
painter.setPen(cg.background().dark(120));
painter.drawLine(r.x(), r.bottom(), r.width(), r.bottom());
painter.setPen((hoveredToolBoxTab && !selected) ? dGetColor(cg.background(), 95) : dGetColor(cg.background(), 45));
PrimitiveElement arrow;
TQRect re = TQRect(r.x()+6,r.y(),r.x()+10,r.height());
if(selected) {
arrow = PE_ArrowDown;
re.setY(re.y()+1);
}
else {
arrow = PE_ArrowRight;
}
drawPrimitive(arrow, &painter, ceData, elementFlags, re, cg, Style_Enabled);
p->drawPixmap(r.x(), r.y(), pix);
break;
}
case CE_HeaderLabel:
{
TQRect rect = r;
const TQHeader* header = (const TQHeader *) widget;
int section = opt.headerSection();
TQIconSet* icon = header->iconSet( section );
if ( icon ) {
TQPixmap pixmap = icon->pixmap( TQIconSet::Small,
flags & Style_Enabled ?
TQIconSet::Normal : TQIconSet::Disabled );
int pixw = pixmap.width();
int pixh = pixmap.height();
// "pixh - 1" because of tricky integer division
TQRect pixRect = rect;
pixRect.setY( rect.center().y() - (pixh - 1) / 2 );
drawItem ( p, pixRect, AlignVCenter, cg, flags & Style_Enabled,
&pixmap, TQString::null );
if (TQApplication::reverseLayout())
rect.setRight(rect.right() - pixw - 2);
else
rect.setLeft(rect.left() + pixw + 2);
}
if (rect.isValid())
dominoDrawItem ( p, rect, AlignVCenter, cg, flags & Style_Enabled,
0, header->label( section ), -1, &(cg.buttonText()), textEffectSettings.mode > 0 ? 1 : 0 );
break;
}
default:
TDEStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
}
}
void DominoStyle::drawControlMask(ControlElement element,
TQPainter *p,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQStyleOption &opt,
const TQWidget *w) const
{
switch (element) {
case CE_PushButton: {
break;
}
case CE_CheckBox: {
drawPrimitive(PE_IndicatorMask, p, ceData, elementFlags, r, w->colorGroup(), Style_Default, opt);
break;
}
case CE_RadioButton : {
drawPrimitive(PE_ExclusiveIndicatorMask, p, ceData, elementFlags, r, w->colorGroup(), Style_Default, opt);
break;
}
default: {
break;
//TDEStyle::drawControlMask (element, p, ceData, elementFlags, r, opt, w);
}
}
}
void DominoStyle::drawComplexControl(ComplexControl control,
TQPainter *p,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQColorGroup &cg,
SFlags flags,
SCFlags controls,
SCFlags active,
const TQStyleOption& opt,
const TQWidget *widget) const
{
const bool reverseLayout = TQApplication::reverseLayout();
const bool enabled = (flags & Style_Enabled);
//return TDEStyle::drawComplexControl(control, p, ceData, elementFlags, r, cg, flags, controls, active, opt, widget);
switch(control) {
// COMBOBOX
// --------
case CC_ComboBox: {
static const unsigned int handleWidth = 15;
const TQComboBox *cb = dynamic_cast<const TQComboBox*>(widget);
bool editable = cb && cb->editable();
bool isDown = cb && cb->listBox() && cb->listBox()->isVisible();
bool hasFocus =(flags&Style_HasFocus);
const TQColor inputColor = enabled ? (editable ? cg.base() : cg.button()) : cg.background();
const TQColor bg = (cb && cb->parentWidget()) ? cb->parentWidget()->paletteBackgroundColor() : cg.background();
bool hasPixmap = cb && cb->count() > 0 && cb->pixmap(cb->currentItem());
uint contourFlags = 0;
bool isKhtmlWidget = tdehtmlWidgets.contains(cb);
if(isKhtmlWidget || (cb && cb->parentWidget() && cb->parentWidget()->paletteBackgroundPixmap())) {
contourFlags |= Draw_AlphaBlend;
buttonContour->setAlphaMode();
}
else {
p->fillRect(TQRect(r.x(), r.y(), 6, r.height()), bg);
p->fillRect(TQRect(r.width()-6, r.y(), 6, r.height()), bg);
}
if(hasPixmap && editable && r.width() > 40) {
int x = reverseLayout ? handleWidth+3 : 6;
TQRegion mask(x, 0, 17, r.height());
if(!reverseLayout)
mask += TQRegion(x-2, 4, 2, r.height()-9);
p->setClipRegion(mask);
}
contourFlags |= Round_UpperLeft|Round_BottomLeft|Round_UpperRight|Round_BottomRight|Draw_Right|Draw_Top|
Draw_Bottom|Draw_Left|Is_Button|Is_Horizontal;
uint surfaceFlags = Is_Button|Is_Horizontal;
if(isDown) {
surfaceFlags |= Is_Down;
contourFlags |= Is_Down;
}
renderSurface(p, TQRect(r.left()+2, r.top()+2, r.width()-4, r.height()-5), cg.background(), cg.button(), cg.background(), surfaceFlags);
if(isDown)
buttonContour->setState(Contour_Pressed);
else if(enabled && cb == hoverWidget)
buttonContour->setState(Contour_MouseOver);
renderContour(p, r, bg, cg.button(), contourFlags);
if(editable) {
TQColor lineEditColor = enabled ? cg.base() : cg.background();
TQString isEnabled = enabled ? "1" : "0";
TQPixmap* lineEditBtnEdges; // shared with spinwidget
if(!(lineEditBtnEdges = TQPixmapCache::find(TQString::number(cg.button().pixel(), 16)+TQString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled))) { // + buttoncolor
// To not make the button contour appear thicker with dark button gradiens, we need a tad smaller rounding for the lineEdit edges.
TQPixmap pixmap(1, r.height());
TQPainter painter(&pixmap);
flatMode = true;
renderSurface(&painter, TQRect(0, 0, 1, r.height()), cg.background(), cg.button(), cg.background(), surfaceFlags);
flatMode = false;
TQImage img = pixmap.convertToImage();
// Test, if we have a dark button. Not accurate, but...
TQColor c1 = TQColor(img.pixel(0, r.y()+4));
TQColor c2 = TQColor(img.pixel(0, r.height()-6));
int v, v1, v2;
c1.getHsv(&v, &v ,&v1);
c2.getHsv(&v, &v ,&v2);
TQImage edges = tintImage(qembed_findImage( (v1+v2)/2 < 200 ? "lineEditBtnEdges-d" : "lineEditBtnEdges"), lineEditColor);
if(enabled) {
TQImage shadow = qembed_findImage("lineEditBtnShadow");
blend(shadow, edges, edges);
}
lineEditBtnEdges = new TQPixmap(edges);
TQPixmapCache::insert(TQString::number(cg.button().pixel(), 16)+TQString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled, lineEditBtnEdges);
}
if(reverseLayout) {
bitBlt(p->device(), r.width()-6, r.y()+3, lineEditBtnEdges, 3, 0, 3, 3);
bitBlt(p->device(), r.width()-6, r.height()-7, lineEditBtnEdges, 3, 3, 3, 3);
}
else {
bitBlt(p->device(), r.x()+3, r.y()+3, lineEditBtnEdges, 0, 0, 3, 3);
bitBlt(p->device(), r.x()+3, r.height()-7, lineEditBtnEdges, 0, 3, 3, 3);
}
}
TQRect ar(reverseLayout ? r.left()+3 : r.width()-handleWidth-1, r.height()/2-2, handleWidth, 6);
if(hasFocus && focusIndicatorSettings.indicateFocus && enabled && cb) {
TQRect editField = querySubControlMetrics(control, ceData, elementFlags, SC_ComboBoxEditField, TQStyleOption::Default, widget);
int pw = hasPixmap ? (cb->pixmap(cb->currentItem()))->width()+2 : 0;
if(!editable) {
int fmheight = p->fontMetrics().height();
if(reverseLayout)
editField.addCoords(pw+17, editField.height()/2-fmheight/2-1,0 , 0);
else
editField.addCoords(2+pw, editField.height()/2-fmheight/2-1,0 , 0);
TQRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_ComboBoxFocusRect, ceData, elementFlags, cb) : editField;
drawFocusIndicator(p, re, AlignLeft, cg, true, 0, cb->currentText(), -1, focusIndicatorSettings.buttonColor, focusIndicatorSettings.drawUnderline, true);
}
}
if(isDown) {
uint shadowFlags = Draw_Top|Draw_Right|Draw_Bottom|Draw_Left;
TQRect sr;
if(editable) {
shadowFlags |= reverseLayout? Round_UpperLeft|Round_BottomLeft|Rectangular_UpperRight|Rectangular_BottomRight :
Rectangular_UpperLeft|Rectangular_BottomLeft|Round_UpperRight|Round_BottomRight;
sr = TQRect(reverseLayout ? r.left()+2 : r.width()-handleWidth-3, r.y()+2, handleWidth+3, r.height()-3);
}
else {
shadowFlags |= Round_UpperLeft|Round_BottomLeft|Round_UpperRight|Round_BottomRight;
sr = TQRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3);
}
renderButtonShadow(p, sr, shadowFlags);
}
buttonContour->reset();
p->setPen(cb ? cb->palette().active().buttonText() : tqApp->palette().active().buttonText());
uint aflags = Style_Default|Style_Raised;
if(enabled)
aflags |= Style_Enabled;
drawPrimitive(PE_ArrowDown, p, ceData, elementFlags, ar, cg, aflags);
p->setPen(cg.foreground());
break;
}
// TOOLBUTTON
// ----------
case CC_ToolButton: {
TQToolButton *tb = (TQToolButton *) widget;
if(_toolBtnAsBtn && ::tqt_cast<TDEToolBarButton*>(tb)) {
const bool reverse = TQApplication::reverseLayout();
TDEToolBar *bar = dynamic_cast<TDEToolBar*>(tb->parentWidget());
if(!bar) break;
TDEToolBarButton* btn = ::tqt_cast<TDEToolBarButton*>(tb);
TDEToolBarButton* prevBtn = 0;
TDEToolBarButton* nextBtn = 0;
bool prevBtnIsOn = false;
bool nextBtnIsOn = false;
bool isOn = flags &Style_On || flags &Style_Down;
bool isDown = flags &Style_Down;
const bool horizontal = bar->orientation() == TQt::Horizontal;
TQRect cr = r , sr = r, bsr = r;
int index = bar->itemIndex(btn->id());
if(bar->getButton(bar->idAt(index-1))) {
prevBtn = bar->getButton(bar->idAt(index-1));
if((!reverse) ? (horizontal) ? prevBtn->x() + prevBtn->width() != btn->x() : prevBtn->y() + prevBtn->height() != btn->y() :
(horizontal) ? prevBtn->x() != btn->x()+btn->width() : prevBtn->y() + prevBtn->height() != btn->y()
)
prevBtn = 0;
else
prevBtnIsOn = prevBtn->isOn();
}
if(bar->getButton(bar->idAt(index+1))) {
nextBtn= bar->getButton(bar->idAt(index+1));
if((!reverse) ? (horizontal) ? nextBtn->x() != btn->x() + btn->width() : nextBtn->y() != btn->y() + btn->height() :
(horizontal) ? nextBtn->x() + nextBtn->width() != btn->x() : nextBtn->y() != btn->y() + btn->height()
)
nextBtn = 0;
else
nextBtnIsOn = nextBtn->isOn();
}
bool drawSeparator = false;
uint contourFlags = Is_Button;
uint surfaceFlags = Is_Button;
if(horizontal) {
surfaceFlags |=Is_Horizontal;
contourFlags |=Is_Horizontal;
}
if(isOn) {
surfaceFlags |= Is_Down;
contourFlags |= Is_Down;
}
TQPixmap buffer(btn->size());
TQPainter painter(&buffer);
if(tb->parentWidget() && tb->parentWidget()->paletteBackgroundPixmap()) {
painter.drawTiledPixmap(0, 0, tb->width(), tb->height(), *tb->parentWidget()->paletteBackgroundPixmap(), tb->geometry().x(), tb->geometry().y());
contourFlags |= Draw_AlphaBlend;
}
else
painter.fillRect(buffer.rect(), cg.brush(TQColorGroup::Background));
if(prevBtn) {
if(nextBtn) {
// middle
if(horizontal) {
contourFlags |= Draw_Top|Draw_Bottom;
cr.setLeft(r.left()-6);
cr.setWidth(r.width()+12);
bsr.setLeft(r.left()-2);
bsr.setWidth(r.width()+3);
sr.addCoords(-1, 2, 0, -3);
drawSeparator = true;
}
else {
contourFlags |= Draw_Left|Draw_Right;
cr.setY(r.y()-6);
cr.setHeight(r.height()+13);
bsr.addCoords(2, 0, 0, 1);
sr.addCoords(2, -1, -2, 0);
drawSeparator = true;
}
}
else {
// right / bottom
if(!horizontal) {
contourFlags |= Draw_Bottom|Draw_Right|Draw_Left|Round_BottomRight|Round_BottomLeft;
cr.setY(r.y()-6);
cr.setHeight(r.height()+6);
bsr.addCoords(2, 0, 0, -1);
sr.addCoords(2, -1, -2, -3);
}
else if(!reverse) {
contourFlags |= Draw_Top|Draw_Bottom|Draw_Right|Round_UpperRight|Round_BottomRight;
cr.setLeft(r.left()-6);
cr.setWidth(r.width()+5);
bsr.setLeft(r.left()-2);
bsr.setWidth(r.width()+1);
sr.addCoords(-1, 2, -3, -3);
}
else { // reverse
contourFlags |= Draw_Top|Draw_Bottom|Draw_Left|Round_UpperLeft|Round_BottomLeft;
cr.setWidth(r.width()+6);
bsr.setWidth(r.width()+1);
sr.addCoords(2, 2, 0, -3);
drawSeparator = true;
}
}
}
else {
if(nextBtn) {
// left / top
if(!horizontal) {
contourFlags |= Draw_Top|Draw_Left|Draw_Right|Round_UpperLeft|Round_UpperRight;
cr.setHeight(r.height()+7);
bsr.addCoords(2, 2, 0, +1);
sr.addCoords(2, 2, -2, 0);
drawSeparator = true;
}
else if(!reverse) {
contourFlags |= Draw_Top|Draw_Bottom|Draw_Left|Round_UpperLeft|Round_BottomLeft;
cr.setWidth(r.width()+6);
bsr.setWidth(r.width()+1);
sr.addCoords(2, 2, 0, -3);
drawSeparator = true;
}
else { //reverse
contourFlags |= Draw_Top|Draw_Bottom|Draw_Right|Round_UpperRight|Round_BottomRight;
cr.setLeft(r.left()-6);
cr.setWidth(r.width()+5);
bsr.setLeft(r.left()-2);
bsr.setWidth(r.width()+1);
sr.addCoords(-1, 2, -3, -3);
}
}
else {
// full
if(horizontal) {
cr.setWidth(r.width()-1);
bsr.setWidth(r.width()-1);
sr.addCoords(2, 2, -3, -3);
}
else {
bsr.addCoords(2, 2, 0, -1);
sr.addCoords(2, 2, -2, -3);
}
contourFlags |= Draw_Top|Draw_Bottom|Draw_Left|Draw_Right|Round_UpperLeft|Round_BottomLeft|
Round_UpperRight|Round_BottomRight;
}
}
renderSurface(&painter, sr, cg.background(), cg.background(), cg.background(), surfaceFlags);
drawControl(CE_ToolButtonLabel, &painter, ceData, elementFlags, r, cg, flags, opt, widget);
renderContour(&painter, cr, cg.background(), cg.background(), contourFlags);
/////////////////////////////////////////// drop down indicator
if(tb->popup()) {
TQString isEnabled = enabled ? "1" : "0";
TQPixmap* arrow;
TQColor color = btn->palette().active().buttonText();
if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled))) {
TQImage ar = tintImage(qembed_findImage("arrow_down"), color);
if(!isEnabled) {
ar = setImageOpacity(ar, 25);
}
arrow = new TQPixmap(ar);
TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled, arrow);
}
TQPoint point;
if(prevBtn)
if(nextBtn)
if(horizontal)
point = TQPoint(cr.width()-19, cr.bottom()-8);
else
point = TQPoint(cr.width()-8, cr.bottom()-12);
else
if(!horizontal)
point = TQPoint(cr.width()-8, cr.bottom()-8);
else if(!reverse)
point = TQPoint(cr.width()-15, cr.bottom()-8);
else // reverse
point = TQPoint(cr.width()-13, cr.bottom()-8);
else
if(nextBtn)
if(!horizontal)
point = TQPoint(cr.width()-8, cr.bottom()-12);
else if(!reverse)
point = TQPoint(cr.width()-13, cr.bottom()-8);
else //reverse
point = TQPoint(cr.width()-15, cr.bottom()-8);
else
if(horizontal)
point = TQPoint(cr.width()-9, cr.bottom()-8);
else
point = TQPoint(cr.width()-8, cr.bottom()-8);
bitBlt(&buffer, point.x(), point.y(), arrow);
}
/////////////////////////////////////////// separator
if(drawSeparator) { // on the right side of the button
ContourState cState;
if(reverse && horizontal) {
if( ((enabled && !isDown) || (prevBtn && prevBtn == hoverWidget)) && (hoverWidget && (tb == hoverWidget || (prevBtn == hoverWidget && prevBtn->isEnabled() && !prevBtn->isDown()))) )
cState = Contour_MouseOver;
else if(isDown || (prevBtn && prevBtn->isDown()))
cState = Contour_Pressed;
else
cState = Contour_Default;
}
else {
if( ((enabled && !isDown) || (nextBtn &&nextBtn == hoverWidget)) && (hoverWidget && (tb == hoverWidget || (nextBtn == hoverWidget && nextBtn->isEnabled() && !nextBtn->isDown()))) )
cState = Contour_MouseOver;
else if(isDown || (nextBtn && nextBtn->isDown()))
cState = Contour_Pressed;
else
cState = Contour_Default;
}
painter.setPen(alphaBlendColors(buttonContour->contourColor(cState), cg.background(), 218));
if(horizontal)
painter.drawLine(r.width()-1, r.top()+1, r.width()-1, r.bottom()-2);
else
painter.drawLine(r.x()+1, r.bottom(), r.width()-2, r.bottom());
}
/////////////////////////////////////////// button shadow
if(isOn && buttonContour->drawButtonSunkenShadow) {
uint shadowFlags;
if(prevBtnIsOn) { // or above is on
if(nextBtnIsOn) { // or below is on
if(horizontal) {
shadowFlags = Draw_Top|Draw_Bottom;
bsr.addCoords(-3, 2, +5, -1);
}
else {
shadowFlags = Draw_Left|Draw_Right;
bsr.addCoords(0, -5, 0, +4);
}
}
else {
if(horizontal) {
if(!reverse) {
shadowFlags = Draw_Top|Draw_Bottom|Draw_Right;
shadowFlags |= contourFlags& Round_UpperRight ? Round_UpperRight : Rectangular_UpperRight;
shadowFlags |= contourFlags& Round_BottomRight ? Round_BottomRight : Rectangular_BottomRight;
bsr.addCoords(-3, 2, 0, -1);
}
else {
shadowFlags = Draw_Top|Draw_Bottom|Draw_Left;
shadowFlags |= contourFlags& Round_UpperLeft ? Round_UpperLeft : Rectangular_UpperLeft;
shadowFlags |= contourFlags& Round_BottomLeft ? Round_BottomLeft : Rectangular_BottomLeft;
bsr.addCoords(2, 2, 5, -1);
}
}
else {
shadowFlags = Draw_Bottom|Draw_Left|Draw_Right;
shadowFlags |= contourFlags& Round_BottomLeft ? Round_BottomLeft : Rectangular_BottomLeft;
shadowFlags |= contourFlags& Round_BottomRight ? Round_BottomRight : Rectangular_BottomRight;
bsr.setY(bsr.y()-5);
}
}
}
else if(nextBtnIsOn) {
if(horizontal) {
if(!reverse) {
shadowFlags = Draw_Top|Draw_Bottom|Draw_Left;
shadowFlags |= (contourFlags& Round_UpperLeft) ? Round_UpperLeft : Rectangular_UpperLeft;
shadowFlags |= (contourFlags& Round_BottomLeft) ? Round_BottomLeft : Rectangular_BottomLeft;
bsr.addCoords(2, 2, 5, -1);
}
else {
shadowFlags = Draw_Top|Draw_Bottom|Draw_Right;
shadowFlags |= contourFlags& Round_UpperRight ? Round_UpperRight : Rectangular_UpperRight;
shadowFlags |= contourFlags& Round_BottomRight ? Round_BottomRight : Rectangular_BottomRight;
bsr.addCoords(-3, 2, 0, -1);
}
}
else {
shadowFlags = Draw_Top|Draw_Left|Draw_Right;
shadowFlags |= contourFlags& Round_UpperLeft ? Round_UpperLeft : Rectangular_UpperLeft;
shadowFlags |= contourFlags& Round_UpperRight ? Round_UpperRight : Rectangular_UpperRight;
bsr.setHeight(bsr.height()+4);
}
}
else {
if(horizontal) {
shadowFlags = Draw_Top|Draw_Bottom|Draw_Left|Draw_Right;
shadowFlags |= contourFlags& Round_UpperLeft ? Round_UpperLeft : Rectangular_UpperLeft;
shadowFlags |= contourFlags& Round_UpperRight ? Round_UpperRight : Rectangular_UpperRight;
shadowFlags |= contourFlags& Round_BottomRight ? Round_BottomRight : Rectangular_BottomRight;
shadowFlags |= contourFlags& Round_BottomLeft ? Round_BottomLeft : Rectangular_BottomLeft;
bsr.addCoords(2, 2, 0, -1);
}
else {
shadowFlags = Draw_Top|Draw_Bottom|Draw_Left|Draw_Right;
shadowFlags |= contourFlags& Round_UpperLeft ? Round_UpperLeft : Rectangular_UpperLeft;
shadowFlags |= contourFlags& Round_UpperRight ? Round_UpperRight : Rectangular_UpperRight;
shadowFlags |= contourFlags& Round_BottomRight ? Round_BottomRight : Rectangular_BottomRight;
shadowFlags |= contourFlags& Round_BottomLeft ? Round_BottomLeft : Rectangular_BottomLeft;
}
}
renderButtonShadow(&painter, bsr, shadowFlags);
}
btn->setUpdatesEnabled(false);
btn->setErasePixmap(buffer);
btn->setUpdatesEnabled(true);
btn->erase();
}
else if(_toolBtnAsBtn) { // not a TDEToolBarButton
if(kickerMode && !(flags&(Style_Raised)))
break;
const TQRect br = querySubControlMetrics(control, ceData, elementFlags, SC_ToolButton, opt, widget);
if(br.width() < 16 || br.height()< 16)
break;
TQColorGroup g = widget->colorGroup();
TQColor bg;
if(widget->parentWidget() && widget->paletteBackgroundColor() != widget->parentWidget()->paletteBackgroundColor()) {
bg = widget->parentWidget()->paletteBackgroundColor();
g.setColor(TQColorGroup::Background, bg);
}
else
bg = widget->paletteBackgroundColor();
if(!widget->paletteBackgroundPixmap()) {
p->fillRect(TQRect(br.x(), br.y(), 6, 6), bg);
p->fillRect(TQRect(br.width()-6, br.y(), 6, 6), bg);
p->fillRect(TQRect(br.width()-6, br.height()-7, 6, 7), bg);
p->fillRect(TQRect(br.x(), br.height()-7, 6, 7), bg);
}
else {
buttonContour->setAlphaMode();
}
if(/*flags &Style_On || */flags &Style_Down)
buttonContour->setState(Contour_Pressed);
if(enabled && tb == hoverWidget)
buttonContour->setState(Contour_MouseOver);
else if(flags & Style_Default)
buttonContour->setState(Contour_DefaultButton);
renderButton(p, br, g, (flags & Style_On || flags & Style_Down), flags & Style_MouseOver, true, enabled, tdehtmlWidgets.contains(opt.widget()) );
buttonContour->reset();
if(tb->popup()) {
TQString isEnabled = enabled ? "1" : "0";
TQPixmap* arrow;
TQColor color = tb->palette().active().buttonText();
if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled))) {
TQImage ar = tintImage(qembed_findImage("arrow_down"), color);
if(!isEnabled) {
ar = setImageOpacity(ar, 25);
}
arrow = new TQPixmap(ar);
TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled, arrow);
}
bitBlt(p->device(), r.width()-8, r.bottom()-8, arrow);
}
}
else {
bool isKbtn = ::tqt_cast<TDEToolBarButton*>(tb);
TQPixmap buffer(tb->size());
TQPainter painter(&buffer);
TQColor bg = cg.background();
if(tb->parentWidget() && tb->parentWidget()->paletteBackgroundPixmap()) {
painter.drawTiledPixmap(0, 0, tb->width(), tb->height(), *tb->parentWidget()->paletteBackgroundPixmap(), tb->geometry().x(), tb->geometry().y());
}
else if(tb->parentWidget() && widget->paletteBackgroundColor() != widget->parentWidget()->paletteBackgroundColor()) {
bg = widget->parentWidget()->paletteBackgroundColor();
painter.fillRect(buffer.rect(), bg);
}
else
painter.fillRect(buffer.rect(), cg.brush(TQColorGroup::Background));
TQRect fr = TQRect(1, 1, r.width()-2, r.height()-2);
bool isOn = flags &Style_On;
if(isOn) {
TQRegion reg(fr.x()+2, fr.y()+1, fr.width()-4, fr.height()-2);
reg += TQRegion(fr.x()+1, fr.y()+2, fr.width()-2, fr.height()-4);
painter.setClipRegion(reg);
painter.fillRect(r, alphaBlendColors(black, bg, 15));
painter.setClipping(false);
}
if(isKbtn)
drawControl(CE_ToolButtonLabel, &painter, ceData, elementFlags, r, cg, flags, opt, widget);
if(isOn) {
TQColor color = buttonContour->contourColor(Contour_Default);
TQPixmap* frame;
if(!(frame = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"toolBtnFrameThin"))) {
frame = new TQPixmap(tintImage(qembed_findImage("toolBtnFrameThin"), color));
TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"toolBtnFrameThin", frame);
}
bitBlt(&buffer, fr.x(), fr.y(), frame, 0, 0, 4, 4);
bitBlt(&buffer, fr.width()-3, fr.y(), frame, 4, 0, 4, 4);
bitBlt(&buffer, fr.x(), fr.height()-3, frame, 0, 4, 4, 4);
bitBlt(&buffer, fr.width()-3, fr.height()-3, frame, 4, 4, 4, 4);
painter.setPen(alphaBlendColors(color, bg, 195));
painter.drawLine(fr.x()+4, fr.y(), fr.width()-4, fr.y());
painter.drawLine(fr.x(), fr.y()+4, fr.x(), fr.height()-4);
painter.drawLine(fr.width(), fr.y()+4, fr.width(), fr.height()-4);
painter.drawLine(fr.x()+4, fr.height(), fr.width()-4, fr.height());
}
if(tb->popup() && (!tb->iconSet().isNull() || !tb->text().isEmpty() || tb->pixmap())) {
TQString isEnabled = enabled ? "1" : "0";
TQPixmap* arrow;
TQColor color = tb->palette().active().buttonText();
if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled))) {
TQImage ar = tintImage(qembed_findImage("arrow_down"), color);
if(!isEnabled) {
ar = setImageOpacity(ar, 25);
}
arrow = new TQPixmap(ar);
TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled, arrow);
}
bitBlt(&buffer, r.width()-8, r.bottom()-4, arrow);
}
if(isKbtn) {
tb->setUpdatesEnabled(false);
tb->setErasePixmap(buffer);
tb->erase();
tb->setUpdatesEnabled(true);
}
else
p->drawPixmap(0, 0, buffer);
}
p->setPen(cg.buttonText() );
break;
}
// SPINWIDGETS
// -----------
case CC_SpinWidget: {
if(active == SC_SpinWidgetUp || active == SC_SpinWidgetDown)
break;
static const unsigned int handleWidth = 15;
const TQSpinWidget *sw = dynamic_cast<const TQSpinWidget *>(widget);
const TQColor bg = cg.background();
SFlags sflags = flags;
PrimitiveElement pe;
bool enabled = sw && sw->isEnabled();
const TQColor buttonColor = enabled ? cg.button() : cg.background();
uint contourFlags = Round_UpperLeft|Round_BottomLeft|Round_UpperRight|Round_BottomRight|Draw_Right|Draw_Top|
Draw_Bottom|Draw_Left|Is_Button|Is_Horizontal;
// fill edges
if(sw && !sw->paletteBackgroundPixmap()) {
p->fillRect(TQRect(r.x(), r.y(), 6, r.height()), bg);
p->fillRect(TQRect(r.width()-6, r.y(), 6, r.height()), bg);
}
else {
contourFlags |= Draw_AlphaBlend;
buttonContour->setAlphaMode();
}
uint surfaceFlags = Is_Button|Is_Horizontal;
if(flags& Style_Down) {
surfaceFlags |= Is_Down;
contourFlags |= Is_Down;
}
renderSurface(p, TQRect(r.x()+2, r.y()+2, r.width()-4, r.height()-5), cg.background(), cg.button(), cg.button(), surfaceFlags);
if(flags & Style_Down)
buttonContour->setState(Contour_Pressed);
else if(enabled && sw == hoverWidget)
buttonContour->setState(Contour_MouseOver);
renderContour(p, r, cg.background(), cg.button(), contourFlags);
if(flags & Style_Down)
renderButtonShadow(p, TQRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3), contourFlags);
buttonContour->reset();
// TQColor lineEditColor = enabled ? cg.base() : cg.background();
TQColor lineEditColor = enabled ? cg.base() : dynamic_cast<TQSpinBox*>(sw->parentWidget()) ?
((DominoTQSpinBox*)sw->parentWidget())->editor()->palette().active().background(): tqApp->palette().active().background();
TQString isEnabled = enabled ? "1" : "0";
TQPixmap* lineEditBtnEdges;
if(!(lineEditBtnEdges = TQPixmapCache::find(TQString::number(cg.button().pixel(), 16)+TQString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled))) {
// To not make the button contour appear thicker with dark button gradiens, we need a tad smaller rounding for the lineEdit edges.
TQPixmap pixmap(1, r.height());
TQPainter painter(&pixmap);
flatMode = true;
renderSurface(&painter, TQRect(0, 0, 1, r.height()), cg.background(), cg.button(), cg.button(), surfaceFlags);
flatMode = false;
TQImage img = pixmap.convertToImage();
// Test, if we have a dark button. Not accurate, but...
TQColor c1 = TQColor(img.pixel(0, r.y()+4));
TQColor c2 = TQColor(img.pixel(0, r.height()-6));
int v, v1, v2;
c1.getHsv(&v, &v ,&v1);
c2.getHsv(&v, &v ,&v2);
TQImage edges = tintImage(qembed_findImage( (v1+v2)/2 < 127 ? "lineEditBtnEdges-d" : "lineEditBtnEdges"), lineEditColor);
if(enabled) {
TQImage shadow = qembed_findImage("lineEditBtnShadow");
blend(shadow, edges, edges);
}
lineEditBtnEdges = new TQPixmap(edges);
TQPixmapCache::insert(TQString::number(cg.button().pixel(), 16)+TQString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled, lineEditBtnEdges);
}
if(reverseLayout) {
bitBlt(p->device(), r.width()-6, r.y()+3, lineEditBtnEdges, 3, 0, 3, 3);
bitBlt(p->device(), r.width()-6, r.height()-7, lineEditBtnEdges, 3, 3, 3, 3);
}
else {
bitBlt(p->device(), r.x()+3, r.y()+3, lineEditBtnEdges, 0, 0, 3, 3);
bitBlt(p->device(), r.x()+3, r.height()-7, lineEditBtnEdges, 0, 3, 3, 3);
}
TQRect upRect = TQRect(reverseLayout ? r.left()+2 : r.right()-handleWidth-1, r.height()/2-7, handleWidth, 6);
TQRect downRect = TQRect(reverseLayout ? r.left()+2 : r.right()-handleWidth-1, r.height()/2+1, handleWidth, 6);
// icons...
//p->setPen(cg.foreground());
p->setPen(sw ? sw->palette().active().buttonText() : tqApp->palette().active().buttonText());
sflags = Style_Default;
if(enabled)
sflags |= Style_Enabled;
if (active == SC_SpinWidgetUp) {
sflags |= Style_On;
sflags |= Style_Sunken;
} else
sflags |= Style_Raised;
if (sw->buttonSymbols() == TQSpinWidget::PlusMinus) {
pe = PE_SpinWidgetPlus;
upRect.moveTop(upRect.y()+1);
}
else
pe = PE_SpinWidgetUp;
drawPrimitive(pe, p, ceData, elementFlags, upRect, cg, sflags);
sflags = Style_Default;
if(enabled)
sflags |= Style_Enabled;
if (active == SC_SpinWidgetDown) {
sflags |= Style_On;
sflags |= Style_Sunken;
} else
sflags |= Style_Raised;
if (sw->buttonSymbols() == TQSpinWidget::PlusMinus)
pe = PE_SpinWidgetMinus;
else
pe = PE_SpinWidgetDown;
drawPrimitive(pe, p, ceData, elementFlags, downRect, cg, sflags);
break;
}
case CC_ScrollBar: { // TODO: find a way to draw pressed buttons
const TQScrollBar *sb = (const TQScrollBar*)widget;
bool maxedOut = (sb->minValue() == sb->maxValue());
bool horizontal = (sb->orientation() == TQt::Horizontal);
SFlags sflags = ((horizontal ? Style_Horizontal : Style_Default) |
(maxedOut ? Style_Default : Style_Enabled));
TQRect addline, subline, subline2, addpage, subpage, slider, first, last;
subline = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubLine, opt, widget);
addline = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddLine, opt, widget);
subpage = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubPage, opt, widget);
addpage = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddPage, opt, widget);
slider = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSlider, opt, widget);
// first = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarFirst, opt, widget);
// last = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarLast, opt, widget);
// subline2 = addline;
// if (horizontal)
// subline2.moveBy(-addline.width(), 0);
// else
// subline2.moveBy(0, -addline.height());
// Draw the up/left button set
if ((controls & SC_ScrollBarSubLine) && subline.isValid()) {
drawPrimitive(PE_ScrollBarSubLine, p, ceData, elementFlags, subline, cg,
sflags | (active == SC_ScrollBarSubLine ?
Style_Down : Style_Default));
subline2 = addline;
if (horizontal)
subline2.moveBy(-addline.width(), 0);
else
subline2.moveBy(0, -addline.height());
if (subline2.isValid())
drawPrimitive((TQStyle::PrimitiveElement)PE_ScrollBarSubLine2, p,
ceData, elementFlags, subline2, cg,
sflags | (active == SC_ScrollBarSubLine ?
Style_Down : Style_Default));
}
if ((controls & SC_ScrollBarAddLine) && addline.isValid())
drawPrimitive(PE_ScrollBarAddLine, p, ceData, elementFlags, addline, cg,
sflags | ((active == SC_ScrollBarAddLine) ?
Style_Down : Style_Default));
if ((controls & SC_ScrollBarSubPage) && subpage.isValid())
drawPrimitive(PE_ScrollBarSubPage, p, ceData, elementFlags, subpage, cg,
sflags | ((active == SC_ScrollBarSubPage) ?
Style_Down : Style_Default));
if ((controls & SC_ScrollBarAddPage) && addpage.isValid())
drawPrimitive(PE_ScrollBarAddPage, p, ceData, elementFlags, addpage, cg,
sflags | ((active == SC_ScrollBarAddPage) ?
Style_Down : Style_Default));
// if ((controls & SC_ScrollBarFirst) && first.isValid())
// drawPrimitive(PE_ScrollBarFirst, p, ceData, elementFlags, first, cg,
// sflags | ((active == SC_ScrollBarFirst) ?
// Style_Down : Style_Default));
//
// if ((controls & SC_ScrollBarLast) && last.isValid())
// drawPrimitive(PE_ScrollBarLast, p, ceData, elementFlags, last, cg,
// sflags | ((active == SC_ScrollBarLast) ?
// Style_Down : Style_Default));
if ((controls & SC_ScrollBarSlider) && slider.isValid()) {
drawPrimitive(PE_ScrollBarSlider, p, ceData, elementFlags, slider, cg,
sflags | ((active == SC_ScrollBarSlider) ?
Style_Down : Style_Default));
}
break;
}
case CC_TitleBar: {
TQRect ir;
bool down;
TQColorGroup g = widget->colorGroup();
if ( controls & SC_TitleBarLabel ) {
TQPixmap pix(10, r.height());
pix.fill(g.background());
TQPainter painter(&pix);
renderGradient(&painter, TQRect(0, 0, 10, r.height()/2), g.background().light(120), g.background(), true);
painter.setPen(g.background().dark(105));
painter.drawLine(0, r.bottom(), 10, r.bottom());
p->drawTiledPixmap(0,0, r.width(), r.height(), pix);
ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarLabel, TQStyleOption::Default, widget ), widget );
p->setPen( g.foreground() );
p->drawText(ir.x()+2, ir.y(), ir.width()-2, ir.height(), AlignCenter | AlignVCenter | SingleLine, widget->caption() );
}
if ( controls & SC_TitleBarCloseButton ) {
ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarCloseButton, TQStyleOption::Default, widget ), widget );
down = active & SC_TitleBarCloseButton;
p->drawPixmap(ir.x(), ir.y(), qembed_findImage("DockCloseButton"), 0, down ? 12 : 0, 12, 12);
}
if ( controls & SC_TitleBarMaxButton ) {
ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarMaxButton, TQStyleOption::Default, widget ), widget );
down = active & SC_TitleBarMaxButton;
p->drawPixmap(ir.x(), ir.y(), qembed_findImage("OverlapButton"), 0, down ? 12 : 0, 12, 12);
}
if ( controls & SC_TitleBarNormalButton) {
ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarNormalButton, TQStyleOption::Default, widget ), widget );
down = active & SC_TitleBarNormalButton;
p->drawPixmap(ir.x(), ir.y(), qembed_findImage("ToDesktopButton"), 0, down ? 12 : 0, 12, 12);
}
if ( controls & SC_TitleBarMinButton) {
ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarMinButton, TQStyleOption::Default, widget ), widget );
down = active & SC_TitleBarMinButton;
p->drawPixmap(ir.x(), ir.y(), qembed_findImage("DockbackButton"), 0, down ? 12 : 0, 12, 12);
}
if ( controls & SC_TitleBarSysMenu ) {
if ( widget->icon() ) {
ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarSysMenu, TQStyleOption::Default, widget ), widget );
drawItem( p, ir, AlignCenter, widget->colorGroup(), TRUE, widget->icon(), TQString::null );
}
}
break;
}
default:
TDEStyle::drawComplexControl(control, p, ceData, elementFlags,
r, cg, flags, controls,
active, opt, widget);
break;
}
}
TQRect DominoStyle::subRect(SubRect r,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQWidget *widget) const
{
switch (r) {
case SR_PushButtonContents: {
const TQPushButton* btn = static_cast<const TQPushButton*>(widget);
TQRect rw = widget->rect();
if(btn->text().isEmpty())
return TQRect(rw.left()+2, rw.top()+2, rw.width()-4, rw.height()-4);
return TQRect(rw.left()+2, rw.top()+3, rw.width()-4, rw.height()-7);
}
case SR_PushButtonFocusRect:
{
TQRect rect, wrect(widget->rect());
const TQPushButton *button = (const TQPushButton *) widget;
int dbw1 = 0, dbw2 = 0;
if (button->isDefault() || button->autoDefault()) {
dbw1 = pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget);
dbw2 = dbw1 * 2;
}
int dfw1 = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) * 2,
dfw2 = dfw1 * 2;
rect.setRect(wrect.x() + dfw1 + dbw1,
wrect.y() + dfw1 + dbw1,
wrect.width() - dfw2 - dbw2,
wrect.height() - dfw2 - dbw2);
return rect;
}
case SR_ComboBoxFocusRect: {
return TQRect(4, 3, widget->width()-8, widget->height()-7);
// return querySubControlMetrics( CC_ComboBox, ceData, elementFlags, SC_ComboBoxEditField, TQStyleOption::Default, widget );
}
case SR_CheckBoxFocusRect:
{
TQRect cr = subRect(SR_CheckBoxContents, ceData, elementFlags, widget);
TQRect fr = TDEStyle::subRect(r, ceData, elementFlags, widget);
if(cr.width() <= 0) // no text
fr.setHeight(fr.height()+2);
else
fr.addCoords(+2, 0, -2, 0);
return fr;
}
case SR_RadioButtonFocusRect:
{
TQRect cr = subRect(SR_CheckBoxContents, ceData, elementFlags, widget);
TQRect fr = TDEStyle::subRect(r, ceData, elementFlags, widget);
if(cr.width() <= 0) // no text
fr.setHeight(fr.height()+2);
else
fr.addCoords(+2, 0, -2, 0);
return fr;
}
case SR_ProgressBarGroove: {
return TQRect(widget->rect());
}
case SR_ProgressBarContents:
case SR_ProgressBarLabel: {
TQRect rw = widget->rect();
return TQRect(rw.left()+2, rw.top()+2, rw.width()-4, rw.height()-4 );
}
case SR_ToolBoxTabContents: {
TQRect rw = widget->rect();
return TQRect(rw.left()+18, rw.top(), rw.width()-18, rw.height());
}
default: {
return TDEStyle::subRect(r, ceData, elementFlags, widget);
}
}
}
TQRect DominoStyle::querySubControlMetrics(ComplexControl control,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
SubControl subcontrol,
const TQStyleOption &opt,
const TQWidget *widget) const
{
if (!widget) {
return TQRect();
}
TQRect r(widget->rect());
switch (control) {
case CC_ComboBox: {
switch (subcontrol) {
case SC_ComboBoxEditField: {
const TQComboBox* cb = dynamic_cast<const TQComboBox *>(widget);
if(!cb) // maybe tdevelop's KComboView
return TQRect(r.left()+4, r.top()+3, r.width()-4-15-3, r.height()-7);
if(!cb->editable())
return TQRect(r.left()+3, r.top()+3, r.width()-4-15-2, r.height()-6);
return TQRect(r.left()+3, r.top()+3, r.width()-4-15-2, r.height()-7);
}
default: {
return TDEStyle::querySubControlMetrics(control, ceData, elementFlags, subcontrol, opt, widget);
}
}
break;
}
case CC_SpinWidget: {
const int fw = 2; // Frame width...
const int buttonsWidth = 15;
const bool heightDividable = ((r.height()%2) == 0);
const int buttonsLeft = r.right()-buttonsWidth+1-fw;
switch (subcontrol) {
case SC_SpinWidgetUp: { // rect without 2px frame
return TQRect(buttonsLeft, r.top()+3, buttonsWidth+1, r.height()/2-3 );
}
case SC_SpinWidgetDown: {
if(heightDividable) {
return TQRect(buttonsLeft, r.top()+r.height()/2+1, buttonsWidth+1, r.height()/2-3);
} else {
return TQRect(buttonsLeft, r.top()+r.height()/2+1, buttonsWidth+1, r.height()/2-2);
}
}
case SC_SpinWidgetFrame: {
return TQRect(r.left(), r.top(), r.width(), r.height() );
}
case SC_SpinWidgetEditField: {
return TQRect(r.left()+1+fw, r.top()+1+fw, r.width()-(buttonsWidth+2+fw*2), r.height()-3-fw*2);
}
case SC_SpinWidgetButtonField: {
return TQRect(buttonsLeft, r.top()+2, buttonsWidth, r.height()-5);
}
default: {
return TDEStyle::querySubControlMetrics(control, ceData, elementFlags, subcontrol, opt, widget);
}
}
break;
}
case CC_ScrollBar: {
const TQScrollBar *scrollbar = (const TQScrollBar *) widget;
int sliderstart = scrollbar->sliderStart();
const int buttonw = 15 /*- (fw * 2)*/;
const int buttonh = 15 /*- (fw * 2)*/;
int maxlen = ((scrollbar->orientation() == TQt::Horizontal) ?
scrollbar->width() : scrollbar->height()) - buttonh * 3;
// calculate slider length
if (scrollbar->maxValue() != scrollbar->minValue()) {
uint range = scrollbar->maxValue() - scrollbar->minValue();
sliderlen = (scrollbar->pageStep() * maxlen) /
(range + scrollbar->pageStep());
if ( sliderlen < 32 || range > INT_MAX/2 )
sliderlen = 32;
if ( sliderlen > maxlen )
sliderlen = maxlen;
}
else
sliderlen = maxlen;
switch(subcontrol) {
case SC_ScrollBarAddLine: { // bottom/right button
if (scrollbar->orientation() == TQt::Horizontal) {
return TQRect(scrollbar->width() - buttonw , 0, buttonw, buttonh);
} else {
return TQRect(0, scrollbar->height() - buttonh, buttonw, buttonh);
}
}
case SC_ScrollBarSubLine: { // top/left button
return TQRect(0, 0, buttonw, buttonh);
}
case SC_ScrollBarSubPage: // top/left
if (scrollbar->orientation() == TQt::Horizontal)
return TQRect(buttonw, 0, sliderstart-buttonw+1, buttonw);
return TQRect(0, buttonh, buttonw, sliderstart-buttonw+1);
case SC_ScrollBarAddPage: // bottom/left
if (scrollbar->orientation() == TQt::Horizontal)
return TQRect(sliderstart + sliderlen-1, 0, maxlen - sliderstart - sliderlen + buttonw+1, buttonw);
return TQRect(0, sliderstart + sliderlen-1, buttonw, maxlen - sliderstart - sliderlen + buttonw+1);
case SC_ScrollBarGroove:
if (scrollbar->orientation() == TQt::Horizontal)
return TQRect(buttonw , 0, maxlen, buttonw);
return TQRect(0, buttonw, buttonw, maxlen);
case SC_ScrollBarSlider:
if (scrollbar->orientation() == TQt::Horizontal)
return TQRect(sliderstart, 0, sliderlen, buttonw);
return TQRect(0, sliderstart, buttonw, sliderlen);
default:
break;
}
}
default: {
return TDEStyle::querySubControlMetrics(control, ceData, elementFlags, subcontrol, opt, widget);
}
}
}
int DominoStyle::pixelMetric(PixelMetric m,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQWidget *widget) const
{
//return TDEStyle::pixelMetric(m, ceData, elementFlags, widget);
switch(m) {
// FRAMES
// ------
case PM_DefaultFrameWidth: {
if(widget) {
if(dynamic_cast<const TQPopupMenu*>(widget))
return 3;
// stolen from baghira
if (dynamic_cast<TQTabWidget*>(widget->parentWidget()) && widget->parentWidget()->parentWidget() && (widget->parentWidget()->parentWidget()->isA("KonqMainWindow") || widget->parentWidget()->parentWidget()->isA("KonqFrameContainer")))
return 0;
}
return 2;
}
case PM_MenuBarFrameWidth:
return 1;
case PM_SpinBoxFrameWidth:
return 2;
// CHECKBOXES / RADIO BUTTONS
// --------------------------
case PM_IndicatorWidth: // Checkbox 18x19
return 18;
case PM_IndicatorHeight:
return 19;
case PM_ExclusiveIndicatorWidth: // Radiobutton 17x17
case PM_ExclusiveIndicatorHeight:
return 17;
// TABS
// ----
case PM_TabBarTabVSpace: {
const TQTabBar * tb = (const TQTabBar *) widget;
switch(tb->shape()) {
case TQTabBar::RoundedAbove:
case TQTabBar::RoundedBelow:
return 12;
default:
return 4;
}
}
case PM_TabBarTabShiftVertical: {
const TQTabBar * tb = (const TQTabBar *) widget;
switch (tb->shape()) {
case TQTabBar::RoundedAbove:
return 1;
case TQTabBar::RoundedBelow:
return (tb->parentWidget() && tb->parentWidget()->isA("KonqFrameTabs"))? 0 : -1;
default:
return 0;
}
}
case PM_TabBarTabShiftHorizontal: {
return 0;
}
case PM_TabBarTabOverlap: {
return 1;
}
case PM_TabBarBaseOverlap: {
const TQTabWidget * tw = (const TQTabWidget *) widget;
if(((DominoTQTabWidget*)tw)->tabBar()->isHidden() || tw->isA("KonqFrameTabs"))
return 0;
return (tw->tabPosition() == TQTabWidget::Top) ? -3 : -4;
}
#if (TQT_VERSION >= 0x030300) // requires TQt 3.3
// extra space between menubar items
case PM_MenuBarItemSpacing: {
return 6;
}
#endif
// #if (TQT_VERSION >= 0x030300) // requires TQt 3.3
// // extra space between toolbar items
// case PM_ToolBarItemSpacing: {
// return 4;
// }
// #endif
// SCROLL BAR
// case PM_ScrollBarSliderMin: {
// return 21;
// }
case PM_ScrollBarExtent: {
return 15;
}
case PM_DockWindowSeparatorExtent:
return 6;
// SPLITTERS
// ---------
case PM_SplitterWidth: {
return 6;
}
// PROGRESSBARS
// ------------
case PM_ProgressBarChunkWidth:
return 10;
// SLIDER
// ------
case PM_SliderLength:
case PM_SliderThickness:
return 15;
// MENU INDICATOR
// --------------
case PM_MenuButtonIndicator:
return 8;
case PM_ButtonDefaultIndicator: {
return 0;
}
case PM_ButtonMargin: {
//return 2;
return 4;
}
case PM_HeaderMargin:
return 2;
case PM_ButtonShiftVertical:
case PM_ButtonShiftHorizontal: {
return 0;
}
case PM_CheckListControllerSize: // radio controller
case PM_CheckListButtonSize: { // box controller
return 16;
}
// case PM_PopupMenuFrameVerticalExtra:
// return 1;
// case PM_PopupMenuFrameHorizontalExtra:
// return 1;
default:
return TDEStyle::pixelMetric(m, ceData, elementFlags, widget);
}
}
TQSize DominoStyle::sizeFromContents(ContentsType t,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQSize &s,
const TQStyleOption &opt,
const TQWidget *widget) const
{
//return TDEStyle::sizeFromContents (t, ceData, elementFlags, s, opt, widget);
switch (t) {
case CT_PushButton:
{
const TQPushButton* btn = static_cast<const TQPushButton*>(widget);
int w = s.width();
int h = s.height();
if ( btn->text().isEmpty() && s.width() < 32 ) {
w += pixelMetric(PM_ButtonMargin, ceData, elementFlags, widget)*2;
h += pixelMetric(PM_ButtonMargin, ceData, elementFlags, widget)*2;
return TQSize(w, h);
}
int bm = pixelMetric(PM_ButtonMargin, ceData, elementFlags, widget);
int fw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) * 2;
w += bm + fw + 22;
h += bm + fw;
return TQSize(w, h < 26 ? 26+_buttonHeightAdjustment : h+4 );
}
case CT_ComboBox: {
int bm = pixelMetric(PM_ButtonMargin, ceData, elementFlags, widget);
int fw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) * 2;
int w = s.width();
int h = s.height();
w += bm + fw + 22;
h += bm + fw-3;
return TQSize(w, h < 26 ? 26+_buttonHeightAdjustment : h+4 );
}
case CT_TabBarTab: {
// konqi = tabbar
// other = tab control
// this is total crap but it helps to reduce the flicker in konqi.
/////////////////////
TQTabBar* tb = 0;
if(::tqt_cast<TQTabBar*>(widget))
tb = ::tqt_cast<TQTabBar*>(widget);
else
return TQSize(s.width(), s.height());
if(!strcmp(widget->name(), "tabbar") && widget->parentWidget()->isA("KonqFrameTabs")) {
TQTab* tab = opt.tab();
int count = tb->count();
int fm = tb->fontMetrics().width("about:blank");
if(tb->parentWidget()->width() <= opt.tab()->rect().x()+44+fm)
return TQSize(s.width(), s.height());
int dots = tb->fontMetrics().width(".");
if((dots*minTabLength+44)*count >= tb->width()) // 44 = frame+iconwidth
return TQSize(s.width(), s.height());
TQSize sz = TDEStyle::sizeFromContents( t, ceData, elementFlags, s, opt, widget );
TQString str;
str.fill(' ', minTabLength);
if( tab->text().isEmpty() || tab->text() == str) {
tab->setText("about:blank");
//return TQSize( fm+44, 26 );
return TQSize( fm+44, s.height());
}
return TQSize(s.width(), s.height());
}
else {
switch (tb->shape()) {
case TQTabBar::RoundedAbove:
case TQTabBar::RoundedBelow:
return TQSize( s.width(), s.height()-2 );
default:
return TQSize( s.width(), s.height() ); // triangular
}
}
}
case CT_ToolButton: {
if(dynamic_cast<const TQToolButton*>(widget)) {
if(dynamic_cast<TQTabWidget*>(widget->parentWidget())) // smaller cornerWidget
return TQSize( s.width()+9, s.height()+7 );
return TQSize( s.width()+11, s.height()+7 );
}
return TDEStyle::sizeFromContents( t, ceData, elementFlags, s, opt, widget ); // KMultiTabBar buttons
}
case CT_SpinBox: {
TQSize sz = TDEStyle::sizeFromContents( t, ceData, elementFlags, s, opt, widget );
int h = sz.height()%2 != 0 ? sz.height()+1 : sz.height();
return ( TQSize( sz.width(), h < 24 ? 24 : h) );
}
case CT_Header: {
TQSize sz = TDEStyle::sizeFromContents( t, ceData, elementFlags, s, opt, widget );
return TQSize(sz.width(), sz.height()-2);
}
case CT_PopupMenuItem: {
if (!widget || opt.isDefault())
return s;
// static const int itemHMargin = 6;
// static const int itemFrame = 7;
// static const int arrowHMargin = 6;
const TQPopupMenu *popup = dynamic_cast<const TQPopupMenu *>(widget);
TQMenuItem *mi = opt.menuItem();
int maxpmw = opt.maxIconWidth();
int w = s.width(), h = s.height(); // includes pixmap width
int cmwidth = 16;
if (mi->custom()) {
w = mi->custom()->sizeHint().width();
h = mi->custom()->sizeHint().height();
if (!mi->custom()->fullSpan() )
h += 4;
} else if (mi->widget()) {
// don't change the size in this case.
} else if (mi->isSeparator()) {
w = 20;
h = 5;
} else {
if (mi->pixmap()) {
h = TQMAX(h, mi->pixmap()->height() + 2);
} else {
h = TQMAX(h, 16 + 2 );
h = TQMAX(h, popup->fontMetrics().height() + 4 );
}
if (mi->iconSet()) {
h = TQMAX(h, mi->iconSet()->pixmap(TQIconSet::Small, TQIconSet::Normal).height() + 2);
}
}
if(_indentPopupMenuItems) {
w += itemHMargin + arrowHMargin + itemFrame*2;
}
else {
w += itemFrame*2;
if (mi->popup()) {
w += itemHMargin + arrowHMargin;
}
if (maxpmw) {
w += itemHMargin;
}
}
int t;
if (!mi->text().isNull() && (t = mi->text().find('\t')) && t >= 0 && mi->text().at(t+1) != 0) {
// space between text and accel + checkmark width (in guiStyle "Windows" isCheckable() returns always true...)
w += 18+cmwidth;
}
else
w += cmwidth;
return TQSize(w, h);
}
default:
return TDEStyle::sizeFromContents( t, ceData, elementFlags, s, opt, widget );
}
return TDEStyle::sizeFromContents( t, ceData, elementFlags, s, opt, widget );
}
int DominoStyle::styleHint( StyleHint stylehint,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQStyleOption &option,
TQStyleHintReturn* returnData,
const TQWidget *widget ) const
{
switch (stylehint) {
case SH_PopupMenu_SubMenuPopupDelay:
//return 96; // Motif-like delay...
return 250;
case SH_GroupBox_TextLabelVerticalAlignment: {
return TQt::AlignTop;
}
case SH_ScrollBar_BackgroundMode: {
return TQt::PaletteBackground;
}
case SH_ScrollBar_ScrollWhenPointerLeavesControl:
// if set to false (the default) it will also scroll when the subPage button is pressed, so no choice here (TQt 3.6)
return true;
case SH_TabBar_Alignment: {
return _centerTabs ? AlignHCenter : AlignLeft;
}
case SH_ToolBox_SelectedPageTitleBold: {
return false;
}
case SH_LineEdit_PasswordCharacter:
{
if (widget) {
const TQFontMetrics &fm = widget->fontMetrics();
if (fm.inFont(TQChar(0x25CF))) {
return 0x25CF;
} else if (fm.inFont(TQChar(0x2022))) {
return 0x2022;
}
}
return '*';
}
default:
return TDEStyle::styleHint(stylehint, ceData, elementFlags, option, returnData, widget);
}
}
TQPixmap DominoStyle::stylePixmap(StylePixmap stylepixmap,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQStyleOption& opt,
const TQWidget* widget ) const {
switch (stylepixmap) {
case SP_DockWindowCloseButton:
case SP_TitleBarCloseButton:
return TQPixmap(qembed_findImage("DockCloseButton").copy(0,0,12,12));
case SP_TitleBarMinButton:
return TQPixmap(qembed_findImage("DockbackButton").copy(0,0,12,12));
case SP_TitleBarMaxButton:
return TQPixmap(qembed_findImage("OverlapButton").copy(0,0,12,12));
case SP_TitleBarNormalButton:
return TQPixmap(qembed_findImage("ToDesktopButton").copy(0,0,12,12));
default:
return TDEStyle::stylePixmap(stylepixmap, ceData, elementFlags, opt, widget);
}
}
TQColor DominoStyle::lightenColor(const TQColor &color, const int value) const
{
if(value < 0)
return darkenColor(color, TQABS(value));
int r, g, b;
color.getRgb(&r, &g, &b);
r += value;
if(r > 255)
r =255;
g += value;
if(g > 255)
g =255;
b += value;
if(b > 255)
b =255;
return TQColor(r, g, b);
}
TQColor DominoStyle::darkenColor(const TQColor &color, const int value) const
{
if(value < 0)
return lightenColor(color, TQABS(value));
int r, g, b;
color.getRgb(&r, &g, &b);
r -= value;
if(r < 0)
r = 0;
g -= value;
if(g < 0)
g = 0;
b -= value;
if(b < 0)
b = 0;
return TQColor(r, g, b);
}
TQColor DominoStyle::dGetColor(const TQColor &color, const int value) const
{
int h, s, v;
color.getHsv(&h, &s, &v);
return (v<127)? lightenColor(color, value): darkenColor(color, value);
}
TQPixmap* DominoStyle::renderLineEditShadow(TQWidget* widget, TQRect r, TQColor bg, uint flags, bool /*reverse*/) {
bool drawLeft = flags& Draw_Left;
bool drawRight = flags& Draw_Right;
int x, y, w, h;
r.rect(&x, &y, &w, &h);
if(!drawLeft) {
x = -3;
w += 3;
}
else if(!drawRight)
w += 3;
TQRect rect(x, y, w, h);
TQColor tintColor;
TQString enabled = widget->isEnabled() ? "1" : "0";
if(!widget->isEnabled())
tintColor =bg;
else
tintColor = alphaBlendColors(TQt::black, bg, 30+35);
TQPixmap* prBgShadow;
if(!(prBgShadow = TQPixmapCache::find(TQString::number(bg.pixel(), 16)+TQString::number(tqApp->palette().active().background().pixel(), 16)+"leBgShadow"+enabled))) {
prBgShadow = new TQPixmap(4,4);
prBgShadow->fill(bg);
TQPixmap pix = tintImage(qembed_findImage("progressShadow2"), tintColor);
bitBlt(prBgShadow, 0, 0, &pix);
TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(tqApp->palette().active().background().pixel(), 16)+"leBgShadow"+enabled, prBgShadow);
}
TQPixmap* pix = new TQPixmap(rect.size());
pix->fill(bg);
if(widget->isEnabled()) {
TQPainter p(pix);
TQColor color_d = alphaBlendColors(tintColor, bg, 170);
TQColor color_m = alphaBlendColors(tintColor, bg, 85);
TQColor color_l = alphaBlendColors(tintColor, bg, 25);
p.setPen(color_d);
p.drawLine(rect.x()+2, rect.y(), rect.right()-2, rect.y());
p.setPen(color_m);
p.drawLine(rect.x()+2, rect.y()+1, rect.right()-2, rect.y()+1);
p.setPen(color_l);
p.drawLine(rect.x()+2, rect.y()+2, rect.right()-2, rect.y()+2);
p.drawLine(rect.x()+2, rect.bottom(), rect.right()-2, rect.bottom());
//p.setPen(color_l);
p.drawLine(rect.x()+1, rect.y()+3, rect.x()+1, rect.bottom()-1); // l
p.drawLine(rect.right()-1, rect.y()+3, rect.right()-1, rect.bottom()-1); // r
p.setPen(color_m);
p.drawLine(rect.x(), rect.y()+3, rect.x(), rect.bottom()-1); // l
p.drawLine(rect.right(), rect.y()+3, rect.right(), rect.bottom()-1); // r
bitBlt(pix, rect.right()-1, rect.y(), prBgShadow, 2, 0, 2, 3, TQt::CopyROP);
bitBlt(pix, rect.x(), rect.y(), prBgShadow, 0, 0, 2, 3, TQt::CopyROP);
bitBlt(pix, rect.right()-1, rect.bottom(), prBgShadow, 2, 3, 2, 1, TQt::CopyROP);
bitBlt(pix, rect.x(), rect.bottom(), prBgShadow, 0, 3, 2, 1, TQt::CopyROP);
p.end();
}
return pix;
}
TQColor DominoStyle::getGroupBoxColor(const TQWidget* w) const {
TQWidget* parent = w->parentWidget();
int tint = groupBoxSettings.customColor ? 0 : groupBoxSettings.brightness;
while(dynamic_cast<TQGroupBox*>(parent)) {
parent = parent->parentWidget();
tint += groupBoxSettings.brightness;
}
return TQColor(darkenColor(groupBoxSettings.customColor ? groupBoxSettings.color :
tqApp->palette().active().background(), tint));
}
TQPixmap* DominoStyle::createCheckMark(const TQColor color) const {
TQImage checkMark_enabled = qembed_findImage("checkmark");
TQImage checkMark_disabled = setImageOpacity(checkMark_enabled, 25);
TQImage img(32, 17, 32); // left enabled, right disabled
img.setAlphaBuffer(true);
for(int x=0; x < checkMark_enabled.width(); ++x) {
for(int y=0; y < checkMark_enabled.height(); ++y) {
img.setPixel(x, y, checkMark_enabled.pixel(x, y));
}
}
for(int x=0; x < checkMark_disabled.width(); ++x) {
for(int y=0; y < checkMark_disabled.height(); ++y) {
img.setPixel(x+16, y, checkMark_disabled.pixel(x, y));
}
}
return new TQPixmap(tintImage(img, color));
}
TQPixmap* DominoStyle::createRadioIndicator(const TQColor color) const {
TQImage dot_enabled = tintImage(qembed_findImage("rb-dot"),color);
blend(qembed_findImage("rb-dot-shadow"), dot_enabled, dot_enabled);
TQImage dot_disabled = setImageOpacity(dot_enabled, 25);
TQImage img(10, 5, 32);
img.setAlphaBuffer(true);
for(int x=0; x < dot_enabled.width(); ++x) {
for(int y=0; y < dot_enabled.height(); ++y) {
img.setPixel(x, y, dot_enabled.pixel(x, y));
}
}
for(int x=0; x < dot_disabled.width(); ++x) {
for(int y=0; y < dot_disabled.height(); ++y) {
img.setPixel(x+5, y, dot_disabled.pixel(x, y));
}
}
return new TQPixmap(img);
}
void DominoStyle::drawFocusIndicator(TQPainter *p, const TQRect &r, int flags, const TQColorGroup cg, bool /*enabled*/,
const TQPixmap* /*pixmap*/, const TQString & text, int /*len = -1*/, const TQColor& highlight, bool drawLine, bool isButton) const
{
if(drawLine) {
// p->setPen(cg.foreground());
// TQPixmap edges = tintImage(qembed_findImage("indicatorEdges"), cg.foreground());
// bitBlt(p->device(), r.x(), r.bottom()-1, &edges, 0, 0, 2, 1, TQt::CopyROP);
// bitBlt(p->device(), r.right()-2, r.bottom()-1, &edges, 2, 0, 2, 1, TQt::CopyROP);
// p->drawLine(r.x()+2, r.bottom()-1, r.right()-3, r.bottom()-1);
TQFont font = p->font();
font.setUnderline(true);
p->setFont(font);
}
else {
TQRect br = p->fontMetrics().boundingRect(r.x(), r.y(), r.width(), r.height(), flags, text);
TQPainter pixPainter;
TQPixmap textPixmap(br.width()+2, br.height()+2);
textPixmap.fill(TQColor(0,0,0));
pixPainter.begin(&textPixmap);
pixPainter.setPen(white);
pixPainter.setFont(p->font());
pixPainter.drawText( TQRect(1, 1, br.width()-1, br.height()-1), flags, text );
pixPainter.end();
DominoTQPixmap* pixm = (DominoTQPixmap*)&textPixmap;
uint height = pixm->height();
uint width = pixm->width();
pixm->data->alphapm = new TQPixmap;
DominoTQPixmap* alphapm = (DominoTQPixmap*)pixm->data->alphapm;
alphapm->data->w = width;
alphapm->data->h = height;
alphapm->data->d = 8;
alphapm->hd = XCreatePixmap(alphapm->x11Display(), RootWindow(alphapm->x11Display(), alphapm->x11Screen()), width, height, 8);
alphapm->rendhd = (HANDLE) XftDrawCreateAlpha( alphapm->x11Display(), alphapm->hd, 8 );
XImage *axi = XCreateImage(alphapm->x11Display(), (Visual *) alphapm->x11Visual(), 8, ZPixmap, 0, 0, width, height, 8, 0);
axi->data = (char *) malloc((unsigned) axi->bytes_per_line * height);
XImage* xi = XGetImage( tqt_xdisplay(), pixm->handle(), 0, 0, width, height, AllPlanes, ZPixmap );
int alpha;
float AXIS_FACTOR = 2.0;
float DIAGONAL_FACTOR = 1.0;
double alphaShadow;
int customalpha = isButton ? focusIndicatorSettings.buttonOpacity : focusIndicatorSettings.opacity;
for(uint x = 1; x < width-1; ++x) {
for(uint y = 1; y < height-1; ++y) {
alphaShadow = (tqBlue(XGetPixel(xi,x-1,y-1)) * DIAGONAL_FACTOR +
tqBlue(XGetPixel(xi,x-1,y )) * AXIS_FACTOR +
tqBlue(XGetPixel(xi,x-1,y+1)) * DIAGONAL_FACTOR +
tqBlue(XGetPixel(xi,x ,y-1)) * AXIS_FACTOR +
0 +
tqBlue(XGetPixel(xi,x ,y+1)) * AXIS_FACTOR +
tqBlue(XGetPixel(xi,x+1,y-1)) * DIAGONAL_FACTOR +
tqBlue(XGetPixel(xi,x+1,y )) * AXIS_FACTOR +
tqBlue(XGetPixel(xi,x+1,y+1)) * DIAGONAL_FACTOR) / 2.0; // / multiplicationFactor
alpha = (int)alphaShadow;
XPutPixel(axi, x, y, TQMIN(255, alpha) *customalpha >> 8);
}
}
GC gc = XCreateGC(alphapm->x11Display(), alphapm->hd, 0, 0);
XPutImage(alphapm->x11Display(), alphapm->hd, gc, axi, 0, 0, 0, 0, width, height);
textPixmap.fill(highlight);
TQRect fr = TQRect(br.x(), br.y(), TQMIN((int)width-2, r.width()) , TQMIN((int)height-2, r.height()));
if(fr.x() < r.x()) {
p->setClipRegion(r);
fr.setWidth(fr.width()+abs(fr.x())+2);
}
if(fr.isValid())
p->drawPixmap(fr.x(), fr.y(), textPixmap, 1, 1, fr.width() , fr.height());
if(fr.x() < r.x())
p->setClipping(false);
if(axi)
XDestroyImage(axi);
if(xi)
XDestroyImage(xi);
XFreeGC(alphapm->x11Display(), gc);
p->setPen(cg.foreground());
}
}
TQPixmap DominoStyle::renderOutlineIcon(const TQPixmap* icon) const
{
TQImage img = icon->convertToImage();
TQImage outlineIcon(img.width()+2, img.height()+2, 32);
outlineIcon.setAlphaBuffer(true);
unsigned int *outlineIconData = (unsigned int*) outlineIcon.bits();
uint total = outlineIcon.width()*outlineIcon.height();
for (uint current = 0 ; current < total ; ++current ) {
outlineIconData[ current ] = 0x00000000;
}
bitBlt(&outlineIcon, 0, 0, &img);
bitBlt(&outlineIcon, 1, 0, &img);
bitBlt(&outlineIcon, 2, 0, &img);
bitBlt(&outlineIcon, 0, 1, &img);
bitBlt(&outlineIcon, 2, 1, &img);
bitBlt(&outlineIcon, 0, 2, &img);
bitBlt(&outlineIcon, 1, 2, &img);
bitBlt(&outlineIcon, 2, 2, &img);
uint customalpha = focusIndicatorSettings.buttonOpacity;
for (uint current = 0 ; current < total ; ++current ) {
outlineIconData[ current ] = tqRgba( focusIndicatorSettings.buttonColor.red(), focusIndicatorSettings.buttonColor.green(), focusIndicatorSettings.buttonColor.blue(), tqAlpha(outlineIconData[ current ]) * customalpha >> 8);
}
return TQPixmap(outlineIcon);
}
void DominoStyle::drawItem( TQPainter *p, const TQRect &r,
int flags, const TQColorGroup &g, bool enabled,
const TQPixmap *pixmap, const TQString& text, int len,
const TQColor* penColor ) const
{
dominoDrawItem(p, r, flags, g, enabled, pixmap, text, len, penColor, false);
}
void DominoStyle::dominoDrawItem( TQPainter *p, const TQRect &r,
int flags, const TQColorGroup &g, bool enabled,
const TQPixmap *pixmap, const TQString& text, int len,
const TQColor* penColor, bool buttonTextEffect ) const
{
int x = r.x();
int y = r.y();
int w = r.width();
int h = r.height();
p->setPen( penColor?*penColor:g.foreground() );
if ( pixmap ) {
TQPixmap pm( *pixmap );
bool clip = (flags & TQt::DontClip) == 0;
if ( clip ) {
if ( pm.width() < w && pm.height() < h ) {
clip = FALSE;
} else {
p->save();
TQRegion cr = TQRect(x, y, w, h);
if (p->hasClipping())
cr &= p->clipRegion(TQPainter::CoordPainter);
p->setClipRegion(cr);
}
}
if ( (flags & TQt::AlignVCenter) == TQt::AlignVCenter )
y += h/2 - pm.height()/2;
else if ( (flags & TQt::AlignBottom) == TQt::AlignBottom)
y += h - pm.height();
if ( (flags & TQt::AlignRight) == TQt::AlignRight )
x += w - pm.width();
else if ( (flags & TQt::AlignHCenter) == TQt::AlignHCenter )
x += w/2 - pm.width()/2;
else if ( ((flags & TQt::AlignLeft) != TQt::AlignLeft) && TQApplication::reverseLayout() ) // AlignAuto && rightToLeft
x += w - pm.width();
p->drawPixmap( x, y, pm );
if ( clip )
p->restore();
}
else if ( !text.isNull() ) {
if(textEffectSettings.mode > 1 || buttonTextEffect) { // 0=none, 1=only buttons, 2=everywhere
TQRect br = p->fontMetrics().boundingRect(x, y, w, h, flags, text);
TQPainter pixPainter;
TQPixmap textPixmap(br.width(), br.height());
textPixmap.fill(TQColor(0,0,0));
pixPainter.begin(&textPixmap);
pixPainter.setPen(white);
pixPainter.setFont(p->font());
pixPainter.drawText( TQRect(0,0,br.width(), br.height()), flags, text );
pixPainter.end();
DominoTQPixmap* pixm = (DominoTQPixmap*)&textPixmap;
uint height = pixm->height();
uint width = pixm->width();
pixm->data->alphapm = new TQPixmap;
DominoTQPixmap* alphapm = (DominoTQPixmap*)pixm->data->alphapm;
alphapm->data->w = width;
alphapm->data->h = height;
alphapm->data->d = 8;
alphapm->hd = XCreatePixmap(alphapm->x11Display(), RootWindow(alphapm->x11Display(), alphapm->x11Screen()), width, height, 8);
alphapm->rendhd = (HANDLE) XftDrawCreateAlpha( alphapm->x11Display(), alphapm->hd, 8 );
XImage *axi = XCreateImage(alphapm->x11Display(), (Visual *) alphapm->x11Visual(), 8, ZPixmap, 0, 0, width, height, 8, 0);
axi->data = (char *) malloc((unsigned) axi->bytes_per_line * height);
XImage* xi = XGetImage( tqt_xdisplay(), pixm->handle(), 0, 0, width, height, AllPlanes, ZPixmap );
int alpha;
int customalpha = buttonTextEffect ? textEffectSettings.buttonOpacity : textEffectSettings.opacity;
for(uint y = 0; y < height; ++y) {
for(uint x = 0; x < width; ++x) {
alpha = (XGetPixel(xi, x, y)& 0xff ) * customalpha >> 8; // blue as alpha
XPutPixel(axi, x, y, alpha);
}
}
GC gc = XCreateGC(alphapm->x11Display(), alphapm->hd, 0, 0);
XPutImage(alphapm->x11Display(), alphapm->hd, gc, axi, 0, 0, 0, 0, width, height);
if(buttonTextEffect) {
textPixmap.fill(textEffectSettings.buttonColor);
TQRect tr = TQRect(br.x()+textEffectSettings.buttonPos.x(), br.y()+textEffectSettings.buttonPos.y(), r.width(), r.height());
if(tr.x() < r.x()) {
p->setClipRegion(r);
tr.setWidth(tr.width()+r.x()+abs(tr.x()));
}
p->drawPixmap(tr.x(), tr.y(), textPixmap, 0, 0, tr.width(), tr.height());
if(tr.x() < r.x())
p->setClipping(false);
}
else {
textPixmap.fill(textEffectSettings.color);
TQRect tr = TQRect(br.x()+textEffectSettings.pos.x(), br.y()+textEffectSettings.pos.y(), r.width(), r.height());
if(tr.x() < r.x()) {
p->setClipRegion(r);
tr.setWidth(tr.width()+r.x()+abs(tr.x()));
}
p->drawPixmap(tr.x(), tr.y(), textPixmap, 0, 0, tr.width(), tr.height());
if(tr.x() < r.x())
p->setClipping(false);
}
if(axi)
XDestroyImage(axi);
if(xi)
XDestroyImage(xi);
XFreeGC(alphapm->x11Display(), gc);
}
if(!enabled)
p->setPen(g.text());
p->drawText( r.x(), r.y(), r.width(), r.height(), flags, text, len );
}
}
TQWidget::BackgroundOrigin DominoStyle::setPixmapOrigin(TQWidget::BackgroundOrigin origin)
{
switch(origin) {
case TQWidget::WidgetOrigin:
return TQWidget::ParentOrigin;
case TQWidget::ParentOrigin:
return TQWidget::AncestorOrigin;
default:
return origin;
break;
}
}
void DominoStyle::setDominoButtonPalette(TQWidget* widget, PaletteTyp type) {
TQPalette pal;
switch(type) {
case Palette_Application:
pal = tqApp->palette();
break;
case Palette_Parent:
pal = widget->parentWidget()->palette();
break;
case Palette_Widget:
pal = widget->palette();
default:
break;
}
int h, s, v;
pal.active().buttonText().hsv(&h, &s, &v);
TQColor disabledColor = alphaBlendColors(pal.active().buttonText(), v < 127 ? white : black, 150);
pal.setColor(TQPalette::Disabled, TQColorGroup::Text, disabledColor);
widget->setPalette(pal);
}
void DominoStyle::updateTabWidgetFrame() {
TQTabWidget* tw = dynamic_cast<TQTabWidget*>(sender()->parent());
TQWidget* w = tw ? tw->currentPage() : 0;
if(!w)
return;
TQFrame* f = dynamic_cast<TQFrame*>(w->parentWidget());
if(f) {
TQRect r = f->rect();
if(tw->tabPosition() == TQTabWidget::Top)
r= TQRect(r.x(), r.y(), r.width(), 3);
else
r= TQRect(r.x(), r.y()+r.height()-4, r.width(), 2);
f->repaint(r, false);
}
}
TQPixmap DominoStyle::disableIcon(const TQPixmap* icon) const {
TQImage img = icon->convertToImage();
uint pixels = img.depth() > 8 ? img.width()*img.height() : img.numColors();
uint *data = img.depth() > 8 ? (unsigned int *)img.bits() : (unsigned int *)img.colorTable();
uint val, i;
for(i=0; i < pixels; ++i){
val = tqGray(data[i]);
data[i] = tqRgba(val, val, val, tqAlpha(data[i]));
}
img = setImageOpacity(img, 50);
return TQPixmap(img);
}
// same as in renderSurface() but with darker colors
void DominoStyle::renderTabSeparator(TQPainter *p, const TQRect &r, const TQColor buttonColor, bool tabAbove) const {
const DSurface* ds = tabAbove ? &tabTopSurface : &tabBottomSurface;
int top = r.y()+r.height()*ds->g1Top/100;
int bottom = r.height()*ds->g1Bottom/100;
int top2 = r.y()+r.height()*ds->g2Top/100;
int bottom2 = r.height()*ds->g2Bottom/100-top2;
TQColor c1;
TQColor c2;
TQColor c3;
TQColor c4;
TQColor bg;
if(buttonColor != tqApp->palette().active().button()) {
c1 = alphaBlendColors(buttonColor, ds->g1Color1, 127);
c2 = alphaBlendColors(buttonColor, ds->g1Color2, 127);
c3 = alphaBlendColors(buttonColor, ds->g2Color1, 127);
c4 = alphaBlendColors(buttonColor, ds->g2Color2, 127);
bg = alphaBlendColors(buttonColor, ds->background, 127);
}
else {
c1 = ds->g1Color1;
c2 = ds->g1Color2;
c3 = ds->g2Color1;
c4 = ds->g2Color2;
bg = ds->background;
}
const int alpha = 35; // 55, 25
p->fillRect(r, alphaBlendColors(TQColor(0,0,0),bg , alpha));
switch(ds->numGradients) {
case 1: {
c1 = alphaBlendColors(TQColor(0,0,0), c1, alpha);
c2 = alphaBlendColors(TQColor(0,0,0), c2, alpha);
renderGradient(p, TQRect(r.x(), top, r.width(), bottom), c1, c2, true);
break;
}
case 2: {
c1 = alphaBlendColors(TQColor(0,0,0), c1, alpha);
c2 = alphaBlendColors(TQColor(0,0,0), c2, alpha);
c3 = alphaBlendColors(TQColor(0,0,0), c3, alpha);
c4 = alphaBlendColors(TQColor(0,0,0), c4, alpha);
renderGradient(p, TQRect(r.x(), top, r.width(), bottom), c1, c2, true);
renderGradient(p, TQRect(r.x(), top2, r.width(), bottom2), c3, c4, true);
}
default:
break;
}
}
void DominoStyle::renderGroupBox(TQObject *obj, TQEvent *ev) {
TQGroupBox* gb = dynamic_cast<TQGroupBox*>(obj);
bool paintEvent = ev->type() == TQEvent::Paint;
TQRect r = gb->rect();
if(gb->isFlat()) {
TQString title = gb->title();
int titleHeight = gb->fontMetrics().height();
int titleWidth = gb->fontMetrics().width(title);
if(title.contains("&"))
titleWidth -= gb->fontMetrics().width("&");
TQPainter p(gb);
// p.setPen(tqApp->palette().active().background().dark(120));
p.setPen(alphaBlendColors(gb->paletteForegroundColor(), gb->paletteBackgroundColor(), 40));
p.drawLine(0, titleHeight/2-2, r.width()/2-titleWidth/2-4, titleHeight/2-2);
p.drawLine(r.width()/2+titleWidth/2+4, titleHeight/2-2, r.width(), titleHeight/2-2);
TQColorGroup cg = gb->parentWidget()->colorGroup();
dominoDrawItem(&p, TQRect(r.width()/2-titleWidth/2, -1, r.width(), titleHeight), ShowPrefix, cg, Style_Enabled, 0, title, -1, &cg.foreground(), false);
p.setPen(cg.foreground());
((DominoTQGroupBox*)gb)->drawContents(&p);
}
else {
TQString title = gb->title();
int titleHeight = gb->fontMetrics().height();
TQColor outsideColor = gb->parentWidget() ? gb->parentWidget()->paletteBackgroundColor() : gb->paletteBackgroundColor();
TQColor insideColor = groupBoxSettings.tintBackground ? getGroupBoxColor(gb) : gb->paletteBackgroundColor();
bool pixmapExists = groupBoxPixmaps.contains(gb);
if(paintEvent && pixmapExists) {
TQPainter p;
if(!title.isEmpty()) {
int titleWidth = gb->fontMetrics().width(title);
if(title.contains("&"))
titleWidth -= gb->fontMetrics().width("&");
TQPainter p(groupBoxPixmaps[gb]);
TQRect titleRect = TQRect((r.width()-titleWidth)/2, -1, r.width(), titleHeight);
p.fillRect(titleRect, outsideColor);
dominoDrawItem(&p, titleRect, ShowPrefix, gb->colorGroup(), true, 0, title, -1, &gb->foregroundColor(), false);
p.end();
}
// only needed for the case if a disabled groupbox gets disabled for a second time.
// TQt3 just changes the palette to disabled without checking if it already is (and removes here the "hidden" background pixmap)
bitBlt(gb, 0, 0, groupBoxPixmaps[gb]);
p.begin(gb);
((DominoTQGroupBox*)gb)->drawContents(&p);
return;
}
bool isCheckable = gb->isCheckable();
int x = r.x();
int y = isCheckable ? r.y()+titleHeight+5 : (title.isNull() || title.isEmpty()) ? TQMAX(r.y()-1, 0) : r.y()+titleHeight-1;
int w = r.width();
int h = r.height();
// if(y+16 > h || 16 > w) // don't overlap the pixmaps
// return;
TQPixmap buffer(r.width(), r.height());
TQPainter p(&buffer);
p.fillRect(TQRect(0, 0, w, y), outsideColor);
p.fillRect(TQRect(x+3, y+3, w-6, h-6-y), insideColor);
TQPixmap* gbPix = 0;
if(!(gbPix = TQPixmapCache::find(TQString::number(outsideColor.pixel(), 16)+TQString::number(insideColor.pixel(), 16)+"groupbox"))) {
gbPix = new TQPixmap(16, 16);
gbPix->fill(outsideColor);
TQPixmap groupBoxPixMask = qembed_findImage("groupBoxMask");
groupBoxPixMask.fill(insideColor);
bitBlt(gbPix, 0, 0, &groupBoxPixMask);
TQPixmap groupBoxPix = qembed_findImage("groupBox");
bitBlt(gbPix, 0, 0, &groupBoxPix);
TQPixmapCache::insert(TQString::number(outsideColor.pixel(), 16)+TQString::number(insideColor.pixel(), 16)+"groupbox", gbPix);
}
bitBlt(&buffer, 0, y, gbPix, 0, 0, 8, 8);
bitBlt(&buffer, w-8, y, gbPix, 8, 0, 8, 8);
bitBlt(&buffer, 0, h-8, gbPix, 0, 8, 8, 8);
bitBlt(&buffer, w-8, h-8, gbPix, 8, 8, 8, 8 );
// top
TQColor c1 = alphaBlendColors(TQColor(255,255,255), outsideColor, 25);
TQColor c2 = alphaBlendColors(TQColor(0,0,0), insideColor, 70);
TQColor c3 = alphaBlendColors(TQColor(0,0,0), insideColor, 30);
// left + right
TQColor c4 = alphaBlendColors(TQColor(255,255,255), outsideColor, 40);
TQColor c5 = c3; //alphaBlendColors(TQColor(0,0,0), insideColor, 30);
TQColor c6 = alphaBlendColors(TQColor(0,0,0), insideColor, 4);
// bottom
TQColor c7 = alphaBlendColors(TQColor(6,6,6), insideColor, 25);
TQColor c8 = alphaBlendColors(TQColor(255,255,255), outsideColor, 79);
TQColor c9 = alphaBlendColors(TQColor(255,255,255), outsideColor, 30);
// top
p.setPen(c1);
p.drawLine(r.left()+8, y, r.right()-8, y);
p.setPen(c2);
p.drawLine(r.left()+8, y+1, r.right()-8, y+1);
p.setPen(c3);
p.drawLine(r.left()+8, y+2, r.right()-8, y+2);
// bottom
p.setPen(c7);
p.drawLine(r.left()+8, r.bottom()-2, r.right()-8, r.bottom()-2);
p.setPen(c8);
p.drawLine(r.left()+8, r.bottom()-1, r.right()-8, r.bottom()-1);
p.setPen(c9);
p.drawLine(r.left()+8, r.bottom(), r.right()-8, r.bottom());
// left / right
p.setPen(c4);
p.drawLine(r.left(), y+8, r.left(), r.bottom()-8);
p.drawLine(r.right(), y+8, r.right(), r.bottom()-8);
p.setPen(c5);
p.drawLine(r.left()+1, y+8, r.left()+1, r.bottom()-8);
p.drawLine(r.right()-1, y+8, r.right()-1, r.bottom()-8);
p.setPen(c6);
p.drawLine(r.left()+2, y+8, r.left()+2, r.bottom()-8);
p.drawLine(r.right()-2, y+8, r.right()-2, r.bottom()-8);
p.end();
if(ev->type() == TQEvent::Resize)
XSetWindowBackgroundPixmap( gb->x11Display(), gb->winId(), buffer.handle());
else if(paintEvent) {
if(!title.isEmpty()) {
int titleWidth = gb->fontMetrics().width(title);
if(title.contains("&"))
titleWidth -= gb->fontMetrics().width("&");
p.begin(&buffer);
TQRect titleRect = TQRect((r.width()-titleWidth)/2, -1, r.width(), titleHeight);
p.fillRect(titleRect, outsideColor);
dominoDrawItem(&p, titleRect, ShowPrefix, gb->colorGroup(), true, 0, title, -1, &gb->foregroundColor(), false);
p.end();
}
bitBlt(gb, 0, 0, &buffer);
p.begin(gb);
((DominoTQGroupBox*)gb)->drawContents(&p);
}
if(pixmapExists)
delete groupBoxPixmaps[gb];
groupBoxPixmaps[gb] = new TQPixmap(buffer);
}
}
void DominoStyle::spinBoxValueChanged(int value) {
TQSpinBox* sb = (TQSpinBox*)sender();
if(spinWidgetDown) {
spinWidgetDown = !(value == sb->maxValue() || value == sb->minValue());
if(!spinWidgetDown) {
// if we repaint directly, the last mousePressEvent wouldn't be down
TQTimer::singleShot( 200, ((DominoTQSpinBox*)sb)->editor()->parentWidget(), TQ_SLOT(repaint()) );
}
}
}
uint DominoStyle::preMultiplyColor(const uint &c) const {
XRenderColor clr;
uint color = c << 8 | tqAlpha(c);
uint red = (color >> 24) & 0xff;
uint green = (color >> 16) & 0xff;
uint blue = (color >> 8) & 0xff;
uint alpha = (color >> 0) & 0xff;
red = red * alpha / 255;
green = green * alpha / 255;
blue = blue * alpha / 255;
clr.red = (red << 8) + red;
clr.green = (green << 8) + green;
clr.blue = (blue << 8) + blue;
clr.alpha = (alpha << 8) + alpha;
return tqRgba(clr.red, clr.green, clr.blue, clr.alpha);
}
void DominoStyle::toolPopupPressed() {
TQToolButton* tb = (TQToolButton*)sender();
if(!tb )
return;
if(tb->popup() && tb->isEnabled() && tb->isDown()) {
popupButton = tb;
connect(popupTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(popupToolMenu()));
popupTimer->start(600, true);
}
}
void DominoStyle::popupToolMenu() {
if(!popupButton )
return;
if(popupButton->popup() && !popupButton->popup()->isVisible() && popupButton->isEnabled() && popupButton->isDown()) {
popupButton->openPopup();
}
popupButton = 0;
}
void DominoStyle::toolPopupReleased() {
if(!popupButton)
return;
if(popupTimer->isActive()) {
popupTimer->stop();
popupButton = 0;
}
}
#include "eventfilter.cpp"
#include "domino.moc"
View Git Blame Copy Permalink