TDE
/
tdeartwork
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdeartwork
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 'fed5a8d5ad'
${ noResults }
tdeartwork/twin-styles/glow/glowclient.cpp

906 lines
26 KiB
Raw Blame History

/***************************************************************************
glowclient.cpp - description
-------------------
begin : Thu Sep 6 2001
copyright : (C) 2001 by Henning Burchardt
email : h_burchardt@gmx.net
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include <tqapplication.h>
#include <tqbitmap.h>
#include <tqimage.h>
#include <tqlayout.h>
#include <tqpainter.h>
#include <tqpixmap.h>
#include <tdeconfig.h>
#include <kdebug.h>
#include <tdelocale.h>
#include <kpixmapeffect.h>
#include <kpixmap.h>
#include <kstandarddirs.h>
#include <tqlabel.h>
#include "resources.h"
#include "glowclient.h"
#include "glowbutton.h"
namespace Glow
{
static int titleHeight;
static int SIDE_MARGIN;
static int BOTTOM_MARGIN;
static const int TITLE_MARGIN = 2;
static const int TITLE_SPACING = 1;
static int RESIZE_HANDLE_HEIGHT;
//-----------------------------------------------------------------------------
GlowClientConfig::GlowClientConfig()
{
themeName = "default";
}
void GlowClientConfig::load(KDecorationFactory *factory)
{
TDEConfig conf("twinglowrc");
conf.setGroup("General");
const TQColor defaultCloseButtonColor(DEFAULT_CLOSE_BUTTON_COLOR);
const TQColor defaultMaximizeButtonColor(DEFAULT_MAXIMIZE_BUTTON_COLOR);
const TQColor defaultIconifyButtonColor(DEFAULT_ICONIFY_BUTTON_COLOR);
const TQColor defaultHelpButtonColor(DEFAULT_HELP_BUTTON_COLOR);
const TQColor defaultStickyButtonColor(DEFAULT_STICKY_BUTTON_COLOR);
stickyButtonGlowColor = conf.readColorEntry(
"stickyButtonGlowColor", &defaultStickyButtonColor);
helpButtonGlowColor = conf.readColorEntry(
"helpButtonGlowColor", &defaultHelpButtonColor);
iconifyButtonGlowColor = conf.readColorEntry(
"iconifyButtonGlowColor", &defaultIconifyButtonColor);
maximizeButtonGlowColor = conf.readColorEntry(
"maximizeButtonGlowColor", &defaultMaximizeButtonColor);
closeButtonGlowColor = conf.readColorEntry(
"closeButtonGlowColor", &defaultCloseButtonColor);
showResizeHandle = conf.readBoolEntry("showResizeHandle", true);
titlebarGradientType = conf.readNumEntry("titlebarGradientType",
KPixmapEffect::DiagonalGradient);
themeName = conf.readEntry ("themeName", "default");
switch(KDecoration::options()->preferredBorderSize (factory)) {
case KDecoration::BorderLarge:
SIDE_MARGIN = 8;
BOTTOM_MARGIN = 6;
RESIZE_HANDLE_HEIGHT = 10;
break;
case KDecoration::BorderVeryLarge:
SIDE_MARGIN = 12;
BOTTOM_MARGIN = 12;
RESIZE_HANDLE_HEIGHT = 18;
break;
case KDecoration::BorderHuge:
SIDE_MARGIN = 18;
BOTTOM_MARGIN = 18;
RESIZE_HANDLE_HEIGHT = 27;
break;
case KDecoration::BorderVeryHuge:
SIDE_MARGIN = 27;
BOTTOM_MARGIN = 27;
RESIZE_HANDLE_HEIGHT = 40;
break;
case KDecoration::BorderOversized:
SIDE_MARGIN = 40;
BOTTOM_MARGIN = 40;
RESIZE_HANDLE_HEIGHT = 60;
break;
case KDecoration::BorderNormal:
default:
SIDE_MARGIN = 4;
BOTTOM_MARGIN = 2;
RESIZE_HANDLE_HEIGHT = 4;
}
}
//-----------------------------------------------------------------------------
GlowClientGlobals::~GlowClientGlobals()
{
deletePixmaps();
m_instance = 0;
}
TQString GlowClientGlobals::getPixmapName(PixmapType type, bool isActive)
{
TQString s = getPixmapTypeName(static_cast<PixmapType>(type));
s += "|";
s += isActive ? "Active" : "NotActive";
return s;
}
GlowClientGlobals::GlowClientGlobals()
: KDecorationFactory()
{
TDEGlobal::locale()->insertCatalogue("twin_clients");
TDEGlobal::locale()->insertCatalogue("twin_art_clients");
_button_factory = new GlowButtonFactory();
readConfig();
readTheme ();
if (!createPixmaps())
{
deletePixmaps();
delete _theme;
config()->themeName = "default";
readTheme();
createPixmaps();
}
}
void GlowClientGlobals::readConfig()
{
_config = new GlowClientConfig();
_config->load(this);
}
TQValueList< GlowClientGlobals::BorderSize >
GlowClientGlobals::borderSizes() const
{
// the list must be sorted
return TQValueList< BorderSize >() << BorderNormal <<
BorderLarge << BorderVeryLarge << BorderHuge <<
BorderVeryHuge << BorderOversized;
}
void GlowClientGlobals::readTheme()
{
TQString theme_config_file = TDEGlobal::dirs()->findResource ("data",
TQString("twin/glow-themes/") + config()->themeName + "/" +
config()->themeName + ".theme");
if (theme_config_file.isNull())
{
config()->themeName = "default";
return;
}
TDEConfig conf (theme_config_file);
_theme = new GlowTheme(default_glow_theme);
_theme->buttonSize = conf.readSizeEntry ("buttonSize",
&_theme->buttonSize);
_theme->stickyOnPixmap = conf.readEntry ("stickyOnPixmap",
_theme->stickyOnPixmap);
_theme->stickyOffPixmap = conf.readEntry ("stickyOffPixmap",
_theme->stickyOffPixmap);
_theme->maximizeOnPixmap = conf.readEntry ("maximizeOnPixmap",
_theme->maximizeOnPixmap);
_theme->maximizeOffPixmap = conf.readEntry ("maximizeOffPixmap",
_theme->maximizeOffPixmap);
_theme->helpPixmap = conf.readEntry ("helpPixmap",
_theme->helpPixmap);
_theme->closePixmap = conf.readEntry ("closePixmap",
_theme->closePixmap);
_theme->iconifyPixmap = conf.readEntry ("iconifyPixmap",
_theme->iconifyPixmap);
_theme->stickyOnGlowPixmap = conf.readEntry ("stickyOnGlowPixmap",
_theme->stickyOnGlowPixmap);
_theme->stickyOffGlowPixmap = conf.readEntry ("stickyOffGlowPixmap",
_theme->stickyOffGlowPixmap);
_theme->maximizeOnGlowPixmap = conf.readEntry ("maximizeOnGlowPixmap",
_theme->maximizeOnGlowPixmap);
_theme->maximizeOffGlowPixmap = conf.readEntry ("maximizeOffGlowPixmap",
_theme->maximizeOffGlowPixmap);
_theme->helpGlowPixmap = conf.readEntry ("helpGlowPixmap",
_theme->helpGlowPixmap);
_theme->closeGlowPixmap = conf.readEntry ("closeGlowPixmap",
_theme->closeGlowPixmap);
_theme->iconifyGlowPixmap = conf.readEntry ("iconifyGlowPixmap",
_theme->iconifyGlowPixmap);
titleHeight = TQFontMetrics(KDecoration::options()->font(true)).height();
if (titleHeight < SIDE_MARGIN)
titleHeight = SIDE_MARGIN;
if (titleHeight < _theme->buttonSize.height())
titleHeight = _theme->buttonSize.height();
}
bool GlowClientGlobals::reset( unsigned long /*changed*/ )
{
deletePixmaps();
delete _config;
readConfig();
delete _theme;
readTheme ();
if (! createPixmaps())
{
deletePixmaps();
delete _theme;
_config->themeName = "default";
readTheme();
createPixmaps();
}
return true; // FRAME
}
bool GlowClientGlobals::supports( Ability ability )
{
switch( ability )
{
case AbilityAnnounceButtons:
case AbilityButtonOnAllDesktops:
case AbilityButtonSpacer:
case AbilityButtonHelp:
case AbilityButtonMinimize:
case AbilityButtonMaximize:
case AbilityButtonClose:
return true;
default:
return false;
};
}
bool GlowClientGlobals::createPixmaps()
{
for( int type=0; type<=Close; type++ ) {
if (! createPixmap(static_cast<PixmapType>(type), false))
return false;
if (! createPixmap(static_cast<PixmapType>(type), true))
return false;
}
return true;
}
void GlowClientGlobals::deletePixmaps()
{
PixmapCache::clear();
}
const TQString GlowClientGlobals::getPixmapTypeName(PixmapType type)
{
switch(type) {
case (StickyOn):
return "StickyOn";
case(StickyOff ):
return "StickyOff";
case(Help):
return "Help";
case(Iconify):
return "Iconify";
case(MaximizeOn):
return "MaximizeOn";
case(MaximizeOff):
return "MaximizeOff";
case(Close):
return "Close";
default:
return TQString();
}
}
bool GlowClientGlobals::createPixmap(PixmapType type, bool isActive)
{
TQString theme_dir = TDEGlobal::dirs()->findResource ("data",
TQString("twin/glow-themes/") + _config->themeName + "/");
TQColor glow_color;
TQColor color = options()->color(ColorButtonBg, isActive);
TQImage bg_image (theme_dir+_theme->backgroundPixmap);
TQImage fg_image;
TQImage glow_image;
switch(type) {
case (StickyOn):
{
fg_image = TQImage (theme_dir+_theme->stickyOnPixmap);
glow_image = TQImage (theme_dir+_theme->stickyOnGlowPixmap);
glow_color = _config->stickyButtonGlowColor;
break;
}
case (StickyOff):
{
fg_image = TQImage (theme_dir+_theme->stickyOffPixmap);
glow_image = TQImage (theme_dir+_theme->stickyOffGlowPixmap);
glow_color = _config->stickyButtonGlowColor;
break;
}
case (Help):
{
fg_image = TQImage (theme_dir+_theme->helpPixmap);
glow_image = TQImage (theme_dir+_theme->helpGlowPixmap);
glow_color = _config->helpButtonGlowColor;
break;
}
case (Iconify):
{
fg_image = TQImage (theme_dir+_theme->iconifyPixmap);
glow_image = TQImage (theme_dir+_theme->iconifyGlowPixmap);
glow_color = _config->iconifyButtonGlowColor;
break;
}
case (MaximizeOn):
{
fg_image = TQImage (theme_dir+_theme->maximizeOnPixmap);
glow_image = TQImage (theme_dir+_theme->maximizeOnGlowPixmap);
glow_color = _config->maximizeButtonGlowColor;
break;
}
case (MaximizeOff):
{
fg_image = TQImage (theme_dir+_theme->maximizeOffPixmap);
glow_image = TQImage (theme_dir+_theme->maximizeOffGlowPixmap);
glow_color = _config->maximizeButtonGlowColor;
break;
}
case (Close):
{
fg_image = TQImage (theme_dir+_theme->closePixmap);
glow_image = TQImage (theme_dir+_theme->closeGlowPixmap);
glow_color = _config->closeButtonGlowColor;
break;
}
}
if (bg_image.size() != _theme->buttonSize
|| fg_image.size() != _theme->buttonSize
|| glow_image.size() != _theme->buttonSize)
return false;
TQPixmap * glowPm = buttonFactory()->createGlowButtonPixmap(
bg_image, fg_image, glow_image,
color, glow_color);
if (glowPm->isNull())
return false;
PixmapCache::insert(getPixmapName(type, isActive), glowPm);
return true;
}
GlowClientGlobals *GlowClientGlobals::m_instance = 0;
GlowClientGlobals *GlowClientGlobals::instance()
{
if( ! m_instance )
{
m_instance = new GlowClientGlobals();
}
return m_instance;
}
//-----------------------------------------------------------------------------
GlowClient::GlowClient( KDecorationBridge* b, KDecorationFactory* f )
: KDecoration( b, f ),
m_stickyButton(0), m_helpButton(0), m_minimizeButton(0),
m_maximizeButton(0), m_closeButton(0),
m_leftButtonLayout(0), m_rightButtonLayout(0), _main_layout(0)
{
}
void GlowClient::init()
{
createMainWidget(WResizeNoErase | WStaticContents | WRepaintNoErase);
widget()->installEventFilter(this);
createButtons();
resetLayout();
}
GlowClient::~GlowClient()
{
PixmapCache::erase(TQString::number(widget()->winId()));
}
void GlowClient::resizeEvent( TQResizeEvent * )
{
doShape();
widget()->repaint(false);
}
void GlowClient::paintEvent( TQPaintEvent * )
{
GlowClientConfig *conf = GlowClientGlobals::instance()->config();
TQRect r_this = widget()->rect();
TQRect r_title = _title_spacer->geometry();
TQColorGroup titleCg = options()->colorGroup(ColorTitleBar, isActive());
TQColorGroup titleBlendCg=options()->colorGroup(ColorTitleBlend, isActive());
TQColorGroup cg = widget()->colorGroup();
TQColor titleColor = options()->color(ColorTitleBar, isActive());
TQColor titleBlendColor = options()->color(ColorTitleBlend, isActive());
TQColor bgColor = widget()->colorGroup().background();
TQPainter p;
TQPointArray pArray, pArray2, pArray3, pArray4;
// pixmap for title bar
TQSize tBSize(width(), r_title.height());
TQSize gradientPixmapSize (tBSize-TQSize(3,3));
if (! gradientPixmapSize.isValid())
gradientPixmapSize = TQSize(0,0);
KPixmap gradientPixmap(gradientPixmapSize);
if (! gradientPixmapSize.isNull())
KPixmapEffect::gradient(gradientPixmap, titleColor, titleBlendColor,
(KPixmapEffect::GradientType) conf->titlebarGradientType);
TQPixmap * title_buffer = new TQPixmap(tBSize);
p.begin(title_buffer);
if (! gradientPixmap.isNull())
p.drawPixmap(2, 2, gradientPixmap);
if (tBSize.width()>=3 && tBSize.height()>=3)
{
// draw caption
p.setFont(options()->font(isActive()));
p.setPen(options()->color(ColorFont, isActive()));
p.drawText(r_title.x(), 0,
r_title.width(), r_title.height(),
TQt::AlignLeft | TQt::AlignVCenter | TQt::SingleLine, caption());
// draw split color beneath buttons top right
pArray4 = TQPointArray(4);
pArray4.setPoint(0, tBSize.width()-1, tBSize.height()/2-1);
pArray4.setPoint(1, r_title.x()+r_title.width()-1+tBSize.height()/2,
tBSize.height()/2-1);
pArray4.setPoint(2, r_title.x()+r_title.width()-1, tBSize.height());
pArray4.setPoint(3, tBSize.width()-1, tBSize.height());
p.setPen(TQt::NoPen);
p.setBrush(bgColor);
p.drawPolygon(pArray4);
// draw borders
pArray = TQPointArray(3);
pArray.setPoint(0, tBSize.width()-1, tBSize.height()/2-1);
pArray.setPoint(1, r_title.x()+r_title.width()-1+tBSize.height()/2,
tBSize.height()/2-1);
pArray.setPoint(2, r_title.x()+r_title.width()-1, tBSize.height()-1);
p.setPen(titleCg.mid());
p.drawPolyline(pArray);
p.drawLine (0, tBSize.height()-1, r_title.x()+r_title.width()-1, tBSize.height()-1);
pArray2 = TQPointArray(3);
pArray2.setPoint(0, 1, tBSize.height()-2);
pArray2.setPoint(1, 1, 1);
pArray2.setPoint(2, tBSize.width()-2, 1);
p.setPen(titleCg.light());
p.drawPolyline(pArray2);
}
pArray3 = TQPointArray(4);
pArray3.setPoint(0, 0, tBSize.height()-1);
pArray3.setPoint(1, 0, 0);
pArray3.setPoint(2, tBSize.width()-1, 0);
pArray3.setPoint(3, tBSize.width()-1, tBSize.height()-1);
p.setPen(TQt::black);
p.drawPolyline(pArray3);
p.end();
// insert title buffer in cache; before that, remove old buffer
PixmapCache::erase(TQString::number(widget()->winId()));
PixmapCache::insert(TQString::number(widget()->winId()), title_buffer);
bitBlt(widget(), 0, 0, title_buffer);
for (unsigned int i=0; i<m_buttonList.size(); ++i)
m_buttonList[i]->repaint(false);
p.begin(widget());
p.setPen(TQt::black);
//-----
// draw borders
p.drawLine(0,tBSize.height(),0,r_this.height()-1);
p.drawLine(0,r_this.height()-1,r_this.width()-1,r_this.height()-1);
p.drawLine(r_this.width()-1,r_this.height()-1,
r_this.width()-1,tBSize.height()/2);
//-----
// fill content widget
p.fillRect(1, tBSize.height(),
r_this.width()-2, r_this.height()-tBSize.height()-1,
options()->colorGroup(ColorFrame, isActive()).background());
p.end();
// paint resize handle if necessary
if(conf->showResizeHandle && isResizable() && ! isShade()
&& width()>=2 && height() >= RESIZE_HANDLE_HEIGHT)
{
p.begin(widget());
p.setPen (TQt::black);
p.drawLine (1, height() - RESIZE_HANDLE_HEIGHT,
width()-2, height() - RESIZE_HANDLE_HEIGHT);
p.end();
}
}
void GlowClient::showEvent( TQShowEvent * )
{
doShape();
widget()->repaint(false);
}
void GlowClient::mouseDoubleClickEvent( TQMouseEvent *e )
{
if(e->button() == Qt::LeftButton && _title_spacer->geometry().contains(e->pos()))
titlebarDblClickOperation();
}
void GlowClient::wheelEvent( TQWheelEvent *e )
{
if (isSetShade() || TQRect( 0, 0, width(), titleHeight ).contains(e->pos()))
titlebarMouseWheelOperation( e->delta());
}
void GlowClient::activeChange()
{
updateButtonPixmaps();
widget()->repaint(false);
}
void GlowClient::iconChange()
{
// we have no (t yet an) icon button, so do nothing
}
void GlowClient::shadeChange()
{
}
void GlowClient::captionChange()
{
widget()->update(_title_spacer->geometry());
}
TQSize GlowClient::minimumSize() const
{
return widget()->minimumSize();
}
void GlowClient::resize( const TQSize& s )
{
widget()->resize( s );
}
void GlowClient::borders( int& left, int& right, int& top, int& bottom ) const
{
left = right = SIDE_MARGIN;
top = titleHeight + TITLE_MARGIN + 1;
if (GlowClientGlobals::instance()->config()->showResizeHandle
&& isResizable())
bottom = RESIZE_HANDLE_HEIGHT;
else
bottom = BOTTOM_MARGIN;
}
void GlowClient::desktopChange()
{
if (isOnAllDesktops()) {
m_stickyButton->setPixmapName(
GlowClientGlobals::instance()->getPixmapName(
GlowClientGlobals::StickyOn, isActive()));
m_stickyButton->setTipText(i18n("Not on all desktops"));
} else {
m_stickyButton->setPixmapName(
GlowClientGlobals::instance()->getPixmapName(
GlowClientGlobals::StickyOff, isActive()));
m_stickyButton->setTipText(i18n("On all desktops"));
}
}
void GlowClient::maximizeChange()
{
if (maximizeMode() == MaximizeFull) {
m_maximizeButton->setPixmapName(
GlowClientGlobals::instance()->getPixmapName(
GlowClientGlobals::MaximizeOn, isActive()));
m_maximizeButton->setTipText(i18n("Restore"));
} else {
m_maximizeButton->setPixmapName(
GlowClientGlobals::instance()->getPixmapName(
GlowClientGlobals::MaximizeOff, isActive()));
m_maximizeButton->setTipText(i18n("Maximize"));
}
}
KDecoration::Position GlowClient::mousePosition(const TQPoint &pos) const
{
Position m = PositionCenter;
int bottomSize
= (GlowClientGlobals::instance()->config()->showResizeHandle)
? RESIZE_HANDLE_HEIGHT : BOTTOM_MARGIN;
const int range = 14 + 3*SIDE_MARGIN/2;
if ( ( pos.x() > SIDE_MARGIN && pos.x() < width() - SIDE_MARGIN )
&& ( pos.y() > 4 && pos.y() < height() - bottomSize ) )
m = PositionCenter;
else if ( pos.y() <= range && pos.x() <= range)
m = PositionTopLeft;
else if ( pos.y() >= height()-range && pos.x() >= width()-range)
m = PositionBottomRight;
else if ( pos.y() >= height()-range && pos.x() <= range)
m = PositionBottomLeft;
else if ( pos.y() <= range && pos.x() >= width()-range)
m = PositionTopRight;
else if ( pos.y() <= 4 )
m = PositionTop;
else if ( pos.y() >= height()-bottomSize )
m = PositionBottom;
else if ( pos.x() <= SIDE_MARGIN )
m = PositionLeft;
else if ( pos.x() >= width()-SIDE_MARGIN )
m = PositionRight;
else
m = PositionCenter;
return m;
}
void GlowClient::createButtons()
{
GlowClientGlobals *globals = GlowClientGlobals::instance();
GlowButtonFactory *factory = globals->buttonFactory();
TQSize size = globals->theme()->buttonSize;
m_stickyButton = factory->createGlowButton(widget(),
"StickyButton", isOnAllDesktops()?i18n("Not on all desktops"):i18n("On all desktops"), Qt::LeftButton|Qt::RightButton);
m_stickyButton->setFixedSize(size);
connect(m_stickyButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(toggleOnAllDesktops()));
m_buttonList.insert(m_buttonList.end(), m_stickyButton);
m_helpButton = factory->createGlowButton(widget(),
"HelpButton", i18n("Help"));
m_helpButton->setFixedSize(size);
connect(m_helpButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(showContextHelp()));
m_buttonList.insert(m_buttonList.end(), m_helpButton);
m_minimizeButton = factory->createGlowButton(widget(),
"IconifyButton", i18n("Minimize"));
m_minimizeButton->setFixedSize(size);
connect(m_minimizeButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(minimize()));
m_buttonList.insert(m_buttonList.end(), m_minimizeButton);
m_maximizeButton=factory->createGlowButton(widget(),
"MaximizeButton", i18n("Maximize"), Qt::LeftButton|Qt::MidButton|Qt::RightButton);
m_maximizeButton->setFixedSize(size);
connect(m_maximizeButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotMaximize()));
m_buttonList.insert(m_buttonList.end(), m_maximizeButton);
m_closeButton = factory->createGlowButton(widget(),
"CloseButton", i18n("Close"));
m_closeButton->setFixedSize(size);
connect(m_closeButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(closeWindow()));
m_buttonList.insert(m_buttonList.end(), m_closeButton);
}
void GlowClient::resetLayout()
{
_main_layout = new TQVBoxLayout(widget(), 0, 0);
_main_layout->setResizeMode (TQLayout::FreeResize);
// update button positions and colors
updateButtonPositions();
updateButtonPixmaps();
TQBoxLayout * topLayout = new TQBoxLayout(_main_layout,
TQBoxLayout::LeftToRight, 0, 0);
topLayout->setMargin(0);
topLayout->setSpacing(TITLE_SPACING);
topLayout->addSpacing(SIDE_MARGIN);
TQVBoxLayout *outerLeftLayout = new TQVBoxLayout(topLayout);
outerLeftLayout->addSpacing(TITLE_MARGIN);
outerLeftLayout->addItem(m_leftButtonLayout);
outerLeftLayout->addSpacing(1);
topLayout->addSpacing(SIDE_MARGIN);
_title_spacer = new TQSpacerItem(0, titleHeight + TITLE_MARGIN + 1,
TQSizePolicy::Expanding, TQSizePolicy::Fixed);
topLayout->addItem(_title_spacer);
topLayout->addSpacing(SIDE_MARGIN);
TQVBoxLayout *outerRightLayout = new TQVBoxLayout(topLayout);
outerRightLayout->addSpacing(TITLE_MARGIN);
outerRightLayout->addItem(m_rightButtonLayout);
outerRightLayout->addSpacing(1);
topLayout->addSpacing(SIDE_MARGIN);
TQBoxLayout *midLayout = new TQBoxLayout(
_main_layout, TQBoxLayout::LeftToRight, 0, 0);
midLayout->addSpacing(SIDE_MARGIN);
if(isPreview())
midLayout->addWidget(
new TQLabel( i18n( "<b><center>Glow preview</center></b>" ), widget()));
else
midLayout->addItem( new TQSpacerItem( 0, 0 ));
midLayout->addSpacing(SIDE_MARGIN);
if(GlowClientGlobals::instance()->config()->showResizeHandle
&& isResizable() ) {
_bottom_spacer = new TQSpacerItem(SIDE_MARGIN*2,
RESIZE_HANDLE_HEIGHT, TQSizePolicy::Expanding, TQSizePolicy::Minimum);
} else {
_bottom_spacer = new TQSpacerItem(SIDE_MARGIN*2,
BOTTOM_MARGIN, TQSizePolicy::Expanding, TQSizePolicy::Minimum);
}
_main_layout->addItem (_bottom_spacer);
_main_layout->setStretchFactor(topLayout, 0);
_main_layout->setStretchFactor(midLayout, 1);
}
void GlowClient::updateButtonPositions()
{
TQString buttons = options()->titleButtonsLeft() + "|"
+ options()->titleButtonsRight();
bool leftButtons=true;
// hide all buttons
for( unsigned int i=0; i<m_buttonList.size(); i++ )
m_buttonList[i]->hide();
m_leftButtonList.clear();
m_rightButtonList.clear();
// reset left and right button layout
if(m_leftButtonLayout)
delete m_leftButtonLayout;
m_leftButtonLayout = new TQBoxLayout(0, TQBoxLayout::LeftToRight, 0, 0, 0);
m_leftButtonLayout->setMargin(0);
m_leftButtonLayout->setSpacing(TITLE_SPACING);
if(m_rightButtonLayout)
delete m_rightButtonLayout;
m_rightButtonLayout = new TQBoxLayout(0, TQBoxLayout::LeftToRight, 0, 0, 0);
m_rightButtonLayout->setMargin(0);
m_rightButtonLayout->setSpacing(TITLE_SPACING);
for( unsigned int i=0; i<buttons.length(); i++ )
{
char c = buttons[i].latin1();
GlowButton *button = 0;
if( c=='S' ) // sticky
button = m_stickyButton;
else if( c=='H' && providesContextHelp() ) // help
button = m_helpButton;
else if( c=='I' && isMinimizable() ) // iconify
button = m_minimizeButton;
else if( c=='A' && isMaximizable() ) // maximize
button = m_maximizeButton;
else if( c=='X' && isCloseable() ) // close
button= m_closeButton;
else if( c=='_' ) // spacer item
{
if(leftButtons)
m_leftButtonLayout->addSpacing(4);
else
m_rightButtonLayout->addSpacing(4);
}
else if( c=='|' )
leftButtons = false;
if (button) {
button->show(); // show visible buttons
if (leftButtons) {
m_leftButtonList.insert(m_leftButtonList.end(), button);
m_leftButtonLayout->addWidget(button);
} else {
m_rightButtonList.insert(m_rightButtonList.end(), button);
m_rightButtonLayout->addWidget(button);
}
}
}
}
void GlowClient::updateButtonPixmaps()
{
GlowClientGlobals *globals = GlowClientGlobals::instance();
if ( isOnAllDesktops() ) {
m_stickyButton->setPixmapName(globals->getPixmapName(
GlowClientGlobals::StickyOn, isActive()));
} else {
m_stickyButton->setPixmapName(globals->getPixmapName(
GlowClientGlobals::StickyOff, isActive()));
}
m_helpButton->setPixmapName(globals->getPixmapName(
GlowClientGlobals::Help, isActive()));
m_minimizeButton->setPixmapName(globals->getPixmapName(
GlowClientGlobals::Iconify, isActive()));
if ( maximizeMode() == MaximizeFull ) {
m_maximizeButton->setPixmapName(globals->getPixmapName(
GlowClientGlobals::MaximizeOn, isActive()));
} else {
m_maximizeButton->setPixmapName(globals->getPixmapName(
GlowClientGlobals::MaximizeOff, isActive()));
}
m_closeButton->setPixmapName(globals->getPixmapName(
GlowClientGlobals::Close, isActive()));
}
void GlowClient::doShape()
{
TQRegion mask(widget()->rect());
// edges
mask -= TQRegion(width()-1,0,1,1);
mask -= TQRegion(0,height()-1,1,1);
mask -= TQRegion(width()-1,height()-1,1,1);
setMask(mask);
}
bool GlowClient::isLeft(GlowButton *button)
{
for( unsigned int i=0; i<m_leftButtonList.size(); i++ )
if( m_leftButtonList[i] == button )
return true;
return false;
}
bool GlowClient::isRight(GlowButton *button)
{
for( unsigned int i=0; i<m_rightButtonList.size(); i++ )
if( m_rightButtonList[i] == button )
return true;
return false;
}
void GlowClient::slotMaximize()
{
maximize(m_maximizeButton->lastButton());
}
bool GlowClient::eventFilter( TQObject* o, TQEvent* e )
{
if( TQT_BASE_OBJECT(o) != TQT_BASE_OBJECT(widget()))
return false;
switch( e->type())
{
case TQEvent::Resize:
resizeEvent( TQT_TQRESIZEEVENT( e ));
return true;
case TQEvent::Paint:
paintEvent( TQT_TQPAINTEVENT( e ));
return true;
case TQEvent::MouseButtonDblClick:
mouseDoubleClickEvent( TQT_TQMOUSEEVENT( e ));
return true;
case TQEvent::MouseButtonPress:
processMousePressEvent( TQT_TQMOUSEEVENT( e ));
return true;
case TQEvent::Show:
showEvent( TQT_TQSHOWEVENT( e ));
return true;
case TQEvent::Wheel:
wheelEvent( TQT_TQWHEELEVENT( e ));
return true;
default:
break;
}
return false;
}
KDecoration* GlowClientGlobals::createDecoration( KDecorationBridge* bridge )
{
return new GlowClient( bridge, this );
}
} // end of namespace
extern "C"
KDE_EXPORT KDecorationFactory* create_factory()
{
return Glow::GlowClientGlobals::instance();
}
#include "glowclient.moc"
View Git Blame Copy Permalink