|
|
/*
|
|
|
*
|
|
|
* TDEStyle
|
|
|
* Copyright (C) 2001-2002 Karol Szwed <gallium@kde.org>
|
|
|
*
|
|
|
* TQWindowsStyle CC_ListView and style images were kindly donated by TrollTech,
|
|
|
* Copyright (C) 1998-2000 TrollTech AS.
|
|
|
*
|
|
|
* Many thanks to Bradley T. Hughes for the 3 button scrollbar code.
|
|
|
*
|
|
|
* 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 Library General Public License
|
|
|
* along with this library; see the file COPYING.LIB. If not, write to
|
|
|
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
|
* Boston, MA 02110-1301, USA.
|
|
|
*/
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
#include "config.h"
|
|
|
#endif
|
|
|
|
|
|
#include "tdestyle.h"
|
|
|
|
|
|
#include <tqapplication.h>
|
|
|
#include <tqbitmap.h>
|
|
|
#include <tqmetaobject.h>
|
|
|
#include <tqcleanuphandler.h>
|
|
|
#include <tqmap.h>
|
|
|
#include <tqimage.h>
|
|
|
#include <tqlistview.h>
|
|
|
#include <tqmenubar.h>
|
|
|
#include <tqpainter.h>
|
|
|
#include <tqpixmap.h>
|
|
|
#include <tqpopupmenu.h>
|
|
|
#include <tqprogressbar.h>
|
|
|
#include <tqscrollbar.h>
|
|
|
#include <tqsettings.h>
|
|
|
#include <tqslider.h>
|
|
|
#include <tqstylefactory.h>
|
|
|
#include <tqtabbar.h>
|
|
|
#include <tqtoolbar.h>
|
|
|
#include <tqframe.h>
|
|
|
|
|
|
#include <kpixmap.h>
|
|
|
#include <kpixmapeffect.h>
|
|
|
#include <kimageeffect.h>
|
|
|
|
|
|
#ifdef Q_WS_X11
|
|
|
# include <X11/Xlib.h>
|
|
|
# ifdef HAVE_XRENDER
|
|
|
# include <X11/extensions/Xrender.h> // schroder
|
|
|
extern bool tqt_use_xrender;
|
|
|
# endif
|
|
|
#else
|
|
|
#undef HAVE_XRENDER
|
|
|
#endif
|
|
|
|
|
|
#ifdef HAVE_XCOMPOSITE
|
|
|
#include <X11/extensions/Xrender.h>
|
|
|
#include <X11/extensions/Xcomposite.h>
|
|
|
#include <dlfcn.h>
|
|
|
#endif
|
|
|
|
|
|
#include <limits.h>
|
|
|
|
|
|
namespace
|
|
|
{
|
|
|
// INTERNAL
|
|
|
enum TransparencyEngine {
|
|
|
Disabled = 0,
|
|
|
SoftwareTint,
|
|
|
SoftwareBlend,
|
|
|
XRender
|
|
|
};
|
|
|
|
|
|
// Drop Shadow
|
|
|
struct ShadowElements {
|
|
|
TQWidget* w1;
|
|
|
TQWidget* w2;
|
|
|
};
|
|
|
typedef TQMap<const TQWidget*,ShadowElements> ShadowMap;
|
|
|
static ShadowMap *_shadowMap = 0;
|
|
|
TQSingleCleanupHandler<ShadowMap> cleanupShadowMap;
|
|
|
ShadowMap &shadowMap() {
|
|
|
if ( !_shadowMap ) {
|
|
|
_shadowMap = new ShadowMap;
|
|
|
cleanupShadowMap.set( &_shadowMap );
|
|
|
}
|
|
|
return *_shadowMap;
|
|
|
}
|
|
|
|
|
|
|
|
|
// DO NOT ASK ME HOW I MADE THESE TABLES!
|
|
|
// (I probably won't remember anyway ;)
|
|
|
const double top_right_corner[16] =
|
|
|
{ 0.949, 0.965, 0.980, 0.992,
|
|
|
0.851, 0.890, 0.945, 0.980,
|
|
|
0.706, 0.780, 0.890, 0.960,
|
|
|
0.608, 0.706, 0.851, 0.949 };
|
|
|
|
|
|
const double bottom_right_corner[16] =
|
|
|
{ 0.608, 0.706, 0.851, 0.949,
|
|
|
0.706, 0.780, 0.890, 0.960,
|
|
|
0.851, 0.890, 0.945, 0.980,
|
|
|
0.949, 0.965, 0.980, 0.992 };
|
|
|
|
|
|
const double bottom_left_corner[16] =
|
|
|
{ 0.949, 0.851, 0.706, 0.608,
|
|
|
0.965, 0.890, 0.780, 0.706,
|
|
|
0.980, 0.945, 0.890, 0.851,
|
|
|
0.992, 0.980, 0.960, 0.949 };
|
|
|
|
|
|
const double shadow_strip[4] =
|
|
|
{ 0.565, 0.675, 0.835, 0.945 };
|
|
|
|
|
|
static bool useDropShadow(TQWidget* w)
|
|
|
{
|
|
|
return w && w->metaObject() &&
|
|
|
w->metaObject()->findProperty("TDEStyleMenuDropShadow") != -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
namespace
|
|
|
{
|
|
|
class TransparencyHandler : public TQObject
|
|
|
{
|
|
|
public:
|
|
|
TransparencyHandler(TDEStyle* style, TransparencyEngine tEngine,
|
|
|
float menuOpacity, bool useDropShadow);
|
|
|
~TransparencyHandler();
|
|
|
bool eventFilter(TQObject* object, TQEvent* event);
|
|
|
|
|
|
protected:
|
|
|
void blendToColor(const TQColor &col);
|
|
|
void blendToPixmap(const TQColorGroup &cg, const TQWidget* p);
|
|
|
#ifdef HAVE_XRENDER
|
|
|
void XRenderBlendToPixmap(const TQWidget* p);
|
|
|
#endif
|
|
|
bool haveX11RGBASupport();
|
|
|
TQImage handleRealAlpha(TQImage);
|
|
|
void createShadowWindows(const TQWidget* p);
|
|
|
void removeShadowWindows(const TQWidget* p);
|
|
|
void rightShadow(TQImage& dst);
|
|
|
void bottomShadow(TQImage& dst);
|
|
|
private:
|
|
|
bool dropShadow;
|
|
|
float opacity;
|
|
|
TQPixmap pix;
|
|
|
TDEStyle* kstyle;
|
|
|
TransparencyEngine te;
|
|
|
};
|
|
|
} // namespace
|
|
|
|
|
|
struct TDEStylePrivate
|
|
|
{
|
|
|
bool highcolor : 1;
|
|
|
bool useFilledFrameWorkaround : 1;
|
|
|
bool etchDisabledText : 1;
|
|
|
bool scrollablePopupmenus : 1;
|
|
|
bool autoHideAccelerators : 1;
|
|
|
bool menuAltKeyNavigation : 1;
|
|
|
bool menuDropShadow : 1;
|
|
|
bool sloppySubMenus : 1;
|
|
|
bool semiTransparentRubberband : 1;
|
|
|
int popupMenuDelay;
|
|
|
float menuOpacity;
|
|
|
|
|
|
TransparencyEngine transparencyEngine;
|
|
|
TDEStyle::TDEStyleScrollBarType scrollbarType;
|
|
|
TransparencyHandler* menuHandler;
|
|
|
TDEStyle::TDEStyleFlags flags;
|
|
|
|
|
|
//For KPE_ListViewBranch
|
|
|
TQBitmap *verticalLine;
|
|
|
TQBitmap *horizontalLine;
|
|
|
};
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
TDEStyle::TDEStyle( TDEStyleFlags flags, TDEStyleScrollBarType sbtype )
|
|
|
: TQCommonStyle(), d(new TDEStylePrivate)
|
|
|
{
|
|
|
d->flags = flags;
|
|
|
bool useMenuTransparency = (flags & AllowMenuTransparency);
|
|
|
d->useFilledFrameWorkaround = (flags & FilledFrameWorkaround);
|
|
|
d->scrollbarType = sbtype;
|
|
|
d->highcolor = TQPixmap::defaultDepth() > 8;
|
|
|
|
|
|
// Read style settings
|
|
|
TQSettings settings;
|
|
|
d->popupMenuDelay = settings.readNumEntry ("/TDEStyle/Settings/PopupMenuDelay", 256);
|
|
|
d->sloppySubMenus = settings.readBoolEntry("/TDEStyle/Settings/SloppySubMenus", false);
|
|
|
d->etchDisabledText = settings.readBoolEntry("/TDEStyle/Settings/EtchDisabledText", true);
|
|
|
d->menuAltKeyNavigation = settings.readBoolEntry("/TDEStyle/Settings/MenuAltKeyNavigation", true);
|
|
|
d->scrollablePopupmenus = settings.readBoolEntry("/TDEStyle/Settings/ScrollablePopupMenus", false);
|
|
|
d->autoHideAccelerators = settings.readBoolEntry("/TDEStyle/Settings/AutoHideAccelerators", false);
|
|
|
d->menuDropShadow = settings.readBoolEntry("/TDEStyle/Settings/MenuDropShadow", false);
|
|
|
d->semiTransparentRubberband = settings.readBoolEntry("/TDEStyle/Settings/SemiTransparentRubberband", false);
|
|
|
d->menuHandler = NULL;
|
|
|
|
|
|
if (useMenuTransparency) {
|
|
|
TQString effectEngine = settings.readEntry("/TDEStyle/Settings/MenuTransparencyEngine", "Disabled");
|
|
|
|
|
|
#ifdef HAVE_XRENDER
|
|
|
if (effectEngine == "XRender")
|
|
|
d->transparencyEngine = XRender;
|
|
|
#else
|
|
|
if (effectEngine == "XRender")
|
|
|
d->transparencyEngine = SoftwareBlend;
|
|
|
#endif
|
|
|
else if (effectEngine == "SoftwareBlend")
|
|
|
d->transparencyEngine = SoftwareBlend;
|
|
|
else if (effectEngine == "SoftwareTint")
|
|
|
d->transparencyEngine = SoftwareTint;
|
|
|
else
|
|
|
d->transparencyEngine = Disabled;
|
|
|
|
|
|
if (d->transparencyEngine != Disabled) {
|
|
|
// Create an instance of the menu transparency handler
|
|
|
d->menuOpacity = settings.readDoubleEntry("/TDEStyle/Settings/MenuOpacity", 0.90);
|
|
|
d->menuHandler = new TransparencyHandler(this, d->transparencyEngine,
|
|
|
d->menuOpacity, d->menuDropShadow);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
d->verticalLine = 0;
|
|
|
d->horizontalLine = 0;
|
|
|
|
|
|
// Create a transparency handler if only drop shadows are enabled.
|
|
|
if (!d->menuHandler && d->menuDropShadow)
|
|
|
d->menuHandler = new TransparencyHandler(this, Disabled, 1.0, d->menuDropShadow);
|
|
|
}
|
|
|
|
|
|
|
|
|
TDEStyle::~TDEStyle()
|
|
|
{
|
|
|
delete d->verticalLine;
|
|
|
delete d->horizontalLine;
|
|
|
|
|
|
delete d->menuHandler;
|
|
|
|
|
|
d->menuHandler = NULL;
|
|
|
delete d;
|
|
|
}
|
|
|
|
|
|
|
|
|
TQString TDEStyle::defaultStyle()
|
|
|
{
|
|
|
if (TQPixmap::defaultDepth() > 8)
|
|
|
return TQString("plastik");
|
|
|
else
|
|
|
return TQString("light, 3rd revision");
|
|
|
}
|
|
|
|
|
|
void TDEStyle::polish( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr )
|
|
|
{
|
|
|
if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
|
|
|
TQWidget* widget = reinterpret_cast<TQWidget*>(ptr);
|
|
|
if ( d->useFilledFrameWorkaround )
|
|
|
{
|
|
|
if ( TQFrame *frame = ::tqqt_cast< TQFrame* >( widget ) ) {
|
|
|
TQFrame::Shape shape = frame->frameShape();
|
|
|
if (shape == TQFrame::ToolBarPanel || shape == TQFrame::MenuBarPanel)
|
|
|
widget->installEventFilter(this);
|
|
|
}
|
|
|
}
|
|
|
if (widget->isTopLevel())
|
|
|
{
|
|
|
if (!d->menuHandler && useDropShadow(widget))
|
|
|
d->menuHandler = new TransparencyHandler(this, Disabled, 1.0, false);
|
|
|
|
|
|
if (d->menuHandler && useDropShadow(widget))
|
|
|
widget->installEventFilter(d->menuHandler);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
void TDEStyle::unPolish( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr )
|
|
|
{
|
|
|
if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
|
|
|
TQWidget* widget = reinterpret_cast<TQWidget*>(ptr);
|
|
|
if ( d->useFilledFrameWorkaround )
|
|
|
{
|
|
|
if ( TQFrame *frame = ::tqqt_cast< TQFrame* >( widget ) ) {
|
|
|
TQFrame::Shape shape = frame->frameShape();
|
|
|
if (shape == TQFrame::ToolBarPanel || shape == TQFrame::MenuBarPanel)
|
|
|
widget->removeEventFilter(this);
|
|
|
}
|
|
|
}
|
|
|
if (widget->isTopLevel() && d->menuHandler && useDropShadow(widget))
|
|
|
widget->removeEventFilter(d->menuHandler);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
// Style changes (should) always re-polish popups.
|
|
|
void TDEStyle::polishPopupMenu( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr )
|
|
|
{
|
|
|
if ( !(ceData.windowState & WState_Polished ) ) {
|
|
|
widgetActionRequest(ceData, elementFlags, ptr, WAR_SetCheckable);
|
|
|
}
|
|
|
|
|
|
if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
|
|
|
TQWidget* widget = reinterpret_cast<TQWidget*>(ptr);
|
|
|
TQPopupMenu *p = dynamic_cast<TQPopupMenu*>(widget);
|
|
|
if (p) {
|
|
|
// Install transparency handler if the effect is enabled.
|
|
|
if ( d->menuHandler && (strcmp(p->name(), "tear off menu") != 0)) {
|
|
|
p->installEventFilter(d->menuHandler);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
// TDEStyle extensions
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
|
|
void TDEStyle::setScrollBarType(TDEStyleScrollBarType sbtype)
|
|
|
{
|
|
|
d->scrollbarType = sbtype;
|
|
|
}
|
|
|
|
|
|
TDEStyle::TDEStyleFlags TDEStyle::styleFlags() const
|
|
|
{
|
|
|
return d->flags;
|
|
|
}
|
|
|
|
|
|
void TDEStyle::renderMenuBlendPixmap( KPixmap &pix, const TQColorGroup &cg,
|
|
|
const TQPopupMenu* /* popup */ ) const
|
|
|
{
|
|
|
pix.fill(cg.button()); // Just tint as the default behavior
|
|
|
}
|
|
|
|
|
|
void TDEStyle::drawTDEStylePrimitive( TDEStylePrimitive kpe,
|
|
|
TQPainter* p,
|
|
|
const TQWidget* widget,
|
|
|
const TQRect &r,
|
|
|
const TQColorGroup &cg,
|
|
|
SFlags flags,
|
|
|
const TQStyleOption &opt ) const
|
|
|
{
|
|
|
TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption());
|
|
|
drawTDEStylePrimitive(kpe, p, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), r, cg, flags, opt);
|
|
|
}
|
|
|
|
|
|
void TDEStyle::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
|
|
|
{
|
|
|
switch( kpe )
|
|
|
{
|
|
|
// Dock / Toolbar / General handles.
|
|
|
// ---------------------------------
|
|
|
|
|
|
case KPE_DockWindowHandle: {
|
|
|
|
|
|
// Draws a nice DockWindow handle including the dock title.
|
|
|
TQWidget* wid = const_cast<TQWidget*>(widget);
|
|
|
bool horizontal = flags & Style_Horizontal;
|
|
|
int x,y,w,h,x2,y2;
|
|
|
|
|
|
r.rect( &x, &y, &w, &h );
|
|
|
if ((w <= 2) || (h <= 2)) {
|
|
|
p->fillRect(r, cg.highlight());
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
|
|
|
x2 = x + w - 1;
|
|
|
y2 = y + h - 1;
|
|
|
|
|
|
TQFont fnt;
|
|
|
fnt = TQApplication::font(wid);
|
|
|
fnt.setPointSize( fnt.pointSize()-2 );
|
|
|
|
|
|
// Draw the item on an off-screen pixmap
|
|
|
// to preserve Xft antialiasing for
|
|
|
// vertically oriented handles.
|
|
|
TQPixmap pix;
|
|
|
if (horizontal)
|
|
|
pix.resize( h-2, w-2 );
|
|
|
else
|
|
|
pix.resize( w-2, h-2 );
|
|
|
|
|
|
TQString title = wid->parentWidget()->caption();
|
|
|
TQPainter p2;
|
|
|
p2.begin(&pix);
|
|
|
p2.fillRect(pix.rect(), cg.brush(TQColorGroup::Highlight));
|
|
|
p2.setPen(cg.highlightedText());
|
|
|
p2.setFont(fnt);
|
|
|
p2.drawText(pix.rect(), AlignCenter, title);
|
|
|
p2.end();
|
|
|
|
|
|
// Draw a sunken bevel
|
|
|
p->setPen(cg.dark());
|
|
|
p->drawLine(x, y, x2, y);
|
|
|
p->drawLine(x, y, x, y2);
|
|
|
p->setPen(cg.light());
|
|
|
p->drawLine(x+1, y2, x2, y2);
|
|
|
p->drawLine(x2, y+1, x2, y2);
|
|
|
|
|
|
if (horizontal) {
|
|
|
TQWMatrix m;
|
|
|
m.rotate(-90.0);
|
|
|
TQPixmap vpix = pix.xForm(m);
|
|
|
bitBlt(wid, r.x()+1, r.y()+1, &vpix);
|
|
|
} else
|
|
|
bitBlt(wid, r.x()+1, r.y()+1, &pix);
|
|
|
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* KPE_ListViewExpander and KPE_ListViewBranch are based on code from
|
|
|
* QWindowStyle's CC_ListView, kindly donated by TrollTech.
|
|
|
* CC_ListView code is Copyright (C) 1998-2000 TrollTech AS.
|
|
|
*/
|
|
|
|
|
|
case KPE_ListViewExpander: {
|
|
|
// Typical Windows style expand/collapse element.
|
|
|
int radius = (r.width() - 4) / 2;
|
|
|
int centerx = r.x() + r.width()/2;
|
|
|
int centery = r.y() + r.height()/2;
|
|
|
|
|
|
// Outer box
|
|
|
p->setPen( cg.mid() );
|
|
|
p->drawRect( r );
|
|
|
|
|
|
// plus or minus
|
|
|
p->setPen( cg.text() );
|
|
|
p->drawLine( centerx - radius, centery, centerx + radius, centery );
|
|
|
if ( flags & Style_On ) // Collapsed = On
|
|
|
p->drawLine( centerx, centery - radius, centerx, centery + radius );
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case KPE_ListViewBranch: {
|
|
|
// Typical Windows style listview branch element (dotted line).
|
|
|
|
|
|
// Create the dotline pixmaps if not already created
|
|
|
if ( !d->verticalLine )
|
|
|
{
|
|
|
// make 128*1 and 1*128 bitmaps that can be used for
|
|
|
// drawing the right sort of lines.
|
|
|
d->verticalLine = new TQBitmap( 1, 129, true );
|
|
|
d->horizontalLine = new TQBitmap( 128, 1, true );
|
|
|
TQPointArray a( 64 );
|
|
|
TQPainter p2;
|
|
|
p2.begin( d->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();
|
|
|
d->verticalLine->setMask( *d->verticalLine );
|
|
|
|
|
|
p2.begin( d->horizontalLine );
|
|
|
for( i=0; i < 64; i++ )
|
|
|
a.setPoint( i, i*2+1, 0 );
|
|
|
p2.setPen( color1 );
|
|
|
p2.drawPoints( a );
|
|
|
p2.end();
|
|
|
TQApplication::flushX();
|
|
|
d->horizontalLine->setMask( *d->horizontalLine );
|
|
|
}
|
|
|
|
|
|
p->setPen( cg.text() ); // cg.dark() is bad for dark color schemes.
|
|
|
|
|
|
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, *d->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, *d->verticalLine, 0, pixmapoffset, thickness, i );
|
|
|
point += i;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
// Reimplement the other primitives in your styles.
|
|
|
// The current implementation just paints something visibly different.
|
|
|
case KPE_ToolBarHandle:
|
|
|
case KPE_GeneralHandle:
|
|
|
case KPE_SliderHandle:
|
|
|
p->fillRect(r, cg.light());
|
|
|
break;
|
|
|
|
|
|
case KPE_SliderGroove:
|
|
|
p->fillRect(r, cg.dark());
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
p->fillRect(r, Qt::yellow); // Something really bad happened - highlight.
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
int TDEStyle::kPixelMetric( TDEStylePixelMetric kpm, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQWidget* /* widget */) const
|
|
|
{
|
|
|
int value;
|
|
|
switch(kpm)
|
|
|
{
|
|
|
case KPM_ListViewBranchThickness:
|
|
|
value = 1;
|
|
|
break;
|
|
|
|
|
|
case KPM_MenuItemSeparatorHeight:
|
|
|
case KPM_MenuItemHMargin:
|
|
|
case KPM_MenuItemVMargin:
|
|
|
case KPM_MenuItemHFrame:
|
|
|
case KPM_MenuItemVFrame:
|
|
|
case KPM_MenuItemCheckMarkHMargin:
|
|
|
case KPM_MenuItemArrowHMargin:
|
|
|
case KPM_MenuItemTabSpacing:
|
|
|
default:
|
|
|
value = 0;
|
|
|
}
|
|
|
|
|
|
return value;
|
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
|
|
// #ifdef USE_QT4 // tdebindings / smoke needs this function declaration available at all times. Furthermore I don't think it would hurt to have the declaration available at all times...so leave these commented out for now
|
|
|
|
|
|
//void TDEStyle::drawPrimitive( TQ_ControlElement pe,
|
|
|
// TQPainter* p,
|
|
|
// const TQStyleControlElementData &ceData,
|
|
|
// ControlElementFlags elementFlags,
|
|
|
// const TQRect &r,
|
|
|
// const TQColorGroup &cg,
|
|
|
// SFlags flags,
|
|
|
// const TQStyleOption& opt ) const
|
|
|
//{
|
|
|
// // FIXME:
|
|
|
// // What should "widget" be in actuality? How should I get it? From where?
|
|
|
// // Almost certainly it should not be null!
|
|
|
// TQWidget *widget = 0;
|
|
|
// drawControl(pe, p, ceData, elementFlags, r, cg, flags, opt, widget);
|
|
|
//}
|
|
|
|
|
|
// #endif // USE_QT4
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
|
|
void TDEStyle::drawPrimitive( TQ_PrimitiveElement pe,
|
|
|
TQPainter* p,
|
|
|
const TQStyleControlElementData &ceData,
|
|
|
ControlElementFlags elementFlags,
|
|
|
const TQRect &r,
|
|
|
const TQColorGroup &cg,
|
|
|
SFlags flags,
|
|
|
const TQStyleOption& opt ) const
|
|
|
{
|
|
|
// TOOLBAR/DOCK WINDOW HANDLE
|
|
|
// ------------------------------------------------------------------------
|
|
|
if (pe == PE_DockWindowHandle)
|
|
|
{
|
|
|
// Wild workarounds are here. Beware.
|
|
|
TQWidget *widget, *parent;
|
|
|
|
|
|
if (p && p->device()->devType() == TQInternal::Widget) {
|
|
|
widget = static_cast<TQWidget*>(p->device());
|
|
|
parent = widget->parentWidget();
|
|
|
} else
|
|
|
return; // Don't paint on non-widgets
|
|
|
|
|
|
// Check if we are a normal toolbar or a hidden dockwidget.
|
|
|
if ( parent &&
|
|
|
(parent->inherits(TQTOOLBAR_OBJECT_NAME_STRING) || // Normal toolbar
|
|
|
(parent->inherits(TQMAINWINDOW_OBJECT_NAME_STRING)) )) // Collapsed dock
|
|
|
|
|
|
// Draw a toolbar handle
|
|
|
drawTDEStylePrimitive( KPE_ToolBarHandle, p, ceData, elementFlags, r, cg, flags, opt, widget );
|
|
|
|
|
|
else if (ceData.widgetObjectTypes.contains(TQDOCKWINDOWHANDLE_OBJECT_NAME_STRING))
|
|
|
|
|
|
// Draw a dock window handle
|
|
|
drawTDEStylePrimitive( KPE_DockWindowHandle, p, ceData, elementFlags, r, cg, flags, opt, widget );
|
|
|
|
|
|
else
|
|
|
// General handle, probably a kicker applet handle.
|
|
|
drawTDEStylePrimitive( KPE_GeneralHandle, p, ceData, elementFlags, r, cg, flags, opt, widget );
|
|
|
#if TQT_VERSION >= 0x030300
|
|
|
#ifdef HAVE_XRENDER
|
|
|
} else if ( d->semiTransparentRubberband && pe == TQStyle::PE_RubberBand ) {
|
|
|
TQRect rect = r.normalize();
|
|
|
TQPoint point;
|
|
|
point = p->xForm( point );
|
|
|
|
|
|
static XRenderColor clr = { 0, 0, 0, 0 };
|
|
|
static unsigned long fillColor = 0;
|
|
|
if ( fillColor != cg.highlight().rgb() ) {
|
|
|
fillColor = cg.highlight().rgb();
|
|
|
|
|
|
unsigned long color = fillColor << 8 | 0x40;
|
|
|
|
|
|
int red = (color >> 24) & 0xff;
|
|
|
int green = (color >> 16) & 0xff;
|
|
|
int blue = (color >> 8) & 0xff;
|
|
|
int 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;
|
|
|
}
|
|
|
|
|
|
XRenderFillRectangle(
|
|
|
p->device()->x11Display(),
|
|
|
PictOpOver,
|
|
|
p->device()->x11RenderHandle(),
|
|
|
&clr,
|
|
|
rect.x() + point.x(),
|
|
|
rect.y() + point.y(),
|
|
|
rect.width(),
|
|
|
rect.height() );
|
|
|
|
|
|
p->save();
|
|
|
p->setRasterOp( TQt::CopyROP );
|
|
|
p->setPen( TQPen( cg.highlight().dark( 160 ), 1 ) );
|
|
|
p->setBrush( NoBrush );
|
|
|
p->drawRect(
|
|
|
rect.x() + point.x(),
|
|
|
rect.y() + point.y(),
|
|
|
rect.width(),
|
|
|
rect.height() );
|
|
|
p->restore();
|
|
|
#endif
|
|
|
#endif
|
|
|
} else
|
|
|
TQCommonStyle::drawPrimitive( pe, p, ceData, elementFlags, r, cg, flags, opt );
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void TDEStyle::drawControl( TQ_ControlElement element,
|
|
|
TQPainter* p,
|
|
|
const TQStyleControlElementData &ceData,
|
|
|
ControlElementFlags elementFlags,
|
|
|
const TQRect &r,
|
|
|
const TQColorGroup &cg,
|
|
|
SFlags flags,
|
|
|
const TQStyleOption &opt,
|
|
|
const TQWidget* widget ) const
|
|
|
{
|
|
|
switch (element)
|
|
|
{
|
|
|
// TABS
|
|
|
// ------------------------------------------------------------------------
|
|
|
case CE_TabBarTab: {
|
|
|
TQTabBar::Shape tbs = ceData.tabBarData.shape;
|
|
|
bool selected = flags & Style_Selected;
|
|
|
int x = r.x(), y=r.y(), bottom=r.bottom(), right=r.right();
|
|
|
|
|
|
switch (tbs) {
|
|
|
|
|
|
case TQTabBar::RoundedAbove: {
|
|
|
if (!selected)
|
|
|
p->translate(0,1);
|
|
|
p->setPen(selected ? cg.light() : cg.shadow());
|
|
|
p->drawLine(x, y+4, x, bottom);
|
|
|
p->drawLine(x, y+4, x+4, y);
|
|
|
p->drawLine(x+4, y, right-1, y);
|
|
|
if (selected)
|
|
|
p->setPen(cg.shadow());
|
|
|
p->drawLine(right, y+1, right, bottom);
|
|
|
|
|
|
p->setPen(cg.midlight());
|
|
|
p->drawLine(x+1, y+4, x+1, bottom);
|
|
|
p->drawLine(x+1, y+4, x+4, y+1);
|
|
|
p->drawLine(x+5, y+1, right-2, y+1);
|
|
|
|
|
|
if (selected) {
|
|
|
p->setPen(cg.mid());
|
|
|
p->drawLine(right-1, y+1, right-1, bottom);
|
|
|
} else {
|
|
|
p->setPen(cg.mid());
|
|
|
p->drawPoint(right-1, y+1);
|
|
|
p->drawLine(x+4, y+2, right-1, y+2);
|
|
|
p->drawLine(x+3, y+3, right-1, y+3);
|
|
|
p->fillRect(x+2, y+4, r.width()-3, r.height()-6, cg.mid());
|
|
|
|
|
|
p->setPen(cg.light());
|
|
|
p->drawLine(x, bottom-1, right, bottom-1);
|
|
|
p->translate(0,-1);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case TQTabBar::RoundedBelow: {
|
|
|
if (!selected)
|
|
|
p->translate(0,-1);
|
|
|
p->setPen(selected ? cg.light() : cg.shadow());
|
|
|
p->drawLine(x, bottom-4, x, y);
|
|
|
if (selected)
|
|
|
p->setPen(cg.mid());
|
|
|
p->drawLine(x, bottom-4, x+4, bottom);
|
|
|
if (selected)
|
|
|
p->setPen(cg.shadow());
|
|
|
p->drawLine(x+4, bottom, right-1, bottom);
|
|
|
p->drawLine(right, bottom-1, right, y);
|
|
|
|
|
|
p->setPen(cg.midlight());
|
|
|
p->drawLine(x+1, bottom-4, x+1, y);
|
|
|
p->drawLine(x+1, bottom-4, x+4, bottom-1);
|
|
|
p->drawLine(x+5, bottom-1, right-2, bottom-1);
|
|
|
|
|
|
if (selected) {
|
|
|
p->setPen(cg.mid());
|
|
|
p->drawLine(right-1, y, right-1, bottom-1);
|
|
|
} else {
|
|
|
p->setPen(cg.mid());
|
|
|
p->drawPoint(right-1, bottom-1);
|
|
|
p->drawLine(x+4, bottom-2, right-1, bottom-2);
|
|
|
p->drawLine(x+3, bottom-3, right-1, bottom-3);
|
|
|
p->fillRect(x+2, y+2, r.width()-3, r.height()-6, cg.mid());
|
|
|
p->translate(0,1);
|
|
|
p->setPen(cg.dark());
|
|
|
p->drawLine(x, y, right, y);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case TQTabBar::TriangularAbove: {
|
|
|
if (!selected)
|
|
|
p->translate(0,1);
|
|
|
p->setPen(selected ? cg.light() : cg.shadow());
|
|
|
p->drawLine(x, bottom, x, y+6);
|
|
|
p->drawLine(x, y+6, x+6, y);
|
|
|
p->drawLine(x+6, y, right-6, y);
|
|
|
if (selected)
|
|
|
p->setPen(cg.mid());
|
|
|
p->drawLine(right-5, y+1, right-1, y+5);
|
|
|
p->setPen(cg.shadow());
|
|
|
p->drawLine(right, y+6, right, bottom);
|
|
|
|
|
|
p->setPen(cg.midlight());
|
|
|
p->drawLine(x+1, bottom, x+1, y+6);
|
|
|
p->drawLine(x+1, y+6, x+6, y+1);
|
|
|
p->drawLine(x+6, y+1, right-6, y+1);
|
|
|
p->drawLine(right-5, y+2, right-2, y+5);
|
|
|
p->setPen(cg.mid());
|
|
|
p->drawLine(right-1, y+6, right-1, bottom);
|
|
|
|
|
|
TQPointArray a(6);
|
|
|
a.setPoint(0, x+2, bottom);
|
|
|
a.setPoint(1, x+2, y+7);
|
|
|
a.setPoint(2, x+7, y+2);
|
|
|
a.setPoint(3, right-7, y+2);
|
|
|
a.setPoint(4, right-2, y+7);
|
|
|
a.setPoint(5, right-2, bottom);
|
|
|
p->setPen (selected ? cg.background() : cg.mid());
|
|
|
p->setBrush(selected ? cg.background() : cg.mid());
|
|
|
p->drawPolygon(a);
|
|
|
p->setBrush(NoBrush);
|
|
|
if (!selected) {
|
|
|
p->translate(0,-1);
|
|
|
p->setPen(cg.light());
|
|
|
p->drawLine(x, bottom, right, bottom);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
default: { // TQTabBar::TriangularBelow
|
|
|
if (!selected)
|
|
|
p->translate(0,-1);
|
|
|
p->setPen(selected ? cg.light() : cg.shadow());
|
|
|
p->drawLine(x, y, x, bottom-6);
|
|
|
if (selected)
|
|
|
p->setPen(cg.mid());
|
|
|
p->drawLine(x, bottom-6, x+6, bottom);
|
|
|
if (selected)
|
|
|
p->setPen(cg.shadow());
|
|
|
p->drawLine(x+6, bottom, right-6, bottom);
|
|
|
p->drawLine(right-5, bottom-1, right-1, bottom-5);
|
|
|
if (!selected)
|
|
|
p->setPen(cg.shadow());
|
|
|
p->drawLine(right, bottom-6, right, y);
|
|
|
|
|
|
p->setPen(cg.midlight());
|
|
|
p->drawLine(x+1, y, x+1, bottom-6);
|
|
|
p->drawLine(x+1, bottom-6, x+6, bottom-1);
|
|
|
p->drawLine(x+6, bottom-1, right-6, bottom-1);
|
|
|
p->drawLine(right-5, bottom-2, right-2, bottom-5);
|
|
|
p->setPen(cg.mid());
|
|
|
p->drawLine(right-1, bottom-6, right-1, y);
|
|
|
|
|
|
TQPointArray a(6);
|
|
|
a.setPoint(0, x+2, y);
|
|
|
a.setPoint(1, x+2, bottom-7);
|
|
|
a.setPoint(2, x+7, bottom-2);
|
|
|
a.setPoint(3, right-7, bottom-2);
|
|
|
a.setPoint(4, right-2, bottom-7);
|
|
|
a.setPoint(5, right-2, y);
|
|
|
p->setPen (selected ? cg.background() : cg.mid());
|
|
|
p->setBrush(selected ? cg.background() : cg.mid());
|
|
|
p->drawPolygon(a);
|
|
|
p->setBrush(NoBrush);
|
|
|
if (!selected) {
|
|
|
p->translate(0,1);
|
|
|
p->setPen(cg.dark());
|
|
|
p->drawLine(x, y, right, y);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
// Popup menu scroller
|
|
|
// ------------------------------------------------------------------------
|
|
|
case CE_PopupMenuScroller: {
|
|
|
p->fillRect(r, cg.background());
|
|
|
drawPrimitive(PE_ButtonTool, p, ceData, elementFlags, r, cg, Style_Enabled);
|
|
|
drawPrimitive((flags & Style_Up) ? PE_ArrowUp : PE_ArrowDown, p, ceData, elementFlags, r, cg, Style_Enabled);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
|
|
|
// PROGRESSBAR
|
|
|
// ------------------------------------------------------------------------
|
|
|
case CE_ProgressBarGroove: {
|
|
|
TQRect fr = subRect(SR_ProgressBarGroove, ceData, elementFlags, widget);
|
|
|
drawPrimitive(PE_Panel, p, ceData, elementFlags, fr, cg, Style_Sunken, TQStyleOption::SO_Default);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case CE_ProgressBarContents: {
|
|
|
// ### Take into account totalSteps() for busy indicator
|
|
|
TQRect cr = subRect(SR_ProgressBarContents, ceData, elementFlags, widget);
|
|
|
double progress = ceData.currentStep;
|
|
|
bool reverse = TQApplication::reverseLayout();
|
|
|
int steps = ceData.totalSteps;
|
|
|
|
|
|
if (!cr.isValid())
|
|
|
return;
|
|
|
|
|
|
// Draw progress bar
|
|
|
if (progress > 0 || steps == 0) {
|
|
|
double pg = (steps == 0) ? 0.1 : progress / steps;
|
|
|
int width = QMIN(cr.width(), (int)(pg * cr.width()));
|
|
|
if (steps == 0) { //Busy indicator
|
|
|
|
|
|
if (width < 1) width = 1; //A busy indicator with width 0 is kind of useless
|
|
|
|
|
|
int remWidth = cr.width() - width; //Never disappear completely
|
|
|
if (remWidth <= 0) remWidth = 1; //Do something non-crashy when too small...
|
|
|
|
|
|
int pstep = int(progress) % ( 2 * remWidth );
|
|
|
|
|
|
if ( pstep > remWidth ) {
|
|
|
//Bounce about.. We're remWidth + some delta, we want to be remWidth - delta...
|
|
|
// - ( (remWidth + some delta) - 2* remWidth ) = - (some deleta - remWidth) = remWidth - some delta..
|
|
|
pstep = - (pstep - 2 * remWidth );
|
|
|
}
|
|
|
|
|
|
if (reverse)
|
|
|
p->fillRect(cr.x() + cr.width() - width - pstep, cr.y(), width, cr.height(),
|
|
|
cg.brush(TQColorGroup::Highlight));
|
|
|
else
|
|
|
p->fillRect(cr.x() + pstep, cr.y(), width, cr.height(),
|
|
|
cg.brush(TQColorGroup::Highlight));
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Do fancy gradient for highcolor displays
|
|
|
if (d->highcolor) {
|
|
|
TQColor c(cg.highlight());
|
|
|
KPixmap pix;
|
|
|
pix.resize(cr.width(), cr.height());
|
|
|
KPixmapEffect::gradient(pix, reverse ? c.light(150) : c.dark(150),
|
|
|
reverse ? c.dark(150) : c.light(150),
|
|
|
KPixmapEffect::HorizontalGradient);
|
|
|
if (reverse)
|
|
|
p->drawPixmap(cr.x()+(cr.width()-width), cr.y(), pix,
|
|
|
cr.width()-width, 0, width, cr.height());
|
|
|
else
|
|
|
p->drawPixmap(cr.x(), cr.y(), pix, 0, 0, width, cr.height());
|
|
|
} else
|
|
|
if (reverse)
|
|
|
p->fillRect(cr.x()+(cr.width()-width), cr.y(), width, cr.height(),
|
|
|
cg.brush(TQColorGroup::Highlight));
|
|
|
else
|
|
|
p->fillRect(cr.x(), cr.y(), width, cr.height(),
|
|
|
cg.brush(TQColorGroup::Highlight));
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case CE_ProgressBarLabel: {
|
|
|
TQRect cr = subRect(SR_ProgressBarContents, ceData, elementFlags, widget);
|
|
|
double progress = ceData.currentStep;
|
|
|
bool reverse = TQApplication::reverseLayout();
|
|
|
int steps = ceData.totalSteps;
|
|
|
|
|
|
if (!cr.isValid())
|
|
|
return;
|
|
|
|
|
|
TQFont font = p->font();
|
|
|
font.setBold(true);
|
|
|
p->setFont(font);
|
|
|
|
|
|
// Draw label
|
|
|
if (progress > 0 || steps == 0) {
|
|
|
double pg = (steps == 0) ? 1.0 : progress / steps;
|
|
|
int width = QMIN(cr.width(), (int)(pg * cr.width()));
|
|
|
TQRect crect;
|
|
|
if (reverse)
|
|
|
crect.setRect(cr.x()+(cr.width()-width), cr.y(), cr.width(), cr.height());
|
|
|
else
|
|
|
crect.setRect(cr.x()+width, cr.y(), cr.width(), cr.height());
|
|
|
|
|
|
p->save();
|
|
|
p->setPen((elementFlags & CEF_IsEnabled) ? (reverse ? cg.text() : cg.highlightedText()) : cg.text());
|
|
|
p->drawText(r, AlignCenter, ceData.progressText);
|
|
|
p->setClipRect(crect);
|
|
|
p->setPen(reverse ? cg.highlightedText() : cg.text());
|
|
|
p->drawText(r, AlignCenter, ceData.progressText);
|
|
|
p->restore();
|
|
|
|
|
|
} else {
|
|
|
p->setPen(cg.text());
|
|
|
p->drawText(r, AlignCenter, ceData.progressText);
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
default:
|
|
|
TQCommonStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
TQRect TDEStyle::subRect(SubRect r, const TQStyleControlElementData &ceData, const ControlElementFlags elementFlags, const TQWidget* widget) const
|
|
|
{
|
|
|
switch(r)
|
|
|
{
|
|
|
// KDE2 look smooth progress bar
|
|
|
// ------------------------------------------------------------------------
|
|
|
case SR_ProgressBarGroove:
|
|
|
return ceData.rect;
|
|
|
|
|
|
case SR_ProgressBarContents:
|
|
|
case SR_ProgressBarLabel: {
|
|
|
// ### take into account indicatorFollowsStyle()
|
|
|
TQRect rt = ceData.rect;
|
|
|
return TQRect(rt.x()+2, rt.y()+2, rt.width()-4, rt.height()-4);
|
|
|
}
|
|
|
|
|
|
default:
|
|
|
return TQCommonStyle::subRect(r, ceData, elementFlags, widget);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
int TDEStyle::pixelMetric(PixelMetric m, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQWidget* widget) const
|
|
|
{
|
|
|
switch(m)
|
|
|
{
|
|
|
// BUTTONS
|
|
|
// ------------------------------------------------------------------------
|
|
|
case PM_ButtonShiftHorizontal: // Offset by 1
|
|
|
case PM_ButtonShiftVertical: // ### Make configurable
|
|
|
return 1;
|
|
|
|
|
|
case PM_DockWindowHandleExtent:
|
|
|
{
|
|
|
TQWidget* parent = 0;
|
|
|
// Check that we are not a normal toolbar or a hidden dockwidget,
|
|
|
// in which case we need to adjust the height for font size
|
|
|
if (widget
|
|
|
&& !(ceData.parentWidgetData.widgetObjectTypes.contains(TQTOOLBAR_OBJECT_NAME_STRING))
|
|
|
&& !(ceData.parentWidgetData.widgetObjectTypes.contains(TQMAINWINDOW_OBJECT_NAME_STRING))
|
|
|
&& (ceData.widgetObjectTypes.contains(TQDOCKWINDOWHANDLE_OBJECT_NAME_STRING)) )
|
|
|
return widget->fontMetrics().lineSpacing();
|
|
|
else
|
|
|
return TQCommonStyle::pixelMetric(m, ceData, elementFlags, widget);
|
|
|
}
|
|
|
|
|
|
// TABS
|
|
|
// ------------------------------------------------------------------------
|
|
|
case PM_TabBarTabHSpace:
|
|
|
return 24;
|
|
|
|
|
|
case PM_TabBarTabVSpace: {
|
|
|
if ( ceData.tabBarData.shape == TQTabBar::RoundedAbove ||
|
|
|
ceData.tabBarData.shape == TQTabBar::RoundedBelow )
|
|
|
return 10;
|
|
|
else
|
|
|
return 4;
|
|
|
}
|
|
|
|
|
|
case PM_TabBarTabOverlap: {
|
|
|
TQTabBar::Shape tbs = ceData.tabBarData.shape;
|
|
|
|
|
|
if ( (tbs == TQTabBar::RoundedAbove) ||
|
|
|
(tbs == TQTabBar::RoundedBelow) )
|
|
|
return 0;
|
|
|
else
|
|
|
return 2;
|
|
|
}
|
|
|
|
|
|
// SLIDER
|
|
|
// ------------------------------------------------------------------------
|
|
|
case PM_SliderLength:
|
|
|
return 18;
|
|
|
|
|
|
case PM_SliderThickness:
|
|
|
return 24;
|
|
|
|
|
|
// Determines how much space to leave for the actual non-tickmark
|
|
|
// portion of the slider.
|
|
|
case PM_SliderControlThickness: {
|
|
|
TQSlider::TickSetting ts = (TQSlider::TickSetting)ceData.tickMarkSetting;
|
|
|
int thickness = (ceData.orientation == TQt::Horizontal) ?
|
|
|
ceData.rect.height() : ceData.rect.width();
|
|
|
switch (ts) {
|
|
|
case TQSlider::NoMarks: // Use total area.
|
|
|
break;
|
|
|
case TQSlider::Both:
|
|
|
thickness = (thickness/2) + 3; // Use approx. 1/2 of area.
|
|
|
break;
|
|
|
default: // Use approx. 2/3 of area
|
|
|
thickness = ((thickness*2)/3) + 3;
|
|
|
break;
|
|
|
};
|
|
|
return thickness;
|
|
|
}
|
|
|
|
|
|
// SPLITTER
|
|
|
// ------------------------------------------------------------------------
|
|
|
case PM_SplitterWidth:
|
|
|
if (ceData.widgetObjectTypes.contains(TQDOCKWINDOWRESIZEHANDLE_OBJECT_NAME_STRING))
|
|
|
return 8; // ### why do we need 2pix extra?
|
|
|
else
|
|
|
return 6;
|
|
|
|
|
|
// FRAMES
|
|
|
// ------------------------------------------------------------------------
|
|
|
case PM_MenuBarFrameWidth:
|
|
|
return 1;
|
|
|
|
|
|
case PM_DockWindowFrameWidth:
|
|
|
return 1;
|
|
|
|
|
|
// GENERAL
|
|
|
// ------------------------------------------------------------------------
|
|
|
case PM_MaximumDragDistance:
|
|
|
return -1;
|
|
|
|
|
|
case PM_MenuBarItemSpacing:
|
|
|
return 5;
|
|
|
|
|
|
case PM_ToolBarItemSpacing:
|
|
|
return 0;
|
|
|
|
|
|
case PM_PopupMenuScrollerHeight:
|
|
|
return pixelMetric( PM_ScrollBarExtent, ceData, elementFlags, 0);
|
|
|
|
|
|
default:
|
|
|
return TQCommonStyle::pixelMetric( m, ceData, elementFlags, widget );
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//Helper to find the next sibling that's not hidden
|
|
|
static TQListViewItem* nextVisibleSibling(TQListViewItem* item)
|
|
|
{
|
|
|
TQListViewItem* sibling = item;
|
|
|
do
|
|
|
{
|
|
|
sibling = sibling->nextSibling();
|
|
|
}
|
|
|
while (sibling && !sibling->isVisible());
|
|
|
|
|
|
return sibling;
|
|
|
}
|
|
|
|
|
|
void TDEStyle::drawComplexControl( TQ_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
|
|
|
{
|
|
|
switch(control)
|
|
|
{
|
|
|
// 3 BUTTON SCROLLBAR
|
|
|
// ------------------------------------------------------------------------
|
|
|
case CC_ScrollBar: {
|
|
|
// Many thanks to Brad Hughes for contributing this code.
|
|
|
bool useThreeButtonScrollBar = (d->scrollbarType & ThreeButtonScrollBar);
|
|
|
|
|
|
bool maxedOut = (ceData.minSteps == ceData.maxSteps);
|
|
|
bool horizontal = (ceData.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 ( useThreeButtonScrollBar ) {
|
|
|
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));
|
|
|
|
|
|
if (useThreeButtonScrollBar && subline2.isValid())
|
|
|
drawPrimitive(PE_ScrollBarSubLine, 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));
|
|
|
// Draw focus rect
|
|
|
if (elementFlags & CEF_HasFocus) {
|
|
|
TQRect fr(slider.x() + 2, slider.y() + 2,
|
|
|
slider.width() - 5, slider.height() - 5);
|
|
|
drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, Style_Default);
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
|
|
|
// SLIDER
|
|
|
// -------------------------------------------------------------------
|
|
|
case CC_Slider: {
|
|
|
TQRect groove = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderGroove, opt, widget);
|
|
|
TQRect handle = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderHandle, opt, widget);
|
|
|
|
|
|
// Double-buffer slider for no flicker
|
|
|
TQPixmap pix(ceData.rect.size());
|
|
|
TQPainter p2;
|
|
|
p2.begin(&pix);
|
|
|
|
|
|
if ( (elementFlags & CEF_HasParentWidget) &&
|
|
|
!ceData.parentWidgetData.bgPixmap.isNull() ) {
|
|
|
TQPixmap pixmap = ceData.parentWidgetData.bgPixmap;
|
|
|
p2.drawTiledPixmap(r, pixmap, ceData.pos);
|
|
|
} else
|
|
|
pix.fill(cg.background());
|
|
|
|
|
|
// Draw slider groove
|
|
|
if ((controls & SC_SliderGroove) && groove.isValid()) {
|
|
|
drawTDEStylePrimitive( KPE_SliderGroove, &p2, ceData, elementFlags, groove, cg, flags, opt, widget );
|
|
|
|
|
|
// Draw the focus rect around the groove
|
|
|
if (elementFlags & CEF_HasFocus) {
|
|
|
drawPrimitive(PE_FocusRect, &p2, ceData, elementFlags, groove, cg);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Draw the tickmarks
|
|
|
if (controls & SC_SliderTickmarks)
|
|
|
TQCommonStyle::drawComplexControl(control, &p2, ceData, elementFlags,
|
|
|
r, cg, flags, SC_SliderTickmarks, active, opt, widget);
|
|
|
|
|
|
// Draw the slider handle
|
|
|
if ((controls & SC_SliderHandle) && handle.isValid()) {
|
|
|
if (active == SC_SliderHandle)
|
|
|
flags |= Style_Active;
|
|
|
drawTDEStylePrimitive( KPE_SliderHandle, &p2, ceData, elementFlags, handle, cg, flags, opt, widget );
|
|
|
}
|
|
|
|
|
|
p2.end();
|
|
|
|
|
|
TQPaintDevice* ppd = p->device();
|
|
|
if (ppd->isExtDev()) {
|
|
|
p->drawPixmap(0, 0, pix);
|
|
|
}
|
|
|
else {
|
|
|
bitBlt((TQWidget*)widget, r.x(), r.y(), &pix);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
// LISTVIEW
|
|
|
// -------------------------------------------------------------------
|
|
|
case CC_ListView: {
|
|
|
|
|
|
/*
|
|
|
* Many thanks to TrollTech AS for donating CC_ListView from TQWindowsStyle.
|
|
|
* CC_ListView code is Copyright (C) 1998-2000 TrollTech AS.
|
|
|
*/
|
|
|
|
|
|
// Paint the icon and text.
|
|
|
if ( controls & SC_ListView )
|
|
|
TQCommonStyle::drawComplexControl( control, p, ceData, elementFlags, r, cg, flags, controls, active, opt, widget );
|
|
|
|
|
|
// If we're have a branch or are expanded...
|
|
|
if ( controls & (SC_ListViewBranch | SC_ListViewExpand) )
|
|
|
{
|
|
|
// If no list view item was supplied, break
|
|
|
if (opt.isDefault())
|
|
|
break;
|
|
|
|
|
|
TQListViewItem *item = opt.listViewItem();
|
|
|
TQListViewItem *child = item->firstChild();
|
|
|
|
|
|
int y = r.y();
|
|
|
int c; // dotline vertice count
|
|
|
int dotoffset = 0;
|
|
|
TQPointArray dotlines;
|
|
|
|
|
|
if ( active == SC_All && controls == SC_ListViewExpand ) {
|
|
|
// We only need to draw a vertical line
|
|
|
c = 2;
|
|
|
dotlines.resize(2);
|
|
|
dotlines[0] = TQPoint( r.right(), r.top() );
|
|
|
dotlines[1] = TQPoint( r.right(), r.bottom() );
|
|
|
|
|
|
} else {
|
|
|
|
|
|
int linetop = 0, linebot = 0;
|
|
|
// each branch needs at most two lines, ie. four end points
|
|
|
dotoffset = (item->itemPos() + item->height() - y) % 2;
|
|
|
dotlines.resize( item->childCount() * 4 );
|
|
|
c = 0;
|
|
|
|
|
|
// skip the stuff above the exposed rectangle
|
|
|
while ( child && y + child->height() <= 0 )
|
|
|
{
|
|
|
y += child->totalHeight();
|
|
|
child = nextVisibleSibling(child);
|
|
|
}
|
|
|
|
|
|
int bx = r.width() / 2;
|
|
|
|
|
|
// paint stuff in the magical area
|
|
|
TQListView* v = item->listView();
|
|
|
int lh = QMAX( p->fontMetrics().height() + 2 * v->itemMargin(),
|
|
|
TQApplication::globalStrut().height() );
|
|
|
if ( lh % 2 > 0 )
|
|
|
lh++;
|
|
|
|
|
|
// Draw all the expand/close boxes...
|
|
|
TQRect boxrect;
|
|
|
TQStyle::StyleFlags boxflags;
|
|
|
while ( child && y < r.height() )
|
|
|
{
|
|
|
linebot = y + lh/2;
|
|
|
if ( (child->isExpandable() || child->childCount()) &&
|
|
|
(child->height() > 0) )
|
|
|
{
|
|
|
// The primitive requires a rect.
|
|
|
boxrect = TQRect( bx-4, linebot-4, 9, 9 );
|
|
|
boxflags = child->isOpen() ? TQStyle::Style_Off : TQStyle::Style_On;
|
|
|
|
|
|
// TDEStyle extension: Draw the box and expand/collapse indicator
|
|
|
drawTDEStylePrimitive( KPE_ListViewExpander, p, ceData, elementFlags, boxrect, cg, boxflags, opt, NULL );
|
|
|
|
|
|
// dotlinery
|
|
|
p->setPen( cg.mid() );
|
|
|
dotlines[c++] = TQPoint( bx, linetop );
|
|
|
dotlines[c++] = TQPoint( bx, linebot - 5 );
|
|
|
dotlines[c++] = TQPoint( bx + 5, linebot );
|
|
|
dotlines[c++] = TQPoint( r.width(), linebot );
|
|
|
linetop = linebot + 5;
|
|
|
} else {
|
|
|
// just dotlinery
|
|
|
dotlines[c++] = TQPoint( bx+1, linebot );
|
|
|
dotlines[c++] = TQPoint( r.width(), linebot );
|
|
|
}
|
|
|
|
|
|
y += child->totalHeight();
|
|
|
child = nextVisibleSibling(child);
|
|
|
}
|
|
|
|
|
|
if ( child ) // there's a child to draw, so move linebot to edge of rectangle
|
|
|
linebot = r.height();
|
|
|
|
|
|
if ( linetop < linebot )
|
|
|
{
|
|
|
dotlines[c++] = TQPoint( bx, linetop );
|
|
|
dotlines[c++] = TQPoint( bx, linebot );
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Draw all the branches...
|
|
|
static int thickness = kPixelMetric( KPM_ListViewBranchThickness, ceData, elementFlags );
|
|
|
int line; // index into dotlines
|
|
|
TQRect branchrect;
|
|
|
TQStyle::StyleFlags branchflags;
|
|
|
for( line = 0; line < c; line += 2 )
|
|
|
{
|
|
|
// assumptions here: lines are horizontal or vertical.
|
|
|
// lines always start with the numerically lowest
|
|
|
// coordinate.
|
|
|
|
|
|
// point ... relevant coordinate of current point
|
|
|
// end ..... same coordinate of the end of the current line
|
|
|
// other ... the other coordinate of the current point/line
|
|
|
if ( dotlines[line].y() == dotlines[line+1].y() )
|
|
|
{
|
|
|
// Horizontal branch
|
|
|
int end = dotlines[line+1].x();
|
|
|
int point = dotlines[line].x();
|
|
|
int other = dotlines[line].y();
|
|
|
|
|
|
branchrect = TQRect( point, other-(thickness/2), end-point, thickness );
|
|
|
branchflags = TQStyle::Style_Horizontal;
|
|
|
|
|
|
// TDEStyle extension: Draw the horizontal branch
|
|
|
drawTDEStylePrimitive( KPE_ListViewBranch, p, ceData, elementFlags, branchrect, cg, branchflags, opt, NULL );
|
|
|
|
|
|
} else {
|
|
|
// Vertical branch
|
|
|
int end = dotlines[line+1].y();
|
|
|
int point = dotlines[line].y();
|
|
|
int other = dotlines[line].x();
|
|
|
int pixmapoffset = ((point & 1) != dotoffset ) ? 1 : 0;
|
|
|
|
|
|
branchrect = TQRect( other-(thickness/2), point, thickness, end-point );
|
|
|
if (!pixmapoffset) // ### Hackish - used to hint the offset
|
|
|
branchflags = TQStyle::Style_NoChange;
|
|
|
else
|
|
|
branchflags = TQStyle::Style_Default;
|
|
|
|
|
|
// TDEStyle extension: Draw the vertical branch
|
|
|
drawTDEStylePrimitive( KPE_ListViewBranch, p, ceData, elementFlags, branchrect, cg, branchflags, opt, NULL );
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
default:
|
|
|
TQCommonStyle::drawComplexControl( control, p, ceData, elementFlags, r, cg,
|
|
|
flags, controls, active, opt, widget );
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
TQStyle::SubControl TDEStyle::querySubControl( TQ_ComplexControl control,
|
|
|
const TQStyleControlElementData &ceData,
|
|
|
ControlElementFlags elementFlags,
|
|
|
const TQPoint &pos,
|
|
|
const TQStyleOption &opt,
|
|
|
const TQWidget* widget ) const
|
|
|
{
|
|
|
TQStyle::SubControl ret = TQCommonStyle::querySubControl(control, ceData, elementFlags, pos, opt, widget);
|
|
|
|
|
|
if (d->scrollbarType == ThreeButtonScrollBar) {
|
|
|
// Enable third button
|
|
|
if (control == CC_ScrollBar && ret == SC_None)
|
|
|
ret = SC_ScrollBarSubLine;
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
|
|
|
TQRect TDEStyle::querySubControlMetrics( TQ_ComplexControl control,
|
|
|
const TQStyleControlElementData &ceData,
|
|
|
ControlElementFlags elementFlags,
|
|
|
SubControl sc,
|
|
|
const TQStyleOption &opt,
|
|
|
const TQWidget* widget ) const
|
|
|
{
|
|
|
TQRect ret;
|
|
|
|
|
|
if (control == CC_ScrollBar)
|
|
|
{
|
|
|
bool threeButtonScrollBar = d->scrollbarType & ThreeButtonScrollBar;
|
|
|
bool platinumScrollBar = d->scrollbarType & PlatinumStyleScrollBar;
|
|
|
bool nextScrollBar = d->scrollbarType & NextStyleScrollBar;
|
|
|
|
|
|
bool horizontal = ceData.orientation == TQt::Horizontal;
|
|
|
int sliderstart = ceData.startStep;
|
|
|
int sbextent = pixelMetric(PM_ScrollBarExtent, ceData, elementFlags, widget);
|
|
|
int maxlen = (horizontal ? ceData.rect.width() : ceData.rect.height())
|
|
|
- (sbextent * (threeButtonScrollBar ? 3 : 2));
|
|
|
int sliderlen;
|
|
|
|
|
|
// calculate slider length
|
|
|
if (ceData.maxSteps != ceData.minSteps)
|
|
|
{
|
|
|
uint range = ceData.maxSteps - ceData.minSteps;
|
|
|
sliderlen = (ceData.pageStep * maxlen) / (range + ceData.pageStep);
|
|
|
|
|
|
int slidermin = pixelMetric( PM_ScrollBarSliderMin, ceData, elementFlags, widget );
|
|
|
if ( sliderlen < slidermin || range > INT_MAX / 2 )
|
|
|
sliderlen = slidermin;
|
|
|
if ( sliderlen > maxlen )
|
|
|
sliderlen = maxlen;
|
|
|
} else
|
|
|
sliderlen = maxlen;
|
|
|
|
|
|
// Subcontrols
|
|
|
switch (sc)
|
|
|
{
|
|
|
case SC_ScrollBarSubLine: {
|
|
|
// top/left button
|
|
|
if (platinumScrollBar) {
|
|
|
if (horizontal)
|
|
|
ret.setRect(ceData.rect.width() - 2 * sbextent, 0, sbextent, sbextent);
|
|
|
else
|
|
|
ret.setRect(0, ceData.rect.height() - 2 * sbextent, sbextent, sbextent);
|
|
|
} else
|
|
|
ret.setRect(0, 0, sbextent, sbextent);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case SC_ScrollBarAddLine: {
|
|
|
// bottom/right button
|
|
|
if (nextScrollBar) {
|
|
|
if (horizontal)
|
|
|
ret.setRect(sbextent, 0, sbextent, sbextent);
|
|
|
else
|
|
|
ret.setRect(0, sbextent, sbextent, sbextent);
|
|
|
} else {
|
|
|
if (horizontal)
|
|
|
ret.setRect(ceData.rect.width() - sbextent, 0, sbextent, sbextent);
|
|
|
else
|
|
|
ret.setRect(0, ceData.rect.height() - sbextent, sbextent, sbextent);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case SC_ScrollBarSubPage: {
|
|
|
// between top/left button and slider
|
|
|
if (platinumScrollBar) {
|
|
|
if (horizontal)
|
|
|
ret.setRect(0, 0, sliderstart, sbextent);
|
|
|
else
|
|
|
ret.setRect(0, 0, sbextent, sliderstart);
|
|
|
} else if (nextScrollBar) {
|
|
|
if (horizontal)
|
|
|
ret.setRect(sbextent*2, 0, sliderstart-2*sbextent, sbextent);
|
|
|
else
|
|
|
ret.setRect(0, sbextent*2, sbextent, sliderstart-2*sbextent);
|
|
|
} else {
|
|
|
if (horizontal)
|
|
|
ret.setRect(sbextent, 0, sliderstart - sbextent, sbextent);
|
|
|
else
|
|
|
ret.setRect(0, sbextent, sbextent, sliderstart - sbextent);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case SC_ScrollBarAddPage: {
|
|
|
// between bottom/right button and slider
|
|
|
int fudge;
|
|
|
|
|
|
if (platinumScrollBar)
|
|
|
fudge = 0;
|
|
|
else if (nextScrollBar)
|
|
|
fudge = 2*sbextent;
|
|
|
else
|
|
|
fudge = sbextent;
|
|
|
|
|
|
if (horizontal)
|
|
|
ret.setRect(sliderstart + sliderlen, 0,
|
|
|
maxlen - sliderstart - sliderlen + fudge, sbextent);
|
|
|
else
|
|
|
ret.setRect(0, sliderstart + sliderlen, sbextent,
|
|
|
maxlen - sliderstart - sliderlen + fudge);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case SC_ScrollBarGroove: {
|
|
|
int multi = threeButtonScrollBar ? 3 : 2;
|
|
|
int fudge;
|
|
|
|
|
|
if (platinumScrollBar)
|
|
|
fudge = 0;
|
|
|
else if (nextScrollBar)
|
|
|
fudge = 2*sbextent;
|
|
|
else
|
|
|
fudge = sbextent;
|
|
|
|
|
|
if (horizontal)
|
|
|
ret.setRect(fudge, 0, ceData.rect.width() - sbextent * multi, ceData.rect.height());
|
|
|
else
|
|
|
ret.setRect(0, fudge, ceData.rect.width(), ceData.rect.height() - sbextent * multi);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
case SC_ScrollBarSlider: {
|
|
|
if (horizontal)
|
|
|
ret.setRect(sliderstart, 0, sliderlen, sbextent);
|
|
|
else
|
|
|
ret.setRect(0, sliderstart, sbextent, sliderlen);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
default:
|
|
|
ret = TQCommonStyle::querySubControlMetrics(control, ceData, elementFlags, sc, opt, widget);
|
|
|
break;
|
|
|
}
|
|
|
} else
|
|
|
ret = TQCommonStyle::querySubControlMetrics(control, ceData, elementFlags, sc, opt, widget);
|
|
|
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
static const char * const kstyle_close_xpm[] = {
|
|
|
"12 12 2 1",
|
|
|
"# c #000000",
|
|
|
". c None",
|
|
|
"............",
|
|
|
"............",
|
|
|
"..##....##..",
|
|
|
"...##..##...",
|
|
|
"....####....",
|
|
|
".....##.....",
|
|
|
"....####....",
|
|
|
"...##..##...",
|
|
|
"..##....##..",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............"};
|
|
|
|
|
|
static const char * const kstyle_maximize_xpm[]={
|
|
|
"12 12 2 1",
|
|
|
"# c #000000",
|
|
|
". c None",
|
|
|
"............",
|
|
|
"............",
|
|
|
".##########.",
|
|
|
".##########.",
|
|
|
".#........#.",
|
|
|
".#........#.",
|
|
|
".#........#.",
|
|
|
".#........#.",
|
|
|
".#........#.",
|
|
|
".#........#.",
|
|
|
".##########.",
|
|
|
"............"};
|
|
|
|
|
|
|
|
|
static const char * const kstyle_minimize_xpm[] = {
|
|
|
"12 12 2 1",
|
|
|
"# c #000000",
|
|
|
". c None",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"...######...",
|
|
|
"...######...",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............"};
|
|
|
|
|
|
static const char * const kstyle_normalizeup_xpm[] = {
|
|
|
"12 12 2 1",
|
|
|
"# c #000000",
|
|
|
". c None",
|
|
|
"............",
|
|
|
"...#######..",
|
|
|
"...#######..",
|
|
|
"...#.....#..",
|
|
|
".#######.#..",
|
|
|
".#######.#..",
|
|
|
".#.....#.#..",
|
|
|
".#.....###..",
|
|
|
".#.....#....",
|
|
|
".#.....#....",
|
|
|
".#######....",
|
|
|
"............"};
|
|
|
|
|
|
|
|
|
static const char * const kstyle_shade_xpm[] = {
|
|
|
"12 12 2 1",
|
|
|
"# c #000000",
|
|
|
". c None",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
".....#......",
|
|
|
"....###.....",
|
|
|
"...#####....",
|
|
|
"..#######...",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............"};
|
|
|
|
|
|
static const char * const kstyle_unshade_xpm[] = {
|
|
|
"12 12 2 1",
|
|
|
"# c #000000",
|
|
|
". c None",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"..#######...",
|
|
|
"...#####....",
|
|
|
"....###.....",
|
|
|
".....#......",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............",
|
|
|
"............"};
|
|
|
|
|
|
static const char * const dock_window_close_xpm[] = {
|
|
|
"8 8 2 1",
|
|
|
"# c #000000",
|
|
|
". c None",
|
|
|
"##....##",
|
|
|
".##..##.",
|
|
|
"..####..",
|
|
|
"...##...",
|
|
|
"..####..",
|
|
|
".##..##.",
|
|
|
"##....##",
|
|
|
"........"};
|
|
|
|
|
|
// Message box icons, from page 210 of the Windows style guide.
|
|
|
|
|
|
// Hand-drawn to resemble Microsoft's icons, but in the Mac/Netscape
|
|
|
// palette. The "question mark" icon, which Microsoft recommends not
|
|
|
// using but a lot of people still use, is left out.
|
|
|
|
|
|
/* XPM */
|
|
|
static const char * const information_xpm[]={
|
|
|
"32 32 5 1",
|
|
|
". c None",
|
|
|
"c c #000000",
|
|
|
"* c #999999",
|
|
|
"a c #ffffff",
|
|
|
"b c #0000ff",
|
|
|
"...........********.............",
|
|
|
"........***aaaaaaaa***..........",
|
|
|
"......**aaaaaaaaaaaaaa**........",
|
|
|
".....*aaaaaaaaaaaaaaaaaa*.......",
|
|
|
"....*aaaaaaaabbbbaaaaaaaac......",
|
|
|
"...*aaaaaaaabbbbbbaaaaaaaac.....",
|
|
|
"..*aaaaaaaaabbbbbbaaaaaaaaac....",
|
|
|
".*aaaaaaaaaaabbbbaaaaaaaaaaac...",
|
|
|
".*aaaaaaaaaaaaaaaaaaaaaaaaaac*..",
|
|
|
"*aaaaaaaaaaaaaaaaaaaaaaaaaaaac*.",
|
|
|
"*aaaaaaaaaabbbbbbbaaaaaaaaaaac*.",
|
|
|
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
|
|
|
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
|
|
|
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
|
|
|
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
|
|
|
"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
|
|
|
".*aaaaaaaaaaabbbbbaaaaaaaaaac***",
|
|
|
".*aaaaaaaaaaabbbbbaaaaaaaaaac***",
|
|
|
"..*aaaaaaaaaabbbbbaaaaaaaaac***.",
|
|
|
"...caaaaaaabbbbbbbbbaaaaaac****.",
|
|
|
"....caaaaaaaaaaaaaaaaaaaac****..",
|
|
|
".....caaaaaaaaaaaaaaaaaac****...",
|
|
|
"......ccaaaaaaaaaaaaaacc****....",
|
|
|
".......*cccaaaaaaaaccc*****.....",
|
|
|
"........***cccaaaac*******......",
|
|
|
"..........****caaac*****........",
|
|
|
".............*caaac**...........",
|
|
|
"...............caac**...........",
|
|
|
"................cac**...........",
|
|
|
".................cc**...........",
|
|
|
"..................***...........",
|
|
|
"...................**..........."};
|
|
|
/* XPM */
|
|
|
static const char* const warning_xpm[]={
|
|
|
"32 32 4 1",
|
|
|
". c None",
|
|
|
"a c #ffff00",
|
|
|
"* c #000000",
|
|
|
"b c #999999",
|
|
|
".............***................",
|
|
|
"............*aaa*...............",
|
|
|
"...........*aaaaa*b.............",
|
|
|
"...........*aaaaa*bb............",
|
|
|
"..........*aaaaaaa*bb...........",
|
|
|
"..........*aaaaaaa*bb...........",
|
|
|
".........*aaaaaaaaa*bb..........",
|
|
|
".........*aaaaaaaaa*bb..........",
|
|
|
"........*aaaaaaaaaaa*bb.........",
|
|
|
"........*aaaa***aaaa*bb.........",
|
|
|
".......*aaaa*****aaaa*bb........",
|
|
|
".......*aaaa*****aaaa*bb........",
|
|
|
"......*aaaaa*****aaaaa*bb.......",
|
|
|
"......*aaaaa*****aaaaa*bb.......",
|
|
|
".....*aaaaaa*****aaaaaa*bb......",
|
|
|
".....*aaaaaa*****aaaaaa*bb......",
|
|
|
"....*aaaaaaaa***aaaaaaaa*bb.....",
|
|
|
"....*aaaaaaaa***aaaaaaaa*bb.....",
|
|
|
"...*aaaaaaaaa***aaaaaaaaa*bb....",
|
|
|
"...*aaaaaaaaaa*aaaaaaaaaa*bb....",
|
|
|
"..*aaaaaaaaaaa*aaaaaaaaaaa*bb...",
|
|
|
"..*aaaaaaaaaaaaaaaaaaaaaaa*bb...",
|
|
|
".*aaaaaaaaaaaa**aaaaaaaaaaa*bb..",
|
|
|
".*aaaaaaaaaaa****aaaaaaaaaa*bb..",
|
|
|
"*aaaaaaaaaaaa****aaaaaaaaaaa*bb.",
|
|
|
"*aaaaaaaaaaaaa**aaaaaaaaaaaa*bb.",
|
|
|
"*aaaaaaaaaaaaaaaaaaaaaaaaaaa*bbb",
|
|
|
"*aaaaaaaaaaaaaaaaaaaaaaaaaaa*bbb",
|
|
|
".*aaaaaaaaaaaaaaaaaaaaaaaaa*bbbb",
|
|
|
"..*************************bbbbb",
|
|
|
"....bbbbbbbbbbbbbbbbbbbbbbbbbbb.",
|
|
|
".....bbbbbbbbbbbbbbbbbbbbbbbbb.."};
|
|
|
/* XPM */
|
|
|
static const char* const critical_xpm[]={
|
|
|
"32 32 4 1",
|
|
|
". c None",
|
|
|
"a c #999999",
|
|
|
"* c #ff0000",
|
|
|
"b c #ffffff",
|
|
|
"...........********.............",
|
|
|
".........************...........",
|
|
|
".......****************.........",
|
|
|
"......******************........",
|
|
|
".....********************a......",
|
|
|
"....**********************a.....",
|
|
|
"...************************a....",
|
|
|
"..*******b**********b*******a...",
|
|
|
"..******bbb********bbb******a...",
|
|
|
".******bbbbb******bbbbb******a..",
|
|
|
".*******bbbbb****bbbbb*******a..",
|
|
|
"*********bbbbb**bbbbb*********a.",
|
|
|
"**********bbbbbbbbbb**********a.",
|
|
|
"***********bbbbbbbb***********aa",
|
|
|
"************bbbbbb************aa",
|
|
|
"************bbbbbb************aa",
|
|
|
"***********bbbbbbbb***********aa",
|
|
|
"**********bbbbbbbbbb**********aa",
|
|
|
"*********bbbbb**bbbbb*********aa",
|
|
|
".*******bbbbb****bbbbb*******aa.",
|
|
|
".******bbbbb******bbbbb******aa.",
|
|
|
"..******bbb********bbb******aaa.",
|
|
|
"..*******b**********b*******aa..",
|
|
|
"...************************aaa..",
|
|
|
"....**********************aaa...",
|
|
|
"....a********************aaa....",
|
|
|
".....a******************aaa.....",
|
|
|
"......a****************aaa......",
|
|
|
".......aa************aaaa.......",
|
|
|
".........aa********aaaaa........",
|
|
|
"...........aaaaaaaaaaa..........",
|
|
|
".............aaaaaaa............"};
|
|
|
|
|
|
TQPixmap TDEStyle::stylePixmap( StylePixmap stylepixmap,
|
|
|
const TQStyleControlElementData &ceData,
|
|
|
ControlElementFlags elementFlags,
|
|
|
const TQStyleOption& opt,
|
|
|
const TQWidget* widget) const
|
|
|
{
|
|
|
switch (stylepixmap) {
|
|
|
case SP_TitleBarShadeButton:
|
|
|
return TQPixmap(const_cast<const char**>(kstyle_shade_xpm));
|
|
|
case SP_TitleBarUnshadeButton:
|
|
|
return TQPixmap(const_cast<const char**>(kstyle_unshade_xpm));
|
|
|
case SP_TitleBarNormalButton:
|
|
|
return TQPixmap(const_cast<const char**>(kstyle_normalizeup_xpm));
|
|
|
case SP_TitleBarMinButton:
|
|
|
return TQPixmap(const_cast<const char**>(kstyle_minimize_xpm));
|
|
|
case SP_TitleBarMaxButton:
|
|
|
return TQPixmap(const_cast<const char**>(kstyle_maximize_xpm));
|
|
|
case SP_TitleBarCloseButton:
|
|
|
return TQPixmap(const_cast<const char**>(kstyle_close_xpm));
|
|
|
case SP_DockWindowCloseButton:
|
|
|
return TQPixmap(const_cast<const char**>(dock_window_close_xpm ));
|
|
|
case SP_MessageBoxInformation:
|
|
|
return TQPixmap(const_cast<const char**>(information_xpm));
|
|
|
case SP_MessageBoxWarning:
|
|
|
return TQPixmap(const_cast<const char**>(warning_xpm));
|
|
|
case SP_MessageBoxCritical:
|
|
|
return TQPixmap(const_cast<const char**>(critical_xpm));
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
return TQCommonStyle::stylePixmap(stylepixmap, ceData, elementFlags, opt, widget);
|
|
|
}
|
|
|
|
|
|
|
|
|
int TDEStyle::styleHint( TQ_StyleHint sh, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags,
|
|
|
const TQStyleOption &opt, TQStyleHintReturn* shr, const TQWidget* w) const
|
|
|
{
|
|
|
switch (sh)
|
|
|
{
|
|
|
case SH_EtchDisabledText:
|
|
|
return d->etchDisabledText ? 1 : 0;
|
|
|
|
|
|
case SH_PopupMenu_Scrollable:
|
|
|
return d->scrollablePopupmenus ? 1 : 0;
|
|
|
|
|
|
case SH_HideUnderlineAcceleratorWhenAltUp:
|
|
|
return d->autoHideAccelerators ? 1 : 0;
|
|
|
|
|
|
case SH_MenuBar_AltKeyNavigation:
|
|
|
return d->menuAltKeyNavigation ? 1 : 0;
|
|
|
|
|
|
case SH_PopupMenu_SubMenuPopupDelay:
|
|
|
if ( styleHint( SH_PopupMenu_SloppySubMenus, ceData, elementFlags, TQStyleOption::Default, 0, w ) )
|
|
|
return QMIN( 100, d->popupMenuDelay );
|
|
|
else
|
|
|
return d->popupMenuDelay;
|
|
|
|
|
|
case SH_PopupMenu_SloppySubMenus:
|
|
|
return d->sloppySubMenus;
|
|
|
|
|
|
case SH_ItemView_ChangeHighlightOnFocus:
|
|
|
case SH_Slider_SloppyKeyEvents:
|
|
|
case SH_MainWindow_SpaceBelowMenuBar:
|
|
|
case SH_PopupMenu_AllowActiveAndDisabled:
|
|
|
return 0;
|
|
|
|
|
|
case SH_Slider_SnapToValue:
|
|
|
case SH_PrintDialog_RightAlignButtons:
|
|
|
case SH_FontDialog_SelectAssociatedText:
|
|
|
case SH_MenuBar_MouseTracking:
|
|
|
case SH_PopupMenu_MouseTracking:
|
|
|
case SH_ComboBox_ListMouseTracking:
|
|
|
case SH_ScrollBar_MiddleClickAbsolutePosition:
|
|
|
return 1;
|
|
|
case SH_LineEdit_PasswordCharacter:
|
|
|
{
|
|
|
if (w) {
|
|
|
const TQFontMetrics &fm = w->fontMetrics();
|
|
|
if (fm.inFont(TQChar(0x25CF))) {
|
|
|
return 0x25CF;
|
|
|
} else if (fm.inFont(TQChar(0x2022))) {
|
|
|
return 0x2022;
|
|
|
}
|
|
|
}
|
|
|
return '*';
|
|
|
}
|
|
|
|
|
|
default:
|
|
|
return TQCommonStyle::styleHint(sh, ceData, elementFlags, opt, shr, w);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
bool TDEStyle::objectEventHandler( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void* source, TQEvent *event )
|
|
|
{
|
|
|
if (ceData.widgetObjectTypes.contains(TQOBJECT_OBJECT_NAME_STRING)) {
|
|
|
TQObject* object = reinterpret_cast<TQObject*>(source);
|
|
|
if ( d->useFilledFrameWorkaround )
|
|
|
{
|
|
|
// Make the QMenuBar/TQToolBar paintEvent() cover a larger area to
|
|
|
// ensure that the filled frame contents are properly painted.
|
|
|
// We essentially modify the paintEvent's rect to include the
|
|
|
// panel border, which also paints the widget's interior.
|
|
|
// This is nasty, but I see no other way to properly repaint
|
|
|
// filled frames in all QMenuBars and QToolBars.
|
|
|
// -- Karol.
|
|
|
TQFrame *frame = 0;
|
|
|
if ( event->type() == TQEvent::Paint
|
|
|
&& (frame = ::tqqt_cast<TQFrame*>(object)) )
|
|
|
{
|
|
|
if (frame->frameShape() != TQFrame::ToolBarPanel && frame->frameShape() != TQFrame::MenuBarPanel)
|
|
|
return false;
|
|
|
|
|
|
bool horizontal = true;
|
|
|
TQPaintEvent* pe = (TQPaintEvent*)event;
|
|
|
TQToolBar *toolbar = ::tqqt_cast< TQToolBar *>( frame );
|
|
|
TQRect r = pe->rect();
|
|
|
|
|
|
if (toolbar && toolbar->orientation() == Qt::Vertical)
|
|
|
horizontal = false;
|
|
|
|
|
|
if (horizontal) {
|
|
|
if ( r.height() == frame->height() )
|
|
|
return false; // Let TQFrame handle the painting now.
|
|
|
|
|
|
// Else, send a new paint event with an updated paint rect.
|
|
|
TQPaintEvent dummyPE( TQRect( r.x(), 0, r.width(), frame->height()) );
|
|
|
TQApplication::sendEvent( frame, &dummyPE );
|
|
|
}
|
|
|
else { // Vertical
|
|
|
if ( r.width() == frame->width() )
|
|
|
return false;
|
|
|
|
|
|
TQPaintEvent dummyPE( TQRect( 0, r.y(), frame->width(), r.height()) );
|
|
|
TQApplication::sendEvent( frame, &dummyPE );
|
|
|
}
|
|
|
|
|
|
// Discard this event as we sent a new paintEvent.
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
// I N T E R N A L - TDEStyle menu transparency handler
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
|
|
TransparencyHandler::TransparencyHandler( TDEStyle* style,
|
|
|
TransparencyEngine tEngine, float menuOpacity, bool useDropShadow )
|
|
|
: TQObject()
|
|
|
{
|
|
|
te = tEngine;
|
|
|
kstyle = style;
|
|
|
opacity = menuOpacity;
|
|
|
dropShadow = useDropShadow;
|
|
|
pix.setOptimization(TQPixmap::BestOptim);
|
|
|
}
|
|
|
|
|
|
TransparencyHandler::~TransparencyHandler()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
bool TransparencyHandler::haveX11RGBASupport()
|
|
|
{
|
|
|
// Simple way to determine if we have ARGB support
|
|
|
if (TQPaintDevice::x11AppDepth() == 32) {
|
|
|
return true;
|
|
|
}
|
|
|
else {
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#define REAL_ALPHA_STRENGTH 255.0
|
|
|
|
|
|
// This is meant to be ugly but fast.
|
|
|
void TransparencyHandler::rightShadow(TQImage& dst)
|
|
|
{
|
|
|
bool have_composite = haveX11RGBASupport();
|
|
|
|
|
|
if (dst.depth() != 32)
|
|
|
dst = dst.convertDepth(32);
|
|
|
|
|
|
// blend top-right corner.
|
|
|
int pixels = dst.width() * dst.height();
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
|
register unsigned char* data = dst.bits() + 1; // Skip alpha
|
|
|
#else
|
|
|
register unsigned char* data = dst.bits(); // Skip alpha
|
|
|
#endif
|
|
|
for(register int i = 0; i < 16; i++) {
|
|
|
if (have_composite) {
|
|
|
data++;
|
|
|
data++;
|
|
|
data++;
|
|
|
*data = (unsigned char)(REAL_ALPHA_STRENGTH*(1.0-top_right_corner[i])); data++;
|
|
|
}
|
|
|
else {
|
|
|
*data = (unsigned char)((*data)*top_right_corner[i]); data++;
|
|
|
*data = (unsigned char)((*data)*top_right_corner[i]); data++;
|
|
|
*data = (unsigned char)((*data)*top_right_corner[i]); data++;
|
|
|
data++; // skip alpha
|
|
|
}
|
|
|
}
|
|
|
|
|
|
pixels -= 32; // tint right strip without rounded edges.
|
|
|
register int c = 0;
|
|
|
for(register int i = 0; i < pixels; i++) {
|
|
|
if (have_composite) {
|
|
|
data++;
|
|
|
data++;
|
|
|
data++;;
|
|
|
*data = (unsigned char)(REAL_ALPHA_STRENGTH*(1.0-shadow_strip[c])); data++;
|
|
|
}
|
|
|
else {
|
|
|
*data = (unsigned char)((*data)*shadow_strip[c]); data++;
|
|
|
*data = (unsigned char)((*data)*shadow_strip[c]); data++;
|
|
|
*data = (unsigned char)((*data)*shadow_strip[c]); data++;
|
|
|
data++; // skip alpha
|
|
|
}
|
|
|
++c;
|
|
|
c %= 4;
|
|
|
}
|
|
|
|
|
|
// tint bottom edge
|
|
|
for(register int i = 0; i < 16; i++) {
|
|
|
if (have_composite) {
|
|
|
data++;
|
|
|
data++;
|
|
|
data++;
|
|
|
*data = (unsigned char)(REAL_ALPHA_STRENGTH*(1.0-bottom_right_corner[i])); data++;
|
|
|
}
|
|
|
else {
|
|
|
*data = (unsigned char)((*data)*bottom_right_corner[i]); data++;
|
|
|
*data = (unsigned char)((*data)*bottom_right_corner[i]); data++;
|
|
|
*data = (unsigned char)((*data)*bottom_right_corner[i]); data++;
|
|
|
data++; // skip alpha
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void TransparencyHandler::bottomShadow(TQImage& dst)
|
|
|
{
|
|
|
bool have_composite = haveX11RGBASupport();
|
|
|
|
|
|
if (dst.depth() != 32)
|
|
|
dst = dst.convertDepth(32);
|
|
|
|
|
|
int line = 0;
|
|
|
int width = dst.width() - 4;
|
|
|
double strip_data = shadow_strip[0];
|
|
|
double* corner = const_cast<double*>(bottom_left_corner);
|
|
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
|
register unsigned char* data = dst.bits() + 1; // Skip alpha
|
|
|
#else
|
|
|
register unsigned char* data = dst.bits(); // Skip alpha
|
|
|
#endif
|
|
|
|
|
|
for(int y = 0; y < 4; y++)
|
|
|
{
|
|
|
// Bottom-left Corner
|
|
|
for(register int x = 0; x < 4; x++) {
|
|
|
if (have_composite) {
|
|
|
data++;
|
|
|
data++;
|
|
|
data++;
|
|
|
*data = (unsigned char)(REAL_ALPHA_STRENGTH*(1.0-(*corner))); data++;
|
|
|
}
|
|
|
else {
|
|
|
*data = (unsigned char)((*data)*(*corner)); data++;
|
|
|
*data = (unsigned char)((*data)*(*corner)); data++;
|
|
|
*data = (unsigned char)((*data)*(*corner)); data++;
|
|
|
data++; // skip alpha
|
|
|
}
|
|
|
corner++;
|
|
|
}
|
|
|
|
|
|
// Scanline
|
|
|
for(register int x = 0; x < width; x++) {
|
|
|
if (have_composite) {
|
|
|
data++;
|
|
|
data++;
|
|
|
data++;
|
|
|
*data = (unsigned char)(REAL_ALPHA_STRENGTH*(1.0-strip_data)); data++;
|
|
|
}
|
|
|
else {
|
|
|
*data = (unsigned char)((*data)*strip_data); data++;
|
|
|
*data = (unsigned char)((*data)*strip_data); data++;
|
|
|
*data = (unsigned char)((*data)*strip_data); data++;
|
|
|
data++; // skip alpha
|
|
|
}
|
|
|
}
|
|
|
|
|
|
strip_data = shadow_strip[++line];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
TQImage TransparencyHandler::handleRealAlpha(TQImage img) {
|
|
|
TQImage clearImage = img.convertDepth(32);
|
|
|
clearImage.setAlphaBuffer(true);
|
|
|
|
|
|
int w = clearImage.width();
|
|
|
int h = clearImage.height();
|
|
|
|
|
|
for (int y = 0; y < h; ++y) {
|
|
|
TQRgb *ls = (TQRgb *)clearImage.scanLine( y );
|
|
|
for (int x = 0; x < w; ++x) {
|
|
|
ls[x] = tqRgba( 0, 0, 0, 0 );
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return clearImage;
|
|
|
}
|
|
|
|
|
|
// Create a shadow of thickness 4.
|
|
|
void TransparencyHandler::createShadowWindows(const TQWidget* p)
|
|
|
{
|
|
|
#ifdef Q_WS_X11
|
|
|
int x2 = p->x()+p->width();
|
|
|
int y2 = p->y()+p->height();
|
|
|
TQRect shadow1(x2, p->y() + 4, 4, p->height());
|
|
|
TQRect shadow2(p->x() + 4, y2, p->width() - 4, 4);
|
|
|
|
|
|
bool have_composite = haveX11RGBASupport();
|
|
|
|
|
|
// Create a fake drop-down shadow effect via blended Xwindows
|
|
|
ShadowElements se;
|
|
|
se.w1 = new TQWidget(0, 0, (WFlags)(WStyle_Customize | WType_Popup | WX11BypassWM) );
|
|
|
se.w2 = new TQWidget(0, 0, (WFlags)(WStyle_Customize | WType_Popup | WX11BypassWM) );
|
|
|
se.w1->setGeometry(shadow1);
|
|
|
se.w2->setGeometry(shadow2);
|
|
|
XSelectInput(tqt_xdisplay(), se.w1->winId(), StructureNotifyMask );
|
|
|
XSelectInput(tqt_xdisplay(), se.w2->winId(), StructureNotifyMask );
|
|
|
|
|
|
// Insert a new ShadowMap entry
|
|
|
shadowMap()[p] = se;
|
|
|
|
|
|
// Some hocus-pocus here to create the drop-shadow.
|
|
|
TQPixmap pix_shadow1;
|
|
|
TQPixmap pix_shadow2;
|
|
|
if (have_composite) {
|
|
|
pix_shadow1 = TQPixmap(shadow1.width(), shadow1.height());
|
|
|
pix_shadow2 = TQPixmap(shadow2.width(), shadow2.height());
|
|
|
}
|
|
|
else {
|
|
|
pix_shadow1 = TQPixmap::grabWindow(tqt_xrootwin(),
|
|
|
shadow1.x(), shadow1.y(), shadow1.width(), shadow1.height());
|
|
|
pix_shadow2 = TQPixmap::grabWindow(tqt_xrootwin(),
|
|
|
shadow2.x(), shadow2.y(), shadow2.width(), shadow2.height());
|
|
|
}
|
|
|
|
|
|
TQImage img;
|
|
|
img = pix_shadow1.convertToImage();
|
|
|
if (have_composite) img = handleRealAlpha(img);
|
|
|
rightShadow(img);
|
|
|
pix_shadow1.convertFromImage(img);
|
|
|
img = pix_shadow2.convertToImage();
|
|
|
if (have_composite) img = handleRealAlpha(img);
|
|
|
bottomShadow(img);
|
|
|
pix_shadow2.convertFromImage(img);
|
|
|
|
|
|
// Set the background pixmaps
|
|
|
se.w1->setErasePixmap(pix_shadow1);
|
|
|
se.w2->setErasePixmap(pix_shadow2);
|
|
|
|
|
|
// Show the 'shadow' just before showing the popup menu window
|
|
|
// Don't use TQWidget::show() so we don't confuse QEffects, thus causing broken focus.
|
|
|
XMapWindow(tqt_xdisplay(), se.w1->winId());
|
|
|
XMapWindow(tqt_xdisplay(), se.w2->winId());
|
|
|
#else
|
|
|
Q_UNUSED( p )
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
void TransparencyHandler::removeShadowWindows(const TQWidget* p)
|
|
|
{
|
|
|
#ifdef Q_WS_X11
|
|
|
ShadowMap::iterator it = shadowMap().find(p);
|
|
|
if (it != shadowMap().end())
|
|
|
{
|
|
|
ShadowElements se = it.data();
|
|
|
XUnmapWindow(tqt_xdisplay(), se.w1->winId()); // hide
|
|
|
XUnmapWindow(tqt_xdisplay(), se.w2->winId());
|
|
|
XFlush(tqt_xdisplay()); // try to hide faster
|
|
|
delete se.w1;
|
|
|
delete se.w2;
|
|
|
shadowMap().erase(it);
|
|
|
}
|
|
|
#else
|
|
|
Q_UNUSED( p )
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
bool TransparencyHandler::eventFilter( TQObject* object, TQEvent* event )
|
|
|
{
|
|
|
#if !defined Q_WS_MAC && !defined Q_WS_WIN
|
|
|
// Transparency idea was borrowed from KDE2's "MegaGradient" Style,
|
|
|
// Copyright (C) 2000 Daniel M. Duley <mosfet@kde.org>
|
|
|
|
|
|
// Added 'fake' menu shadows <04-Jul-2002> -- Karol
|
|
|
TQWidget* p = (TQWidget*)object;
|
|
|
TQEvent::Type et = event->type();
|
|
|
|
|
|
if (et == TQEvent::Show)
|
|
|
{
|
|
|
// Handle translucency
|
|
|
if (te != Disabled)
|
|
|
{
|
|
|
pix = TQPixmap::grabWindow(tqt_xrootwin(),
|
|
|
p->x(), p->y(), p->width(), p->height());
|
|
|
|
|
|
switch (te) {
|
|
|
#ifdef HAVE_XRENDER
|
|
|
case XRender:
|
|
|
if (tqt_use_xrender) {
|
|
|
XRenderBlendToPixmap(p);
|
|
|
break;
|
|
|
}
|
|
|
// Fall through intended
|
|
|
#else
|
|
|
case XRender:
|
|
|
#endif
|
|
|
case SoftwareBlend:
|
|
|
blendToPixmap(p->colorGroup(), p);
|
|
|
break;
|
|
|
|
|
|
case SoftwareTint:
|
|
|
default:
|
|
|
blendToColor(p->colorGroup().button());
|
|
|
};
|
|
|
|
|
|
p->setErasePixmap(pix);
|
|
|
}
|
|
|
|
|
|
// Handle drop shadow
|
|
|
// * FIXME : !shadowMap().contains(p) is a workaround for leftover
|
|
|
// * shadows after duplicate show events.
|
|
|
// * TODO : determine real cause for duplicate events
|
|
|
// * till 20021005
|
|
|
if ((dropShadow || useDropShadow(p))
|
|
|
&& p->width() > 16 && p->height() > 16 && !shadowMap().contains( p ))
|
|
|
createShadowWindows(p);
|
|
|
}
|
|
|
else if (et == TQEvent::Resize && p->isShown() && p->isTopLevel())
|
|
|
{
|
|
|
// Handle drop shadow
|
|
|
if (dropShadow || useDropShadow(p))
|
|
|
{
|
|
|
removeShadowWindows(p);
|
|
|
createShadowWindows(p);
|
|
|
}
|
|
|
}
|
|
|
else if (et == TQEvent::Hide)
|
|
|
{
|
|
|
// Handle drop shadow
|
|
|
if (dropShadow || useDropShadow(p))
|
|
|
removeShadowWindows(p);
|
|
|
|
|
|
// Handle translucency
|
|
|
if (te != Disabled)
|
|
|
p->setErasePixmap(TQPixmap());
|
|
|
}
|
|
|
|
|
|
#endif
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Blends a TQImage to a predefined color, with a given opacity.
|
|
|
void TransparencyHandler::blendToColor(const TQColor &col)
|
|
|
{
|
|
|
if (opacity < 0.0 || opacity > 1.0)
|
|
|
return;
|
|
|
|
|
|
TQImage img = pix.convertToImage();
|
|
|
KImageEffect::blend(col, img, opacity);
|
|
|
pix.convertFromImage(img);
|
|
|
}
|
|
|
|
|
|
|
|
|
void TransparencyHandler::blendToPixmap(const TQColorGroup &cg, const TQWidget* p)
|
|
|
{
|
|
|
if (opacity < 0.0 || opacity > 1.0)
|
|
|
return;
|
|
|
|
|
|
KPixmap blendPix;
|
|
|
blendPix.resize( pix.width(), pix.height() );
|
|
|
|
|
|
if (blendPix.width() != pix.width() ||
|
|
|
blendPix.height() != pix.height())
|
|
|
return;
|
|
|
|
|
|
// Allow styles to define the blend pixmap - allows for some interesting effects.
|
|
|
if (::tqqt_cast<TQPopupMenu*>(p))
|
|
|
kstyle->renderMenuBlendPixmap( blendPix, cg, ::tqqt_cast<TQPopupMenu*>(p) );
|
|
|
else
|
|
|
blendPix.fill(cg.button()); // Just tint as the default behavior
|
|
|
|
|
|
TQImage blendImg = blendPix.convertToImage();
|
|
|
TQImage backImg = pix.convertToImage();
|
|
|
KImageEffect::blend(blendImg, backImg, opacity);
|
|
|
pix.convertFromImage(backImg);
|
|
|
}
|
|
|
|
|
|
|
|
|
#ifdef HAVE_XRENDER
|
|
|
// Here we go, use XRender in all its glory.
|
|
|
// NOTE: This is actually a bit slower than the above routines
|
|
|
// on non-accelerated displays. -- Karol.
|
|
|
void TransparencyHandler::XRenderBlendToPixmap(const TQWidget* p)
|
|
|
{
|
|
|
KPixmap renderPix;
|
|
|
renderPix.resize( pix.width(), pix.height() );
|
|
|
|
|
|
// Allow styles to define the blend pixmap - allows for some interesting effects.
|
|
|
if (::tqqt_cast<TQPopupMenu*>(p))
|
|
|
kstyle->renderMenuBlendPixmap( renderPix, p->colorGroup(),
|
|
|
::tqqt_cast<TQPopupMenu*>(p) );
|
|
|
else
|
|
|
renderPix.fill(p->colorGroup().button()); // Just tint as the default behavior
|
|
|
|
|
|
Display* dpy = tqt_xdisplay();
|
|
|
Pixmap alphaPixmap;
|
|
|
Picture alphaPicture;
|
|
|
XRenderPictFormat Rpf;
|
|
|
XRenderPictureAttributes Rpa;
|
|
|
XRenderColor clr;
|
|
|
clr.alpha = ((unsigned short)(255*opacity) << 8);
|
|
|
|
|
|
Rpf.type = PictTypeDirect;
|
|
|
Rpf.depth = 8;
|
|
|
Rpf.direct.alphaMask = 0xff;
|
|
|
Rpa.repeat = True; // Tile
|
|
|
|
|
|
XRenderPictFormat* xformat = XRenderFindFormat(dpy,
|
|
|
PictFormatType | PictFormatDepth | PictFormatAlphaMask, &Rpf, 0);
|
|
|
|
|
|
alphaPixmap = XCreatePixmap(dpy, p->handle(), 1, 1, 8);
|
|
|
alphaPicture = XRenderCreatePicture(dpy, alphaPixmap, xformat, CPRepeat, &Rpa);
|
|
|
|
|
|
XRenderFillRectangle(dpy, PictOpSrc, alphaPicture, &clr, 0, 0, 1, 1);
|
|
|
|
|
|
XRenderComposite(dpy, PictOpOver,
|
|
|
renderPix.x11RenderHandle(), alphaPicture, pix.x11RenderHandle(), // src, mask, dst
|
|
|
0, 0, // srcx, srcy
|
|
|
0, 0, // maskx, masky
|
|
|
0, 0, // dstx, dsty
|
|
|
pix.width(), pix.height());
|
|
|
|
|
|
XRenderFreePicture(dpy, alphaPicture);
|
|
|
XFreePixmap(dpy, alphaPixmap);
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
void TDEStyle::virtual_hook( int, void* )
|
|
|
{ /*BASE::virtual_hook( id, data );*/ }
|
|
|
|
|
|
// HACK for gtk-qt-engine
|
|
|
|
|
|
extern "C" KDE_EXPORT
|
|
|
void kde_kstyle_set_scrollbar_type_windows( void* style )
|
|
|
{
|
|
|
((TDEStyle*)style)->setScrollBarType( TDEStyle::WindowsStyleScrollBar );
|
|
|
}
|
|
|
|
|
|
// vim: set noet ts=4 sw=4:
|
|
|
// kate: indent-width 4; replace-tabs off; tab-width 4; space-indent off;
|
|
|
|
|
|
#include "tdestyle.moc"
|