summaryrefslogtreecommitdiffstats
path: root/kwin/clients/default
diff options
context:
space:
mode:
Diffstat (limited to 'kwin/clients/default')
-rw-r--r--kwin/clients/default/Makefile.am14
-rw-r--r--kwin/clients/default/config/Makefile.am16
-rw-r--r--kwin/clients/default/config/config.cpp131
-rw-r--r--kwin/clients/default/config/config.h49
-rw-r--r--kwin/clients/default/kdedefault.cpp1069
-rw-r--r--kwin/clients/default/kdedefault.h103
6 files changed, 1382 insertions, 0 deletions
diff --git a/kwin/clients/default/Makefile.am b/kwin/clients/default/Makefile.am
new file mode 100644
index 000000000..3f9b1e7e7
--- /dev/null
+++ b/kwin/clients/default/Makefile.am
@@ -0,0 +1,14 @@
+
+INCLUDES = -I$(srcdir)/../../lib $(all_includes)
+
+SUBDIRS = . config
+
+kde_module_LTLIBRARIES = kwin3_default.la
+
+kwin3_default_la_SOURCES = kdedefault.cpp
+kwin3_default_la_LDFLAGS = $(all_libraries) $(KDE_PLUGIN) -module
+kwin3_default_la_LIBADD = $(LIB_KDECORE) ../../lib/libkdecorations.la
+
+METASOURCES = AUTO
+noinst_HEADERS = kdedefault.h
+
diff --git a/kwin/clients/default/config/Makefile.am b/kwin/clients/default/config/Makefile.am
new file mode 100644
index 000000000..a6e09522a
--- /dev/null
+++ b/kwin/clients/default/config/Makefile.am
@@ -0,0 +1,16 @@
+INCLUDES = $(all_includes)
+
+kde_module_LTLIBRARIES = kwin_default_config.la
+
+kwin_default_config_la_SOURCES = config.cpp
+kwin_default_config_la_LDFLAGS = $(all_libraries) $(KDE_PLUGIN) -module
+kwin_default_config_la_LIBADD = $(LIB_KDEUI)
+
+METASOURCES = AUTO
+noinst_HEADERS = config.h
+
+lnkdir = $(kde_datadir)/kwin/
+
+###KMAKE-start (don't edit or delete this block)
+
+###KMAKE-end
diff --git a/kwin/clients/default/config/config.cpp b/kwin/clients/default/config/config.cpp
new file mode 100644
index 000000000..2ad494fa9
--- /dev/null
+++ b/kwin/clients/default/config/config.cpp
@@ -0,0 +1,131 @@
+/*
+ *
+ * KDE2 Default configuration widget
+ *
+ * Copyright (c) 2001
+ * Karol Szwed <gallium@kde.org>
+ * http://gallium.n3.net/
+ */
+
+#include "config.h"
+#include <kglobal.h>
+#include <qwhatsthis.h>
+#include <kdialog.h>
+#include <klocale.h>
+#include <qpixmap.h>
+#include <qvbox.h>
+
+extern "C"
+{
+ KDE_EXPORT QObject* allocate_config( KConfig* conf, QWidget* parent )
+ {
+ return(new KDEDefaultConfig(conf, parent));
+ }
+}
+
+// NOTE:
+// 'conf' is a pointer to the kwindecoration modules open kwin config,
+// and is by default set to the "Style" group.
+// 'parent' is the parent of the QObject, which is a VBox inside the
+// Configure tab in kwindecoration
+
+KDEDefaultConfig::KDEDefaultConfig( KConfig* conf, QWidget* parent )
+ : QObject( parent )
+{
+ KGlobal::locale()->insertCatalogue("kwin_clients");
+ highcolor = QPixmap::defaultDepth() > 8;
+ gb = new QVBox( parent );
+ gb->setSpacing( KDialog::spacingHint() );
+
+ cbShowStipple = new QCheckBox( i18n("Draw titlebar &stipple effect"), gb );
+ QWhatsThis::add( cbShowStipple,
+ i18n("When selected, active titlebars are drawn "
+ "with a stipple (dotted) effect; otherwise, they are "
+ "drawn without the stipple."));
+
+ cbShowGrabBar = new QCheckBox( i18n("Draw g&rab bar below windows"), gb );
+ QWhatsThis::add( cbShowGrabBar,
+ i18n("When selected, decorations are drawn with a \"grab bar\" "
+ "below windows; otherwise, no grab bar is drawn."));
+
+ // Only show the gradient checkbox for highcolor displays
+ if (highcolor)
+ {
+ cbUseGradients = new QCheckBox( i18n("Draw &gradients"), gb );
+ QWhatsThis::add( cbUseGradients,
+ i18n("When selected, decorations are drawn with gradients "
+ "for high-color displays; otherwise, no gradients are drawn.") );
+ }
+
+ // Load configuration options
+ load( conf );
+
+ // Ensure we track user changes properly
+ connect( cbShowStipple, SIGNAL(clicked()),
+ this, SLOT(slotSelectionChanged()) );
+ connect( cbShowGrabBar, SIGNAL(clicked()),
+ this, SLOT(slotSelectionChanged()) );
+ if (highcolor)
+ connect( cbUseGradients, SIGNAL(clicked()),
+ this, SLOT(slotSelectionChanged()) );
+
+ // Make the widgets visible in kwindecoration
+ gb->show();
+}
+
+
+KDEDefaultConfig::~KDEDefaultConfig()
+{
+ delete gb;
+}
+
+
+void KDEDefaultConfig::slotSelectionChanged()
+{
+ emit changed();
+}
+
+
+// Loads the configurable options from the kwinrc config file
+// It is passed the open config from kwindecoration to improve efficiency
+void KDEDefaultConfig::load( KConfig* conf )
+{
+ conf->setGroup("KDEDefault");
+ bool override = conf->readBoolEntry( "ShowTitleBarStipple", true );
+ cbShowStipple->setChecked( override );
+
+ override = conf->readBoolEntry( "ShowGrabBar", true );
+ cbShowGrabBar->setChecked( override );
+
+ if (highcolor) {
+ override = conf->readBoolEntry( "UseGradients", true );
+ cbUseGradients->setChecked( override );
+ }
+}
+
+
+// Saves the configurable options to the kwinrc config file
+void KDEDefaultConfig::save( KConfig* conf )
+{
+ conf->setGroup("KDEDefault");
+ conf->writeEntry( "ShowTitleBarStipple", cbShowStipple->isChecked() );
+ conf->writeEntry( "ShowGrabBar", cbShowGrabBar->isChecked() );
+
+ if (highcolor)
+ conf->writeEntry( "UseGradients", cbUseGradients->isChecked() );
+ // No need to conf->sync() - kwindecoration will do it for us
+}
+
+
+// Sets UI widget defaults which must correspond to style defaults
+void KDEDefaultConfig::defaults()
+{
+ cbShowStipple->setChecked( true );
+ cbShowGrabBar->setChecked( true );
+
+ if (highcolor)
+ cbUseGradients->setChecked( true );
+}
+
+#include "config.moc"
+// vim: ts=4
diff --git a/kwin/clients/default/config/config.h b/kwin/clients/default/config/config.h
new file mode 100644
index 000000000..248d851df
--- /dev/null
+++ b/kwin/clients/default/config/config.h
@@ -0,0 +1,49 @@
+/*
+ *
+ * KDE2 Default configuration widget
+ *
+ * Copyright (c) 2001
+ * Karol Szwed <gallium@kde.org>
+ * http://gallium.n3.net/
+ */
+
+#ifndef _KDE_DEFAULT_CONFIG_H
+#define _KDE_DEFAULT_CONFIG_H
+
+#include <qcheckbox.h>
+#include <qgroupbox.h>
+#include <kconfig.h>
+#include <qhbox.h>
+#include <qlabel.h>
+#include <qvbox.h>
+
+class KDEDefaultConfig: public QObject
+{
+ Q_OBJECT
+
+ public:
+ KDEDefaultConfig( KConfig* conf, QWidget* parent );
+ ~KDEDefaultConfig();
+
+ // These public signals/slots work similar to KCM modules
+ signals:
+ void changed();
+
+ public slots:
+ void load( KConfig* conf );
+ void save( KConfig* conf );
+ void defaults();
+
+ protected slots:
+ void slotSelectionChanged(); // Internal use
+
+ private:
+ QCheckBox* cbShowStipple;
+ QCheckBox* cbShowGrabBar;
+ QCheckBox* cbUseGradients;
+ QVBox* gb;
+ bool highcolor;
+};
+
+#endif
+// vim: ts=4
diff --git a/kwin/clients/default/kdedefault.cpp b/kwin/clients/default/kdedefault.cpp
new file mode 100644
index 000000000..aeb1b2065
--- /dev/null
+++ b/kwin/clients/default/kdedefault.cpp
@@ -0,0 +1,1069 @@
+/*
+ *
+ * KDE2 Default KWin client
+ *
+ * Copyright (C) 1999, 2001 Daniel Duley <mosfet@kde.org>
+ * Matthias Ettrich <ettrich@kde.org>
+ * Karol Szwed <gallium@kde.org>
+ *
+ * Draws mini titlebars for tool windows.
+ * Many features are now customizable.
+ */
+
+#include "kdedefault.h"
+
+#include <kconfig.h>
+#include <kglobal.h>
+#include <kpixmapeffect.h>
+#include <kimageeffect.h>
+#include <kdrawutil.h>
+#include <klocale.h>
+#include <qlayout.h>
+#include <qdrawutil.h>
+#include <qbitmap.h>
+#include <qimage.h>
+#include <qtooltip.h>
+#include <qapplication.h>
+#include <qlabel.h>
+#include <kdebug.h>
+
+namespace Default
+{
+
+static const unsigned char iconify_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00,
+ 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char close_bits[] = {
+ 0x00, 0x00, 0x84, 0x00, 0xce, 0x01, 0xfc, 0x00, 0x78, 0x00, 0x78, 0x00,
+ 0xfc, 0x00, 0xce, 0x01, 0x84, 0x00, 0x00, 0x00};
+
+static const unsigned char maximize_bits[] = {
+ 0x00, 0x00, 0xfe, 0x01, 0xfe, 0x01, 0x86, 0x01, 0x86, 0x01, 0x86, 0x01,
+ 0x86, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0x00, 0x00};
+
+static const unsigned char minmax_bits[] = {
+ 0x7f, 0x00, 0x7f, 0x00, 0x63, 0x00, 0xfb, 0x03, 0xfb, 0x03, 0x1f, 0x03,
+ 0x1f, 0x03, 0x18, 0x03, 0xf8, 0x03, 0xf8, 0x03};
+
+static const unsigned char question_bits[] = {
+ 0x00, 0x00, 0x78, 0x00, 0xcc, 0x00, 0xc0, 0x00, 0x60, 0x00, 0x30, 0x00,
+ 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00};
+
+static const unsigned char above_on_bits[] = {
+ 0x00, 0x00, 0xfe, 0x01, 0xfe, 0x01, 0x30, 0x00, 0xfc, 0x00, 0x78, 0x00,
+ 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static const unsigned char above_off_bits[] = {
+ 0x30, 0x00, 0x78, 0x00, 0xfc, 0x00, 0x30, 0x00, 0xfe, 0x01, 0xfe, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static const unsigned char below_on_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x78, 0x00, 0xfc, 0x00,
+ 0x30, 0x00, 0xfe, 0x01, 0xfe, 0x01, 0x00, 0x00 };
+
+static const unsigned char below_off_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x01, 0xfe, 0x01,
+ 0x30, 0x00, 0xfc, 0x00, 0x78, 0x00, 0x30, 0x00 };
+
+static const unsigned char shade_on_bits[] = {
+ 0x00, 0x00, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0xfe, 0x01, 0x00, 0x00 };
+
+static const unsigned char shade_off_bits[] = {
+ 0x00, 0x00, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static const unsigned char pindown_white_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x80, 0x1f, 0xa0, 0x03,
+ 0xb0, 0x01, 0x30, 0x01, 0xf0, 0x00, 0x70, 0x00, 0x20, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char pindown_gray_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c,
+ 0x00, 0x0e, 0x00, 0x06, 0x00, 0x00, 0x80, 0x07, 0xc0, 0x03, 0xe0, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char pindown_dgray_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xc0, 0x10, 0x70, 0x20, 0x50, 0x20,
+ 0x48, 0x30, 0xc8, 0x38, 0x08, 0x1f, 0x08, 0x18, 0x10, 0x1c, 0x10, 0x0e,
+ 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char pindown_mask_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xc0, 0x1f, 0xf0, 0x3f, 0xf0, 0x3f,
+ 0xf8, 0x3f, 0xf8, 0x3f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf0, 0x1f, 0xf0, 0x0f,
+ 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char pinup_white_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x11,
+ 0x3f, 0x15, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char pinup_gray_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x80, 0x0a, 0xbf, 0x0a, 0x80, 0x15, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char pinup_dgray_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x20, 0x40, 0x31, 0x40, 0x2e,
+ 0x40, 0x20, 0x40, 0x20, 0x7f, 0x2a, 0x40, 0x3f, 0xc0, 0x31, 0xc0, 0x20,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+static const unsigned char pinup_mask_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x20, 0xc0, 0x31, 0xc0, 0x3f,
+ 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xc0, 0x3f, 0xc0, 0x31, 0xc0, 0x20,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+// ===========================================================================
+
+static QPixmap* titlePix;
+static KPixmap* titleBuffer;
+static KPixmap* aUpperGradient;
+static KPixmap* iUpperGradient;
+
+static KPixmap* pinDownPix;
+static KPixmap* pinUpPix;
+static KPixmap* ipinDownPix;
+static KPixmap* ipinUpPix;
+
+static KPixmap* rightBtnUpPix[2];
+static KPixmap* rightBtnDownPix[2];
+static KPixmap* irightBtnUpPix[2];
+static KPixmap* irightBtnDownPix[2];
+
+static KPixmap* leftBtnUpPix[2];
+static KPixmap* leftBtnDownPix[2];
+static KPixmap* ileftBtnUpPix[2];
+static KPixmap* ileftBtnDownPix[2];
+
+static KDEDefaultHandler* clientHandler;
+static int toolTitleHeight;
+static int normalTitleHeight;
+static int borderWidth;
+static int grabBorderWidth;
+static bool KDEDefault_initialized = false;
+static bool useGradients;
+static bool showGrabBar;
+static bool showTitleBarStipple;
+
+
+// ===========================================================================
+
+KDEDefaultHandler::KDEDefaultHandler()
+{
+ clientHandler = this;
+ readConfig( false );
+ createPixmaps();
+ KDEDefault_initialized = true;
+}
+
+
+KDEDefaultHandler::~KDEDefaultHandler()
+{
+ KDEDefault_initialized = false;
+ freePixmaps();
+ clientHandler = NULL;
+}
+
+KDecoration* KDEDefaultHandler::createDecoration( KDecorationBridge* b )
+{
+ return new KDEDefaultClient( b, this );
+}
+
+bool KDEDefaultHandler::reset( unsigned long changed )
+{
+ KDEDefault_initialized = false;
+ changed |= readConfig( true );
+ if( changed & SettingColors )
+ { // pixmaps need to be recreated
+ freePixmaps();
+ createPixmaps();
+ }
+ KDEDefault_initialized = true;
+ // SettingButtons is handled by KCommonDecoration
+ bool need_recreate = ( changed & ( SettingDecoration | SettingFont | SettingBorder )) != 0;
+ if( need_recreate ) // something else than colors changed
+ return true;
+ resetDecorations( changed );
+ return false;
+}
+
+
+unsigned long KDEDefaultHandler::readConfig( bool update )
+{
+ unsigned long changed = 0;
+ KConfig* conf = KGlobal::config();
+ conf->setGroup("KDEDefault");
+
+ bool new_showGrabBar = conf->readBoolEntry("ShowGrabBar", true);
+ bool new_showTitleBarStipple = conf->readBoolEntry("ShowTitleBarStipple", true);
+ bool new_useGradients = conf->readBoolEntry("UseGradients", true);
+ int new_titleHeight = QFontMetrics(options()->font(true)).height();
+ int new_toolTitleHeight = QFontMetrics(options()->font(true, true)).height()-2;
+
+ int new_borderWidth;
+ switch(options()->preferredBorderSize(this)) {
+ case BorderLarge:
+ new_borderWidth = 8;
+ break;
+ case BorderVeryLarge:
+ new_borderWidth = 12;
+ break;
+ case BorderHuge:
+ new_borderWidth = 18;
+ break;
+ case BorderVeryHuge:
+ new_borderWidth = 27;
+ break;
+ case BorderOversized:
+ new_borderWidth = 40;
+ break;
+ case BorderTiny:
+ case BorderNormal:
+ default:
+ new_borderWidth = 4;
+ }
+
+ if (new_titleHeight < 16) new_titleHeight = 16;
+ if (new_titleHeight < new_borderWidth) new_titleHeight = new_borderWidth;
+ if (new_toolTitleHeight < 12) new_toolTitleHeight = 12;
+ if (new_toolTitleHeight < new_borderWidth) new_toolTitleHeight = new_borderWidth;
+
+ if( update )
+ {
+ if( new_showGrabBar != showGrabBar
+ || new_titleHeight != normalTitleHeight
+ || new_toolTitleHeight != toolTitleHeight
+ || new_borderWidth != borderWidth )
+ changed |= SettingDecoration; // need recreating the decoration
+ if( new_showTitleBarStipple != showTitleBarStipple
+ || new_useGradients != useGradients
+ || new_titleHeight != normalTitleHeight
+ || new_toolTitleHeight != toolTitleHeight )
+ changed |= SettingColors; // just recreate the pixmaps and repaint
+ }
+
+ showGrabBar = new_showGrabBar;
+ showTitleBarStipple = new_showTitleBarStipple;
+ useGradients = new_useGradients;
+ normalTitleHeight = new_titleHeight;
+ toolTitleHeight = new_toolTitleHeight;
+ borderWidth = new_borderWidth;
+ grabBorderWidth = (borderWidth > 15) ? borderWidth + 15 : 2*borderWidth;
+ return changed;
+}
+
+
+// This paints the button pixmaps upon loading the style.
+void KDEDefaultHandler::createPixmaps()
+{
+ bool highcolor = useGradients && (QPixmap::defaultDepth() > 8);
+
+ // Make the titlebar stipple optional
+ if (showTitleBarStipple)
+ {
+ QPainter p;
+ QPainter maskPainter;
+ int i, x, y;
+ titlePix = new QPixmap(132, normalTitleHeight+2);
+ QBitmap mask(132, normalTitleHeight+2);
+ mask.fill(Qt::color0);
+
+ p.begin(titlePix);
+ maskPainter.begin(&mask);
+ maskPainter.setPen(Qt::color1);
+ for(i=0, y=2; i < 9; ++i, y+=4)
+ for(x=1; x <= 132; x+=3)
+ {
+ p.setPen(options()->color(ColorTitleBar, true).light(150));
+ p.drawPoint(x, y);
+ maskPainter.drawPoint(x, y);
+ p.setPen(options()->color(ColorTitleBar, true).dark(150));
+ p.drawPoint(x+1, y+1);
+ maskPainter.drawPoint(x+1, y+1);
+ }
+ maskPainter.end();
+ p.end();
+ titlePix->setMask(mask);
+ } else
+ titlePix = NULL;
+
+ QColor activeTitleColor1(options()->color(ColorTitleBar, true));
+ QColor activeTitleColor2(options()->color(ColorTitleBlend, true));
+
+ QColor inactiveTitleColor1(options()->color(ColorTitleBar, false));
+ QColor inactiveTitleColor2(options()->color(ColorTitleBlend, false));
+
+ // Create titlebar gradient images if required
+ aUpperGradient = NULL;
+ iUpperGradient = NULL;
+
+ if(highcolor)
+ {
+ // Create the titlebar gradients
+ if (activeTitleColor1 != activeTitleColor2)
+ {
+ aUpperGradient = new KPixmap;
+ aUpperGradient->resize(128, normalTitleHeight+2);
+ KPixmapEffect::gradient(*aUpperGradient,
+ activeTitleColor1,
+ activeTitleColor2,
+ KPixmapEffect::VerticalGradient);
+ }
+
+ if (inactiveTitleColor1 != inactiveTitleColor2)
+ {
+ iUpperGradient = new KPixmap;
+ iUpperGradient->resize(128, normalTitleHeight+2);
+
+ KPixmapEffect::gradient(*iUpperGradient,
+ inactiveTitleColor1,
+ inactiveTitleColor2,
+ KPixmapEffect::VerticalGradient);
+ }
+ }
+
+ // Set the sticky pin pixmaps;
+ QColorGroup g;
+ QPainter p;
+
+ // Active pins
+ g = options()->colorGroup( ColorButtonBg, true );
+ pinUpPix = new KPixmap();
+ pinUpPix->resize(16, 16);
+ p.begin( pinUpPix );
+ kColorBitmaps( &p, g, 0, 0, 16, 16, true, pinup_white_bits,
+ pinup_gray_bits, NULL, NULL, pinup_dgray_bits, NULL );
+ p.end();
+ pinUpPix->setMask( QBitmap(16, 16, pinup_mask_bits, true) );
+
+ pinDownPix = new KPixmap();
+ pinDownPix->resize(16, 16);
+ p.begin( pinDownPix );
+ kColorBitmaps( &p, g, 0, 0, 16, 16, true, pindown_white_bits,
+ pindown_gray_bits, NULL, NULL, pindown_dgray_bits, NULL );
+ p.end();
+ pinDownPix->setMask( QBitmap(16, 16, pindown_mask_bits, true) );
+
+ // Inactive pins
+ g = options()->colorGroup( ColorButtonBg, false );
+ ipinUpPix = new KPixmap();
+ ipinUpPix->resize(16, 16);
+ p.begin( ipinUpPix );
+ kColorBitmaps( &p, g, 0, 0, 16, 16, true, pinup_white_bits,
+ pinup_gray_bits, NULL, NULL, pinup_dgray_bits, NULL );
+ p.end();
+ ipinUpPix->setMask( QBitmap(16, 16, pinup_mask_bits, true) );
+
+ ipinDownPix = new KPixmap();
+ ipinDownPix->resize(16, 16);
+ p.begin( ipinDownPix );
+ kColorBitmaps( &p, g, 0, 0, 16, 16, true, pindown_white_bits,
+ pindown_gray_bits, NULL, NULL, pindown_dgray_bits, NULL );
+ p.end();
+ ipinDownPix->setMask( QBitmap(16, 16, pindown_mask_bits, true) );
+
+ // Create a title buffer for flicker-free painting
+ titleBuffer = new KPixmap();
+
+ // Cache all possible button states
+ leftBtnUpPix[true] = new KPixmap();
+ leftBtnUpPix[true]->resize(normalTitleHeight, normalTitleHeight);
+ leftBtnDownPix[true] = new KPixmap();
+ leftBtnDownPix[true]->resize(normalTitleHeight, normalTitleHeight);
+ ileftBtnUpPix[true] = new KPixmap();
+ ileftBtnUpPix[true]->resize(normalTitleHeight, normalTitleHeight);
+ ileftBtnDownPix[true] = new KPixmap();
+ ileftBtnDownPix[true]->resize(normalTitleHeight, normalTitleHeight);
+
+ rightBtnUpPix[true] = new KPixmap();
+ rightBtnUpPix[true]->resize(normalTitleHeight, normalTitleHeight);
+ rightBtnDownPix[true] = new KPixmap();
+ rightBtnDownPix[true]->resize(normalTitleHeight, normalTitleHeight);
+ irightBtnUpPix[true] = new KPixmap();
+ irightBtnUpPix[true]->resize(normalTitleHeight, normalTitleHeight);
+ irightBtnDownPix[true] = new KPixmap();
+ irightBtnDownPix[true]->resize(normalTitleHeight, normalTitleHeight);
+
+ leftBtnUpPix[false] = new KPixmap();
+ leftBtnUpPix[false]->resize(toolTitleHeight, normalTitleHeight);
+ leftBtnDownPix[false] = new KPixmap();
+ leftBtnDownPix[false]->resize(toolTitleHeight, normalTitleHeight);
+ ileftBtnUpPix[false] = new KPixmap();
+ ileftBtnUpPix[false]->resize(normalTitleHeight, normalTitleHeight);
+ ileftBtnDownPix[false] = new KPixmap();
+ ileftBtnDownPix[false]->resize(normalTitleHeight, normalTitleHeight);
+
+ rightBtnUpPix[false] = new KPixmap();
+ rightBtnUpPix[false]->resize(toolTitleHeight, toolTitleHeight);
+ rightBtnDownPix[false] = new KPixmap();
+ rightBtnDownPix[false]->resize(toolTitleHeight, toolTitleHeight);
+ irightBtnUpPix[false] = new KPixmap();
+ irightBtnUpPix[false]->resize(toolTitleHeight, toolTitleHeight);
+ irightBtnDownPix[false] = new KPixmap();
+ irightBtnDownPix[false]->resize(toolTitleHeight, toolTitleHeight);
+
+ // Draw the button state pixmaps
+ g = options()->colorGroup( ColorTitleBar, true );
+ drawButtonBackground( leftBtnUpPix[true], g, false );
+ drawButtonBackground( leftBtnDownPix[true], g, true );
+ drawButtonBackground( leftBtnUpPix[false], g, false );
+ drawButtonBackground( leftBtnDownPix[false], g, true );
+
+ g = options()->colorGroup( ColorButtonBg, true );
+ drawButtonBackground( rightBtnUpPix[true], g, false );
+ drawButtonBackground( rightBtnDownPix[true], g, true );
+ drawButtonBackground( rightBtnUpPix[false], g, false );
+ drawButtonBackground( rightBtnDownPix[false], g, true );
+
+ g = options()->colorGroup( ColorTitleBar, false );
+ drawButtonBackground( ileftBtnUpPix[true], g, false );
+ drawButtonBackground( ileftBtnDownPix[true], g, true );
+ drawButtonBackground( ileftBtnUpPix[false], g, false );
+ drawButtonBackground( ileftBtnDownPix[false], g, true );
+
+ g = options()->colorGroup( ColorButtonBg, false );
+ drawButtonBackground( irightBtnUpPix[true], g, false );
+ drawButtonBackground( irightBtnDownPix[true], g, true );
+ drawButtonBackground( irightBtnUpPix[false], g, false );
+ drawButtonBackground( irightBtnDownPix[false], g, true );
+}
+
+
+void KDEDefaultHandler::freePixmaps()
+{
+ // Free button pixmaps
+ if (rightBtnUpPix[true])
+ delete rightBtnUpPix[true];
+ if(rightBtnDownPix[true])
+ delete rightBtnDownPix[true];
+ if (irightBtnUpPix[true])
+ delete irightBtnUpPix[true];
+ if (irightBtnDownPix[true])
+ delete irightBtnDownPix[true];
+
+ if (leftBtnUpPix[true])
+ delete leftBtnUpPix[true];
+ if(leftBtnDownPix[true])
+ delete leftBtnDownPix[true];
+ if (ileftBtnUpPix[true])
+ delete ileftBtnUpPix[true];
+ if (ileftBtnDownPix[true])
+ delete ileftBtnDownPix[true];
+
+ if (rightBtnUpPix[false])
+ delete rightBtnUpPix[false];
+ if(rightBtnDownPix[false])
+ delete rightBtnDownPix[false];
+ if (irightBtnUpPix[false])
+ delete irightBtnUpPix[false];
+ if (irightBtnDownPix[false])
+ delete irightBtnDownPix[false];
+
+ if (leftBtnUpPix[false])
+ delete leftBtnUpPix[false];
+ if(leftBtnDownPix[false])
+ delete leftBtnDownPix[false];
+ if (ileftBtnUpPix[false])
+ delete ileftBtnUpPix[false];
+ if (ileftBtnDownPix[false])
+ delete ileftBtnDownPix[false];
+
+ // Title images
+ if (titleBuffer)
+ delete titleBuffer;
+ if (titlePix)
+ delete titlePix;
+ if (aUpperGradient)
+ delete aUpperGradient;
+ if (iUpperGradient)
+ delete iUpperGradient;
+
+ // Sticky pin images
+ if (pinUpPix)
+ delete pinUpPix;
+ if (ipinUpPix)
+ delete ipinUpPix;
+ if (pinDownPix)
+ delete pinDownPix;
+ if (ipinDownPix)
+ delete ipinDownPix;
+}
+
+
+void KDEDefaultHandler::drawButtonBackground(KPixmap *pix,
+ const QColorGroup &g, bool sunken)
+{
+ QPainter p;
+ int w = pix->width();
+ int h = pix->height();
+ int x2 = w-1;
+ int y2 = h-1;
+
+ bool highcolor = useGradients && (QPixmap::defaultDepth() > 8);
+ QColor c = g.background();
+
+ // Fill the background with a gradient if possible
+ if (highcolor)
+ KPixmapEffect::gradient(*pix, c.light(130), c.dark(130),
+ KPixmapEffect::VerticalGradient);
+ else
+ pix->fill(c);
+
+ p.begin(pix);
+ // outer frame
+ p.setPen(g.mid());
+ p.drawLine(0, 0, x2, 0);
+ p.drawLine(0, 0, 0, y2);
+ p.setPen(g.light());
+ p.drawLine(x2, 0, x2, y2);
+ p.drawLine(0, x2, y2, x2);
+ p.setPen(g.dark());
+ p.drawRect(1, 1, w-2, h-2);
+ p.setPen(sunken ? g.mid() : g.light());
+ p.drawLine(2, 2, x2-2, 2);
+ p.drawLine(2, 2, 2, y2-2);
+ p.setPen(sunken ? g.light() : g.mid());
+ p.drawLine(x2-2, 2, x2-2, y2-2);
+ p.drawLine(2, x2-2, y2-2, x2-2);
+}
+
+QValueList< KDEDefaultHandler::BorderSize > KDEDefaultHandler::borderSizes() const
+{ // the list must be sorted
+ return QValueList< BorderSize >() << BorderNormal << BorderLarge <<
+ BorderVeryLarge << BorderHuge << BorderVeryHuge << BorderOversized;
+}
+
+bool KDEDefaultHandler::supports( Ability ability )
+{
+ switch( ability )
+ {
+ case AbilityAnnounceButtons:
+ case AbilityButtonMenu:
+ case AbilityButtonOnAllDesktops:
+ case AbilityButtonSpacer:
+ case AbilityButtonHelp:
+ case AbilityButtonMinimize:
+ case AbilityButtonMaximize:
+ case AbilityButtonClose:
+ case AbilityButtonAboveOthers:
+ case AbilityButtonBelowOthers:
+ case AbilityButtonShade:
+ return true;
+ default:
+ return false;
+ };
+}
+
+// ===========================================================================
+
+KDEDefaultButton::KDEDefaultButton(ButtonType type, KDEDefaultClient *parent, const char *name)
+ : KCommonDecorationButton(type, parent, name)
+{
+ setBackgroundMode( QWidget::NoBackground );
+
+ isMouseOver = false;
+ deco = NULL;
+ large = !decoration()->isToolWindow();
+}
+
+
+KDEDefaultButton::~KDEDefaultButton()
+{
+ if (deco)
+ delete deco;
+}
+
+
+void KDEDefaultButton::reset(unsigned long changed)
+{
+ if (changed&DecorationReset || changed&ManualReset || changed&SizeChange || changed&StateChange) {
+ switch (type() ) {
+ case CloseButton:
+ setBitmap(close_bits);
+ break;
+ case HelpButton:
+ setBitmap(question_bits);
+ break;
+ case MinButton:
+ setBitmap(iconify_bits);
+ break;
+ case MaxButton:
+ setBitmap( isOn() ? minmax_bits : maximize_bits );
+ break;
+ case OnAllDesktopsButton:
+ setBitmap(0);
+ break;
+ case ShadeButton:
+ setBitmap( isOn() ? shade_on_bits : shade_off_bits );
+ break;
+ case AboveButton:
+ setBitmap( isOn() ? above_on_bits : above_off_bits );
+ break;
+ case BelowButton:
+ setBitmap( isOn() ? below_on_bits : below_off_bits );
+ break;
+ default:
+ setBitmap(0);
+ break;
+ }
+
+ this->update();
+ }
+}
+
+
+void KDEDefaultButton::setBitmap(const unsigned char *bitmap)
+{
+ delete deco;
+ deco = 0;
+
+ if (bitmap) {
+ deco = new QBitmap(10, 10, bitmap, true);
+ deco->setMask( *deco );
+ }
+}
+
+
+void KDEDefaultButton::drawButton(QPainter *p)
+{
+ if (!KDEDefault_initialized)
+ return;
+
+ const bool active = decoration()->isActive();
+
+ if (deco) {
+ // Fill the button background with an appropriate button image
+ KPixmap btnbg;
+
+ if (isLeft() ) {
+ if (isDown())
+ btnbg = active ?
+ *leftBtnDownPix[large] : *ileftBtnDownPix[large];
+ else
+ btnbg = active ?
+ *leftBtnUpPix[large] : *ileftBtnUpPix[large];
+ } else {
+ if (isDown())
+ btnbg = active ?
+ *rightBtnDownPix[large] : *irightBtnDownPix[large];
+ else
+ btnbg = active ?
+ *rightBtnUpPix[large] : *irightBtnUpPix[large];
+ }
+
+ p->drawPixmap( 0, 0, btnbg );
+
+ } else if ( isLeft() ) {
+
+ // Fill the button background with an appropriate color/gradient
+ // This is for sticky and menu buttons
+ KPixmap* grad = active ? aUpperGradient : iUpperGradient;
+ if (!grad) {
+ QColor c = KDecoration::options()->color(KDecoration::ColorTitleBar, active);
+ p->fillRect(0, 0, width(), height(), c );
+ } else
+ p->drawPixmap( 0, 0, *grad, 0,1, width(), height() );
+
+ } else {
+ // Draw a plain background for menus or sticky buttons on RHS
+ QColor c = KDecoration::options()->color(KDecoration::ColorFrame, active);
+ p->fillRect(0, 0, width(), height(), c);
+ }
+
+
+ // If we have a decoration bitmap, then draw that
+ // otherwise we paint a menu button (with mini icon), or a sticky button.
+ if( deco ) {
+ // Select the appropriate button decoration color
+ bool darkDeco = qGray( KDecoration::options()->color(
+ isLeft() ? KDecoration::ColorTitleBar : KDecoration::ColorButtonBg,
+ active).rgb() ) > 127;
+
+ if (isMouseOver)
+ p->setPen( darkDeco ? Qt::darkGray : Qt::lightGray );
+ else
+ p->setPen( darkDeco ? Qt::black : Qt::white );
+
+ int xOff = (width()-10)/2;
+ int yOff = (height()-10)/2;
+ p->drawPixmap(isDown() ? xOff+1: xOff, isDown() ? yOff+1 : yOff, *deco);
+
+ } else {
+ KPixmap btnpix;
+
+ if (type()==OnAllDesktopsButton) {
+ if (active)
+ btnpix = isOn() ? *pinDownPix : *pinUpPix;
+ else
+ btnpix = isOn() ? *ipinDownPix : *ipinUpPix;
+ } else
+ btnpix = decoration()->icon().pixmap( QIconSet::Small, QIconSet::Normal );
+
+ // Intensify the image if required
+ if (isMouseOver) {
+ btnpix = KPixmapEffect::intensity(btnpix, 0.8);
+ }
+
+ // Smooth scale the pixmap for small titlebars
+ // This is slow, but we assume this isn't done too often
+ if ( width() < 16 ) {
+ btnpix.convertFromImage(btnpix.convertToImage().smoothScale(12, 12));
+ p->drawPixmap( 0, 0, btnpix );
+ }
+ else
+ p->drawPixmap( width()/2-8, height()/2-8, btnpix );
+ }
+}
+
+
+void KDEDefaultButton::enterEvent(QEvent *e)
+{
+ isMouseOver=true;
+ repaint(false);
+ QButton::enterEvent(e);
+}
+
+
+void KDEDefaultButton::leaveEvent(QEvent *e)
+{
+ isMouseOver=false;
+ repaint(false);
+ QButton::leaveEvent(e);
+}
+
+
+// ===========================================================================
+
+KDEDefaultClient::KDEDefaultClient( KDecorationBridge* b, KDecorationFactory* f )
+ : KCommonDecoration( b, f )/*,
+ m_closing(false)*/
+{
+}
+
+QString KDEDefaultClient::visibleName() const
+{
+ return i18n("KDE2");
+}
+
+QString KDEDefaultClient::defaultButtonsLeft() const
+{
+ return "MS";
+}
+
+QString KDEDefaultClient::defaultButtonsRight() const
+{
+ return "HIAX";
+}
+
+bool KDEDefaultClient::decorationBehaviour(DecorationBehaviour behaviour) const
+{
+ switch (behaviour) {
+ case DB_MenuClose:
+ return true;
+ case DB_WindowMask:
+ return true;
+ case DB_ButtonHide:
+ return true;
+
+ default:
+ return KCommonDecoration::decorationBehaviour(behaviour);
+ }
+}
+
+int KDEDefaultClient::layoutMetric(LayoutMetric lm, bool respectWindowState, const KCommonDecorationButton *btn) const
+{
+ switch (lm) {
+ case LM_BorderLeft:
+ case LM_BorderRight:
+ return borderWidth;
+
+ case LM_BorderBottom:
+ return mustDrawHandle() ? grabBorderWidth : borderWidth;
+
+ case LM_TitleEdgeLeft:
+ case LM_TitleEdgeRight:
+ return borderWidth;
+
+ case LM_TitleEdgeTop:
+ return 3;
+
+ case LM_TitleEdgeBottom:
+ return 1;
+
+ case LM_TitleBorderLeft:
+ case LM_TitleBorderRight:
+ return 1;
+
+ case LM_TitleHeight:
+ return titleHeight;
+
+ case LM_ButtonWidth:
+ case LM_ButtonHeight:
+ return titleHeight;
+
+ case LM_ButtonSpacing:
+ return 0;
+
+ case LM_ExplicitButtonSpacer:
+ if ( !isToolWindow() )
+ return borderWidth/2;
+ // fall though
+ default:
+ return KCommonDecoration::layoutMetric(lm, respectWindowState, btn);
+ }
+}
+
+KCommonDecorationButton *KDEDefaultClient::createButton(ButtonType type)
+{
+ switch (type) {
+ case MenuButton:
+ return new KDEDefaultButton(MenuButton, this, "menu");
+ case OnAllDesktopsButton:
+ return new KDEDefaultButton(OnAllDesktopsButton, this, "on_all_desktops");
+ case HelpButton:
+ return new KDEDefaultButton(HelpButton, this, "help");
+ case MinButton:
+ return new KDEDefaultButton(MinButton, this, "minimize");
+ case MaxButton:
+ return new KDEDefaultButton(MaxButton, this, "maximize");
+ case CloseButton:
+ return new KDEDefaultButton(CloseButton, this, "close");
+ case AboveButton:
+ return new KDEDefaultButton(AboveButton, this, "above");
+ case BelowButton:
+ return new KDEDefaultButton(BelowButton, this, "below");
+ case ShadeButton:
+ return new KDEDefaultButton(ShadeButton, this, "shade");
+
+ default:
+ return 0;
+ }
+}
+
+void KDEDefaultClient::init()
+{
+ // Finally, toolWindows look small
+ if ( isToolWindow() ) {
+ titleHeight = toolTitleHeight;
+ }
+ else {
+ titleHeight = normalTitleHeight;
+ }
+
+ KCommonDecoration::init();
+}
+
+void KDEDefaultClient::reset( unsigned long changed)
+{
+ widget()->repaint();
+
+ KCommonDecoration::reset(changed);
+}
+
+bool KDEDefaultClient::mustDrawHandle() const
+{
+ bool drawSmallBorders = !options()->moveResizeMaximizedWindows();
+ if (drawSmallBorders && (maximizeMode() & MaximizeVertical)) {
+ return false;
+ } else {
+ return showGrabBar && isResizable();
+ }
+}
+
+void KDEDefaultClient::paintEvent( QPaintEvent* )
+{
+ if (!KDEDefault_initialized)
+ return;
+
+ QColorGroup g;
+ int offset;
+
+ KPixmap* upperGradient = isActive() ? aUpperGradient : iUpperGradient;
+
+ QPainter p(widget());
+
+ // Obtain widget bounds.
+ QRect r(widget()->rect());
+ int x = r.x();
+ int y = r.y();
+ int x2 = r.width() - 1;
+ int y2 = r.height() - 1;
+ int w = r.width();
+ int h = r.height();
+
+ // Determine where to place the extended left titlebar
+ int leftFrameStart = (h > 42) ? y+titleHeight+26: y+titleHeight;
+
+ // Determine where to make the titlebar color transition
+ r = titleRect();
+ int rightOffset = r.x()+r.width()+1;
+
+ // Create a disposable pixmap buffer for the titlebar
+ // very early before drawing begins so there is no lag
+ // during painting pixels.
+ titleBuffer->resize( rightOffset-3, titleHeight+1 );
+
+ // Draw an outer black frame
+ p.setPen(Qt::black);
+ p.drawRect(x,y,w,h);
+
+ // Draw part of the frame that is the titlebar color
+ g = options()->colorGroup(ColorTitleBar, isActive());
+ p.setPen(g.light());
+ p.drawLine(x+1, y+1, rightOffset-1, y+1);
+ p.drawLine(x+1, y+1, x+1, leftFrameStart+borderWidth-4);
+
+ // Draw titlebar colour separator line
+ p.setPen(g.dark());
+ p.drawLine(rightOffset-1, y+1, rightOffset-1, titleHeight+2);
+
+ p.fillRect(x+2, y+titleHeight+3,
+ borderWidth-4, leftFrameStart+borderWidth-y-titleHeight-8,
+ options()->color(ColorTitleBar, isActive() ));
+
+ // Finish drawing the titlebar extension
+ p.setPen(Qt::black);
+ p.drawLine(x+1, leftFrameStart+borderWidth-4, x+borderWidth-2, leftFrameStart-1);
+ p.setPen(g.mid());
+ p.drawLine(x+borderWidth-2, y+titleHeight+3, x+borderWidth-2, leftFrameStart-2);
+
+ // Fill out the border edges
+ g = options()->colorGroup(ColorFrame, isActive());
+ p.setPen(g.light());
+ p.drawLine(rightOffset, y+1, x2-1, y+1);
+ p.drawLine(x+1, leftFrameStart+borderWidth-3, x+1, y2-1);
+ p.setPen(g.dark());
+ p.drawLine(x2-1, y+1, x2-1, y2-1);
+ p.drawLine(x+1, y2-1, x2-1, y2-1);
+
+ p.setPen(options()->color(ColorFrame, isActive()));
+ QPointArray a;
+ QBrush brush( options()->color(ColorFrame, isActive()), Qt::SolidPattern );
+ p.setBrush( brush ); // use solid, yellow brush
+ a.setPoints( 4, x+2, leftFrameStart+borderWidth-4,
+ x+borderWidth-2, leftFrameStart,
+ x+borderWidth-2, y2-2,
+ x+2, y2-2);
+ p.drawPolygon( a );
+ p.fillRect(x2-borderWidth+2, y+titleHeight+3,
+ borderWidth-3, y2-y-titleHeight-4,
+ options()->color(ColorFrame, isActive() ));
+
+ // Draw the bottom handle if required
+ if (mustDrawHandle())
+ {
+ if(w > 50)
+ {
+ qDrawShadePanel(&p, x+1, y2-grabBorderWidth+2, 2*borderWidth+12, grabBorderWidth-2,
+ g, false, 1, &g.brush(QColorGroup::Mid));
+ qDrawShadePanel(&p, x+2*borderWidth+13, y2-grabBorderWidth+2, w-4*borderWidth-26, grabBorderWidth-2,
+ g, false, 1, isActive() ?
+ &g.brush(QColorGroup::Background) :
+ &g.brush(QColorGroup::Mid));
+ qDrawShadePanel(&p, x2-2*borderWidth-12, y2-grabBorderWidth+2, 2*borderWidth+12, grabBorderWidth-2,
+ g, false, 1, &g.brush(QColorGroup::Mid));
+ } else
+ qDrawShadePanel(&p, x+1, y2-grabBorderWidth+2, w-2, grabBorderWidth-2,
+ g, false, 1, isActive() ?
+ &g.brush(QColorGroup::Background) :
+ &g.brush(QColorGroup::Mid));
+ offset = grabBorderWidth;
+ } else
+ {
+ p.fillRect(x+2, y2-borderWidth+2, w-4, borderWidth-3,
+ options()->color(ColorFrame, isActive() ));
+ offset = borderWidth;
+ }
+
+ // Draw a frame around the wrapped widget.
+ p.setPen( g.dark() );
+ p.drawRect( x+borderWidth-1, y+titleHeight+3, w-2*borderWidth+2, h-titleHeight-offset-2 );
+
+ // Draw the title bar.
+ r = titleRect();
+
+ // Obtain titlebar blend colours
+ QColor c1 = options()->color(ColorTitleBar, isActive() );
+ QColor c2 = options()->color(ColorFrame, isActive() );
+
+ // Fill with frame color behind RHS buttons
+ p.fillRect( rightOffset, y+2, x2-rightOffset-1, titleHeight+1, c2);
+
+ QPainter p2( titleBuffer, this );
+
+ // Draw the titlebar gradient
+ if (upperGradient)
+ p2.drawTiledPixmap(0, 0, rightOffset-3, titleHeight+1, *upperGradient);
+ else
+ p2.fillRect(0, 0, rightOffset-3, titleHeight+1, c1);
+
+ // Draw the title text on the pixmap, and with a smaller font
+ // for toolwindows than the default.
+ QFont fnt = options()->font(true);
+
+ if ( isToolWindow() )
+ fnt.setPointSize( fnt.pointSize()-2 ); // Shrink font by 2pt
+
+ p2.setFont( fnt );
+
+ // Draw the titlebar stipple if active and available
+ if (isActive() && titlePix)
+ {
+ QFontMetrics fm(fnt);
+ int captionWidth = fm.width(caption());
+ if (caption().isRightToLeft())
+ p2.drawTiledPixmap( r.x(), 0, r.width()-captionWidth-4,
+ titleHeight+1, *titlePix );
+ else
+ p2.drawTiledPixmap( r.x()+captionWidth+3, 0, r.width()-captionWidth-4,
+ titleHeight+1, *titlePix );
+ }
+
+ p2.setPen( options()->color(ColorFont, isActive()) );
+ p2.drawText(r.x(), 1, r.width()-1, r.height(),
+ (caption().isRightToLeft() ? AlignRight : AlignLeft) | AlignVCenter,
+ caption() );
+
+ bitBlt( widget(), 2, 2, titleBuffer );
+
+ p2.end();
+
+ // Ensure a shaded window has no unpainted areas
+ // Is this still needed?
+#if 1
+ p.setPen(c2);
+ p.drawLine(x+borderWidth, y+titleHeight+4, x2-borderWidth, y+titleHeight+4);
+#endif
+}
+
+QRegion KDEDefaultClient::cornerShape(WindowCorner corner)
+{
+ switch (corner) {
+ case WC_TopLeft:
+ return QRect(0, 0, 1, 1);
+
+ case WC_TopRight:
+ return QRect(width()-1, 0, 1, 1);
+
+ case WC_BottomLeft:
+ return QRect(0, height()-1, 1, 1);
+
+ case WC_BottomRight:
+ return QRect(width()-1, height()-1, 1, 1);
+
+ default:
+ return QRegion();
+ }
+}
+
+} // namespace
+
+// Extended KWin plugin interface
+extern "C" KDE_EXPORT KDecorationFactory* create_factory()
+{
+ return new Default::KDEDefaultHandler();
+}
+
+// vim: ts=4
+// kate: space-indent off; tab-width 4;
diff --git a/kwin/clients/default/kdedefault.h b/kwin/clients/default/kdedefault.h
new file mode 100644
index 000000000..53ad23fa2
--- /dev/null
+++ b/kwin/clients/default/kdedefault.h
@@ -0,0 +1,103 @@
+/*
+ *
+ * KDE2 Default KWin client
+ *
+ * Copyright (C) 1999, 2001 Daniel Duley <mosfet@kde.org>
+ * Matthias Ettrich <ettrich@kde.org>
+ * Karol Szwed <gallium@kde.org>
+ *
+ * Draws mini titlebars for tool windows.
+ * Many features are now customizable.
+ */
+
+#ifndef _KDE_DEFAULT_H
+#define _KDE_DEFAULT_H
+
+#include <qbutton.h>
+#include <qbitmap.h>
+#include <qdatetime.h>
+#include <kpixmap.h>
+#include <kcommondecoration.h>
+#include <kdecorationfactory.h>
+
+class QSpacerItem;
+class QBoxLayout;
+class QGridLayout;
+
+namespace Default {
+
+class KDEDefaultClient;
+
+class KDEDefaultHandler: public KDecorationFactory
+{
+ public:
+ KDEDefaultHandler();
+ ~KDEDefaultHandler();
+ KDecoration* createDecoration( KDecorationBridge* b );
+ bool reset( unsigned long changed );
+ virtual QValueList< BorderSize > borderSizes() const;
+ virtual bool supports( Ability ability );
+
+ private:
+ unsigned long readConfig( bool update );
+ void createPixmaps();
+ void freePixmaps();
+ void drawButtonBackground(KPixmap *pix,
+ const QColorGroup &g, bool sunken);
+};
+
+
+// class KDEDefaultButton : public QButton, public KDecorationDefines
+class KDEDefaultButton : public KCommonDecorationButton
+{
+ public:
+ KDEDefaultButton(ButtonType type, KDEDefaultClient *parent, const char *name);
+ ~KDEDefaultButton();
+
+ void reset(unsigned long changed);
+
+ void setBitmap(const unsigned char *bitmap);
+
+ protected:
+ void enterEvent(QEvent *);
+ void leaveEvent(QEvent *);
+ void drawButton(QPainter *p);
+ void drawButtonLabel(QPainter*) {;}
+
+ QBitmap* deco;
+ bool large;
+ bool isMouseOver;
+};
+
+
+class KDEDefaultClient : public KCommonDecoration
+{
+ public:
+ KDEDefaultClient( KDecorationBridge* b, KDecorationFactory* f );
+ ~KDEDefaultClient() {;}
+
+ virtual QString visibleName() const;
+ virtual QString defaultButtonsLeft() const;
+ virtual QString defaultButtonsRight() const;
+ virtual bool decorationBehaviour(DecorationBehaviour behaviour) const;
+ virtual int layoutMetric(LayoutMetric lm, bool respectWindowState = true, const KCommonDecorationButton * = 0) const;
+ virtual KCommonDecorationButton *createButton(ButtonType type);
+
+ virtual QRegion cornerShape(WindowCorner corner);
+
+ void init();
+ void reset( unsigned long changed );
+
+ protected:
+ void paintEvent( QPaintEvent* );
+
+ private:
+ bool mustDrawHandle() const;
+ int titleHeight;
+};
+
+}
+
+#endif
+// vim: ts=4
+// kate: space-indent off; tab-width 4;
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-06 00:25:45 +0000