Rename kwin to twin (Part 2 of 2)

1 files changed, 1712 insertions, 0 deletions

diff --git a/twin/kcmtwin/twinoptions/windows.cpp b/twin/kcmtwin/twinoptions/windows.cpp
new file mode 100644
index 000000000..80185a427
--- /dev/null
+++ b/twin/kcmtwin/twinoptions/windows.cpp
@@ -0,0 +1,1712 @@
+/*
+ * windows.cpp
+ *
+ * Copyright (c) 1997 Patrick Dowler dowler@morgul.fsh.uvic.ca
+ * Copyright (c) 2001 Waldo Bastian bastian@kde.org
+ *
+ *  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.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ *
+ */
+
+#include <config.h>
+
+#include <tqdir.h>
+#include <tqlayout.h>
+#include <tqslider.h>
+#include <tqwhatsthis.h>
+#include <tqvbuttongroup.h>
+#include <tqcheckbox.h>
+#include <tqradiobutton.h>
+#include <tqlabel.h>
+#include <tqcombobox.h>
+#include <kmessagebox.h>
+
+#include <kactivelabel.h>
+#include <klocale.h>
+#include <kcolorbutton.h>
+#include <kconfig.h>
+#include <knuminput.h>
+#include <kapplication.h>
+#include <kdialog.h>
+#include <dcopclient.h>
+#include <kglobal.h>
+#include <kprocess.h>
+#include <tqtabwidget.h>
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#include "windows.h"
+
+
+// twin config keywords
+#define KWIN_FOCUS                 "FocusPolicy"
+#define KWIN_PLACEMENT             "Placement"
+#define KWIN_MOVE                  "MoveMode"
+#define KWIN_MINIMIZE_ANIM         "AnimateMinimize"
+#define KWIN_MINIMIZE_ANIM_SPEED   "AnimateMinimizeSpeed"
+#define KWIN_RESIZE_OPAQUE         "ResizeMode"
+#define KWIN_GEOMETRY              "GeometryTip"
+#define KWIN_AUTORAISE_INTERVAL    "AutoRaiseInterval"
+#define KWIN_AUTORAISE             "AutoRaise"
+#define KWIN_DELAYFOCUS_INTERVAL   "DelayFocusInterval"
+#define KWIN_DELAYFOCUS            "DelayFocus"
+#define KWIN_CLICKRAISE            "ClickRaise"
+#define KWIN_ANIMSHADE             "AnimateShade"
+#define KWIN_MOVE_RESIZE_MAXIMIZED "MoveResizeMaximizedWindows"
+#define KWIN_ALTTABMODE            "AltTabStyle"
+#define KWIN_TRAVERSE_ALL          "TraverseAll"
+#define KWIN_SHOW_POPUP            "ShowPopup"
+#define KWIN_ROLL_OVER_DESKTOPS    "RollOverDesktops"
+#define KWIN_SHADEHOVER            "ShadeHover"
+#define KWIN_SHADEHOVER_INTERVAL   "ShadeHoverInterval"
+#define KWIN_FOCUS_STEALING        "FocusStealingPreventionLevel"
+#define KWIN_HIDE_UTILITY          "HideUtilityWindowsForInactive"
+#define KWIN_SEPARATE_SCREEN_FOCUS "SeparateScreenFocus"
+#define KWIN_ACTIVE_MOUSE_SCREEN   "ActiveMouseScreen"
+
+// kwm config keywords
+#define KWM_ELECTRIC_BORDER                  "ElectricBorders"
+#define KWM_ELECTRIC_BORDER_DELAY            "ElectricBorderDelay"
+
+//CT 15mar 98 - magics
+#define KWM_BRDR_SNAP_ZONE                   "BorderSnapZone"
+#define KWM_BRDR_SNAP_ZONE_DEFAULT           10
+#define KWM_WNDW_SNAP_ZONE                   "WindowSnapZone"
+#define KWM_WNDW_SNAP_ZONE_DEFAULT           10
+
+#define MAX_BRDR_SNAP                          100
+#define MAX_WNDW_SNAP                          100
+#define MAX_EDGE_RES                          1000
+
+
+KFocusConfig::~KFocusConfig ()
+{
+    if (standAlone)
+        delete config;
+}
+
+// removed the LCD display over the slider - this is not good GUI design :) RNolden 051701
+KFocusConfig::KFocusConfig (bool _standAlone, KConfig *_config, TQWidget * parent, const char *)
+    : KCModule(parent, "kcmkwm"), config(_config), standAlone(_standAlone)
+{
+    TQString wtstr;
+    TQBoxLayout *lay = new TQVBoxLayout (this, 0, KDialog::spacingHint());
+
+    //iTLabel = new TQLabel(i18n("  Allowed overlap:\n"
+    //                         "(% of desktop space)"),
+    //             plcBox);
+    //iTLabel->tqsetAlignment(AlignTop|AlignHCenter);
+    //pLay->addWidget(iTLabel,1,1);
+
+    //interactiveTrigger = new TQSpinBox(0, 500, 1, plcBox);
+    //pLay->addWidget(interactiveTrigger,1,2);
+
+    //pLay->addRowSpacing(2,KDialog::spacingHint());
+
+    //lay->addWidget(plcBox);
+
+    // focus policy
+    fcsBox = new TQButtonGroup(i18n("Focus"),this);
+    fcsBox->setColumnLayout( 0, Qt::Horizontal );
+
+    TQBoxLayout *fLay = new TQVBoxLayout(fcsBox->tqlayout(),
+        KDialog::spacingHint());
+
+    TQBoxLayout *cLay = new TQHBoxLayout(fLay);
+    TQLabel *fLabel = new TQLabel(i18n("&Policy:"), fcsBox);
+    cLay->addWidget(fLabel, 0);
+    focusCombo =  new TQComboBox(false, fcsBox);
+    focusCombo->insertItem(i18n("Click to Focus"), CLICK_TO_FOCUS);
+    focusCombo->insertItem(i18n("Focus Follows Mouse"), FOCUS_FOLLOWS_MOUSE);
+    focusCombo->insertItem(i18n("Focus Under Mouse"), FOCUS_UNDER_MOUSE);
+    focusCombo->insertItem(i18n("Focus Strictly Under Mouse"), FOCUS_STRICTLY_UNDER_MOUSE);
+    cLay->addWidget(focusCombo,1 ,Qt::AlignLeft);
+    fLabel->setBuddy(focusCombo);
+
+    // FIXME, when more policies have been added to KWin
+    wtstr = i18n("The focus policy is used to determine the active window, i.e."
+                                      " the window you can work in. <ul>"
+                                      " <li><em>Click to focus:</em> A window becomes active when you click into it."
+                                      " This is the behavior you might know from other operating systems.</li>"
+                                      " <li><em>Focus follows mouse:</em> Moving the mouse pointer actively on to a"
+                                      " normal window activates it. New windows will receive the focus,"
+                                      " without you having to point the mouse at them explicitly."
+                                      " Very practical if you are using the mouse a lot.</li>"
+                                      " <li><em>Focus under mouse:</em> The window that happens to be under the"
+                                      " mouse pointer is active. If the mouse points nowhere, the last window"
+                                      " that was under the mouse has focus."
+                                      " New windows will not automatically receive the focus.</li>"
+                                      " <li><em>Focus strictly under mouse:</em> Only the window under the mouse pointer is"
+                                      " active. If the mouse points nowhere, nothing has focus."
+                                      " </ul>"
+                                      "Note that 'Focus under mouse' and 'Focus strictly under mouse' prevent certain"
+                                      " features such as the Alt+Tab walk through windows dialog in the KDE mode"
+                                      " from working properly."
+                         );
+    TQWhatsThis::add( focusCombo, wtstr);
+    TQWhatsThis::add(fLabel, wtstr);
+
+    connect(focusCombo, TQT_SIGNAL(activated(int)), this, TQT_SLOT(setAutoRaiseEnabled()) );
+
+    // autoraise delay
+    autoRaiseOn = new TQCheckBox(i18n("Auto &raise"), fcsBox);
+    fLay->addWidget(autoRaiseOn);
+    connect(autoRaiseOn,TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(autoRaiseOnTog(bool)));
+
+    autoRaise = new KIntNumInput(500, fcsBox);
+    autoRaise->setLabel(i18n("Dela&y:"), Qt::AlignVCenter|Qt::AlignLeft);
+    autoRaise->setRange(0, 3000, 100, true);
+    autoRaise->setSteps(100,100);
+    autoRaise->setSuffix(i18n(" msec"));
+    fLay->addWidget(autoRaise);
+
+    connect(focusCombo, TQT_SIGNAL(activated(int)), this, TQT_SLOT(setDelayFocusEnabled()) );
+
+    delayFocusOn = new TQCheckBox(i18n("Delay focus"), fcsBox);
+    fLay->addWidget(delayFocusOn);
+    connect(delayFocusOn,TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(delayFocusOnTog(bool)));
+
+    delayFocus = new KIntNumInput(500, fcsBox);
+    delayFocus->setLabel(i18n("Dela&y:"), Qt::AlignVCenter|Qt::AlignLeft);
+    delayFocus->setRange(0, 3000, 100, true);
+    delayFocus->setSteps(100,100);
+    delayFocus->setSuffix(i18n(" msec"));
+    fLay->addWidget(delayFocus);
+
+    clickRaiseOn = new TQCheckBox(i18n("C&lick raise active window"), fcsBox);
+    connect(clickRaiseOn,TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(clickRaiseOnTog(bool)));
+    fLay->addWidget(clickRaiseOn);
+
+//     fLay->addColSpacing(0,QMAX(autoRaiseOn->tqsizeHint().width(),
+//                                clickRaiseOn->tqsizeHint().width()) + 15);
+
+    TQWhatsThis::add( autoRaiseOn, i18n("When this option is enabled, a window in the background will automatically"
+                                       " come to the front when the mouse pointer has been over it for some time.") );
+    wtstr = i18n("This is the delay after which the window that the mouse pointer is over will automatically"
+                 " come to the front.");
+    TQWhatsThis::add( autoRaise, wtstr );
+
+    TQWhatsThis::add( clickRaiseOn, i18n("When this option is enabled, the active window will be brought to the"
+                                        " front when you click somewhere into the window contents. To change"
+                                        " it for inactive windows, you need to change the settings"
+                                        " in the Actions tab.") );
+
+    TQWhatsThis::add( delayFocusOn, i18n("When this option is enabled, there will be a delay after which the"
+                                        " window the mouse pointer is over will become active (receive focus).") );
+    TQWhatsThis::add( delayFocus, i18n("This is the delay after which the window the mouse pointer is over"
+                                       " will automatically receive focus.") );
+
+    separateScreenFocus = new TQCheckBox( i18n( "S&eparate screen focus" ), fcsBox );
+    fLay->addWidget( separateScreenFocus );
+    wtstr = i18n( "When this option is enabled, focus operations are limited only to the active Xinerama screen" );
+    TQWhatsThis::add( separateScreenFocus, wtstr );
+
+    activeMouseScreen = new TQCheckBox( i18n( "Active &mouse screen" ), fcsBox );
+    fLay->addWidget( activeMouseScreen );
+    wtstr = i18n( "When this option is enabled, active Xinerama screen (where for example new windows appear)"
+                  " is the screen with the mouse pointer. When disabled, the active Xinerama screen is the screen"
+                  " with the focused window. This option is by default disabled for Click to focus and"
+                  " enabled for other focus policies." );
+    TQWhatsThis::add( activeMouseScreen, wtstr );
+    connect(focusCombo, TQT_SIGNAL(activated(int)), this, TQT_SLOT(updateActiveMouseScreen()));
+
+    if (!TQApplication::desktop()->isVirtualDesktop() ||
+        TQApplication::desktop()->numScreens() == 1) // No Ximerama 
+    {
+        separateScreenFocus->hide();
+        activeMouseScreen->hide();
+    }
+
+    lay->addWidget(fcsBox);
+
+    kbdBox = new TQButtonGroup(i18n("Navigation"), this);
+    kbdBox->setColumnLayout( 0, Qt::Horizontal );
+    TQVBoxLayout *kLay = new TQVBoxLayout(kbdBox->tqlayout(), KDialog::spacingHint());
+
+    altTabPopup = new TQCheckBox( i18n("Show window list while switching windows"), kbdBox );
+    kLay->addWidget( altTabPopup );
+
+    wtstr = i18n("Hold down the Alt key and press the Tab key repeatedly to walk"
+                 " through the windows on the current desktop (the Alt+Tab"
+                 " combination can be reconfigured).\n\n"
+                 "If this checkbox is checked"
+                 " a popup widget is shown, displaying the icons of all windows to"
+                 " walk through and the title of the currently selected one.\n\n"
+                 "Otherwise, the focus is passed to a new window each time Tab"
+                 " is pressed, with no popup widget.  In addition, the previously"
+                 " activated window will be sent to the back in this mode.");
+    TQWhatsThis::add( altTabPopup, wtstr );
+    connect(focusCombo, TQT_SIGNAL(activated(int)), this, TQT_SLOT(updateAltTabMode()));
+
+    traverseAll = new TQCheckBox( i18n( "&Traverse windows on all desktops" ), kbdBox );
+    kLay->addWidget( traverseAll );
+
+    wtstr = i18n( "Leave this option disabled if you want to limit walking through"
+                  " windows to the current desktop." );
+    TQWhatsThis::add( traverseAll, wtstr );
+
+    rollOverDesktops = new TQCheckBox( i18n("Desktop navi&gation wraps around"), kbdBox );
+    kLay->addWidget(rollOverDesktops);
+
+    wtstr = i18n( "Enable this option if you want keyboard or active desktop border navigation beyond"
+                  " the edge of a desktop to take you to the opposite edge of the new desktop." );
+    TQWhatsThis::add( rollOverDesktops, wtstr );
+
+    showPopupinfo = new TQCheckBox( i18n("Popup desktop name on desktop &switch"), kbdBox );
+    kLay->addWidget(showPopupinfo);
+
+    wtstr = i18n( "Enable this option if you wish to see the current desktop"
+                  " name popup whenever the current desktop is changed." );
+    TQWhatsThis::add( showPopupinfo, wtstr );
+
+    lay->addWidget(kbdBox);
+
+    lay->addStretch();
+
+    // Any changes goes to slotChanged()
+    connect(focusCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(changed()));
+    connect(fcsBox, TQT_SIGNAL(clicked(int)), TQT_SLOT(changed()));
+    connect(autoRaise, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+    connect(delayFocus, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+    connect(separateScreenFocus, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+    connect(activeMouseScreen, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+    connect(altTabPopup, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+    connect(traverseAll, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+    connect(rollOverDesktops, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+    connect(showPopupinfo, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+
+    load();
+}
+
+
+int KFocusConfig::getFocus()
+{
+    return focusCombo->currentItem();
+}
+
+void KFocusConfig::setFocus(int foc)
+{
+    focusCombo->setCurrentItem(foc);
+
+    // this will disable/hide the auto raise delay widget if focus==click
+    setAutoRaiseEnabled();
+    updateAltTabMode();
+}
+
+void KFocusConfig::updateAltTabMode()
+{
+    // not KDE-style Alt+Tab with unreasonable focus policies
+    altTabPopup->setEnabled( focusCombo->currentItem() == 0 || focusCombo->currentItem() == 1 );
+}
+
+void KFocusConfig::setAutoRaiseInterval(int tb)
+{
+    autoRaise->setValue(tb);
+}
+
+void KFocusConfig::setDelayFocusInterval(int tb)
+{
+    delayFocus->setValue(tb);
+}
+
+int KFocusConfig::getAutoRaiseInterval()
+{
+    return autoRaise->value();
+}
+
+int KFocusConfig::getDelayFocusInterval()
+{
+    return delayFocus->value();
+}
+
+void KFocusConfig::setAutoRaise(bool on)
+{
+    autoRaiseOn->setChecked(on);
+}
+
+void KFocusConfig::setDelayFocus(bool on)
+{
+    delayFocusOn->setChecked(on);
+}
+
+void KFocusConfig::setClickRaise(bool on)
+{
+    clickRaiseOn->setChecked(on);
+}
+
+void KFocusConfig::setAutoRaiseEnabled()
+{
+    // the auto raise related widgets are: autoRaise
+    if ( focusCombo->currentItem() != CLICK_TO_FOCUS )
+    {
+        autoRaiseOn->setEnabled(true);
+        autoRaiseOnTog(autoRaiseOn->isChecked());
+    }
+    else
+    {
+        autoRaiseOn->setEnabled(false);
+        autoRaiseOnTog(false);
+    }
+}
+
+void KFocusConfig::setDelayFocusEnabled()
+{
+    // the delayed focus related widgets are: delayFocus
+    if ( focusCombo->currentItem() != CLICK_TO_FOCUS )
+    {
+        delayFocusOn->setEnabled(true);
+        delayFocusOnTog(delayFocusOn->isChecked());
+    }
+    else
+    {
+        delayFocusOn->setEnabled(false);
+        delayFocusOnTog(false);
+    }
+}
+
+void KFocusConfig::autoRaiseOnTog(bool a) {
+    autoRaise->setEnabled(a);
+    clickRaiseOn->setEnabled( !a );
+}
+
+void KFocusConfig::delayFocusOnTog(bool a) {
+    delayFocus->setEnabled(a);
+}
+
+void KFocusConfig::clickRaiseOnTog(bool ) {
+}
+
+void KFocusConfig::setSeparateScreenFocus(bool s) {
+    separateScreenFocus->setChecked(s);
+}
+
+void KFocusConfig::setActiveMouseScreen(bool a) {
+    activeMouseScreen->setChecked(a);
+}
+
+void KFocusConfig::updateActiveMouseScreen()
+{
+    // on by default for non click to focus policies
+    KConfigGroup cfg( config, "Windows" );
+    if( !cfg.hasKey( KWIN_ACTIVE_MOUSE_SCREEN ))
+        setActiveMouseScreen( focusCombo->currentItem() != 0 );
+}
+
+void KFocusConfig::setAltTabMode(bool a) {
+    altTabPopup->setChecked(a);
+}
+
+void KFocusConfig::setTraverseAll(bool a) {
+    traverseAll->setChecked(a);
+}
+
+void KFocusConfig::setRollOverDesktops(bool a) {
+    rollOverDesktops->setChecked(a);
+}
+
+void KFocusConfig::setShowPopupinfo(bool a) {
+    showPopupinfo->setChecked(a);
+}
+
+void KFocusConfig::load( void )
+{
+    TQString key;
+
+    config->setGroup( "Windows" );
+
+    key = config->readEntry(KWIN_FOCUS);
+    if( key == "ClickToFocus")
+        setFocus(CLICK_TO_FOCUS);
+    else if( key == "FocusFollowsMouse")
+        setFocus(FOCUS_FOLLOWS_MOUSE);
+    else if(key == "FocusUnderMouse")
+        setFocus(FOCUS_UNDER_MOUSE);
+    else if(key == "FocusStrictlyUnderMouse")
+        setFocus(FOCUS_STRICTLY_UNDER_MOUSE);
+
+    int k = config->readNumEntry(KWIN_AUTORAISE_INTERVAL,750);
+    setAutoRaiseInterval(k);
+
+    k = config->readNumEntry(KWIN_DELAYFOCUS_INTERVAL,750);
+    setDelayFocusInterval(k);
+
+    key = config->readEntry(KWIN_AUTORAISE);
+    setAutoRaise(key == "on");
+    key = config->readEntry(KWIN_DELAYFOCUS);
+    setDelayFocus(key == "on");
+    key = config->readEntry(KWIN_CLICKRAISE);
+    setClickRaise(key != "off");
+    setAutoRaiseEnabled();      // this will disable/hide the auto raise delay widget if focus==click
+    setDelayFocusEnabled();
+    
+    setSeparateScreenFocus( config->readBoolEntry(KWIN_SEPARATE_SCREEN_FOCUS, false));
+    // on by default for non click to focus policies
+    setActiveMouseScreen( config->readBoolEntry(KWIN_ACTIVE_MOUSE_SCREEN, focusCombo->currentItem() != 0 ));
+
+    key = config->readEntry(KWIN_ALTTABMODE, "KDE");
+    setAltTabMode(key == "KDE");
+
+    setRollOverDesktops( config->readBoolEntry(KWIN_ROLL_OVER_DESKTOPS, true ));
+
+    config->setGroup( "PopupInfo" );
+    setShowPopupinfo( config->readBoolEntry(KWIN_SHOW_POPUP, false ));
+
+    config->setGroup( "TabBox" );
+    setTraverseAll( config->readBoolEntry(KWIN_TRAVERSE_ALL, false ));
+
+    config->setGroup("Desktops");
+    emit KCModule::changed(false);
+}
+
+void KFocusConfig::save( void )
+{
+    int v;
+
+    config->setGroup( "Windows" );
+
+    v = getFocus();
+    if (v == CLICK_TO_FOCUS)
+        config->writeEntry(KWIN_FOCUS,"ClickToFocus");
+    else if (v == FOCUS_UNDER_MOUSE)
+        config->writeEntry(KWIN_FOCUS,"FocusUnderMouse");
+    else if (v == FOCUS_STRICTLY_UNDER_MOUSE)
+        config->writeEntry(KWIN_FOCUS,"FocusStrictlyUnderMouse");
+    else
+        config->writeEntry(KWIN_FOCUS,"FocusFollowsMouse");
+
+    v = getAutoRaiseInterval();
+    if (v <0) v = 0;
+    config->writeEntry(KWIN_AUTORAISE_INTERVAL,v);
+
+    v = getDelayFocusInterval();
+    if (v <0) v = 0;
+    config->writeEntry(KWIN_DELAYFOCUS_INTERVAL,v);
+
+    if (autoRaiseOn->isChecked())
+        config->writeEntry(KWIN_AUTORAISE, "on");
+    else
+        config->writeEntry(KWIN_AUTORAISE, "off");
+
+    if (delayFocusOn->isChecked())
+        config->writeEntry(KWIN_DELAYFOCUS, "on");
+    else
+        config->writeEntry(KWIN_DELAYFOCUS, "off");
+
+    if (clickRaiseOn->isChecked())
+        config->writeEntry(KWIN_CLICKRAISE, "on");
+    else
+        config->writeEntry(KWIN_CLICKRAISE, "off");
+
+    config->writeEntry(KWIN_SEPARATE_SCREEN_FOCUS, separateScreenFocus->isChecked());
+    config->writeEntry(KWIN_ACTIVE_MOUSE_SCREEN, activeMouseScreen->isChecked());
+
+    if (altTabPopup->isChecked())
+        config->writeEntry(KWIN_ALTTABMODE, "KDE");
+    else
+        config->writeEntry(KWIN_ALTTABMODE, "CDE");
+
+    config->writeEntry( KWIN_ROLL_OVER_DESKTOPS, rollOverDesktops->isChecked());
+
+    config->setGroup( "PopupInfo" );
+    config->writeEntry( KWIN_SHOW_POPUP, showPopupinfo->isChecked());
+
+    config->setGroup( "TabBox" );
+    config->writeEntry( KWIN_TRAVERSE_ALL , traverseAll->isChecked());
+
+    config->setGroup("Desktops");
+
+    if (standAlone)
+    {
+        config->sync();
+        if ( !kapp->dcopClient()->isAttached() )
+            kapp->dcopClient()->attach();
+        kapp->dcopClient()->send("twin*", "", "reconfigure()", TQString(""));
+    }
+    emit KCModule::changed(false);
+}
+
+void KFocusConfig::defaults()
+{
+    setAutoRaiseInterval(0);
+    setDelayFocusInterval(0);
+    setFocus(CLICK_TO_FOCUS);
+    setAutoRaise(false);
+    setDelayFocus(false);
+    setClickRaise(true);
+    setSeparateScreenFocus( false );
+    // on by default for non click to focus policies
+    setActiveMouseScreen( focusCombo->currentItem() != 0 );
+    setAltTabMode(true);
+    setTraverseAll( false );
+    setRollOverDesktops(true);
+    setShowPopupinfo(false);
+    emit KCModule::changed(true);
+}
+
+KAdvancedConfig::~KAdvancedConfig ()
+{
+    if (standAlone)
+        delete config;
+}
+
+KAdvancedConfig::KAdvancedConfig (bool _standAlone, KConfig *_config, TQWidget *parent, const char *)
+    : KCModule(parent, "kcmkwm"), config(_config), standAlone(_standAlone)
+{
+    TQString wtstr;
+    TQBoxLayout *lay = new TQVBoxLayout (this, 0, KDialog::spacingHint());
+
+    //iTLabel = new TQLabel(i18n("  Allowed overlap:\n"
+    //                         "(% of desktop space)"),
+    //             plcBox);
+    //iTLabel->tqsetAlignment(AlignTop|AlignHCenter);
+    //pLay->addWidget(iTLabel,1,1);
+
+    //interactiveTrigger = new TQSpinBox(0, 500, 1, plcBox);
+    //pLay->addWidget(interactiveTrigger,1,2);
+
+    //pLay->addRowSpacing(2,KDialog::spacingHint());
+
+    //lay->addWidget(plcBox);
+
+    shBox = new TQVButtonGroup(i18n("Shading"), this);
+
+    animateShade = new TQCheckBox(i18n("Anima&te"), shBox);
+    TQWhatsThis::add(animateShade, i18n("Animate the action of reducing the window to its titlebar (shading)"
+                                       " as well as the expansion of a shaded window") );
+
+    shadeHoverOn = new TQCheckBox(i18n("&Enable hover"), shBox);
+
+    connect(shadeHoverOn, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(shadeHoverChanged(bool)));
+
+    shadeHover = new KIntNumInput(500, shBox);
+    shadeHover->setLabel(i18n("Dela&y:"), Qt::AlignVCenter|Qt::AlignLeft);
+    shadeHover->setRange(0, 3000, 100, true);
+    shadeHover->setSteps(100, 100);
+    shadeHover->setSuffix(i18n(" msec"));
+
+    TQWhatsThis::add(shadeHoverOn, i18n("If Shade Hover is enabled, a shaded window will un-shade automatically "
+                                       "when the mouse pointer has been over the title bar for some time."));
+
+    wtstr = i18n("Sets the time in milliseconds before the window unshades "
+                "when the mouse pointer goes over the shaded window.");
+    TQWhatsThis::add(shadeHover, wtstr);
+
+    lay->addWidget(shBox);
+
+    // Any changes goes to slotChanged()
+    connect(animateShade, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+    connect(shadeHoverOn, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+    connect(shadeHover, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+
+    electricBox = new TQVButtonGroup(i18n("Active Desktop Borders"), this);
+    electricBox->setMargin(15);
+
+    TQWhatsThis::add( electricBox, i18n("If this option is enabled, moving the mouse to a screen border"
+       " will change your desktop. This is e.g. useful if you want to drag windows from one desktop"
+       " to the other.") );
+    active_disable = new TQRadioButton(i18n("D&isabled"), electricBox);
+    active_move    = new TQRadioButton(i18n("Only &when moving windows"), electricBox);
+    active_always  = new TQRadioButton(i18n("A&lways enabled"), electricBox);
+
+    delays = new KIntNumInput(10, electricBox);
+    delays->setRange(0, MAX_EDGE_RES, 50, true);
+    delays->setSuffix(i18n(" msec"));
+    delays->setLabel(i18n("Desktop &switch delay:"));
+    TQWhatsThis::add( delays, i18n("Here you can set a delay for switching desktops using the active"
+       " borders feature. Desktops will be switched after the mouse has been pushed against a screen border"
+       " for the specified number of milliseconds.") );
+
+    connect( electricBox, TQT_SIGNAL(clicked(int)), this, TQT_SLOT(setEBorders()));
+
+    // Any changes goes to slotChanged()
+    connect(electricBox, TQT_SIGNAL(clicked(int)), TQT_SLOT(changed()));
+    connect(delays, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+
+    lay->addWidget(electricBox);
+
+    TQHBoxLayout* focusStealingLayout = new TQHBoxLayout( lay,KDialog::spacingHint());
+    TQLabel* focusStealingLabel = new TQLabel( i18n( "Focus stealing prevention level:" ), this );
+    focusStealing = new TQComboBox( this );
+    focusStealing->insertItem( i18n( "Focus Stealing Prevention Level", "None" ));
+    focusStealing->insertItem( i18n( "Focus Stealing Prevention Level", "Low" ));
+    focusStealing->insertItem( i18n( "Focus Stealing Prevention Level", "Normal" ));
+    focusStealing->insertItem( i18n( "Focus Stealing Prevention Level", "High" ));
+    focusStealing->insertItem( i18n( "Focus Stealing Prevention Level", "Extreme" ));
+    focusStealingLabel->setBuddy( focusStealing );
+    focusStealingLayout->addWidget( focusStealingLabel );
+    focusStealingLayout->addWidget( focusStealing, AlignLeft );
+    wtstr = i18n( "<p>This option specifies how much KWin will try to prevent unwanted focus stealing "
+                  "caused by unexpected activation of new windows. (Note: This feature does not "
+                  "work with the Focus Under Mouse or Focus Strictly Under Mouse focus policies.)"
+                  "<ul>"
+                  "<li><em>None:</em> Prevention is turned off "
+                  "and new windows always become activated.</li>"
+                  "<li><em>Low:</em> Prevention is enabled; when some window does not have support "
+                  "for the underlying mechanism and KWin cannot reliably decide whether to "
+                  "activate the window or not, it will be activated. This setting may have both "
+                  "worse and better results than normal level, depending on the applications.</li>"
+                  "<li><em>Normal:</em> Prevention is enabled.</li>"
+                  "<li><em>High:</em> New windows get activated only if no window is currently active "
+                  "or if they belong to the currently active application. This setting is probably "
+                  "not really usable when not using mouse focus policy.</li>"
+                  "<li><em>Extreme:</em> All windows must be explicitly activated by the user.</li>"
+                  "</ul></p>"
+                  "<p>Windows that are prevented from stealing focus are marked as demanding attention, "
+                  "which by default means their taskbar entry will be highlighted. This can be changed "
+                  "in the Notifications control module.</p>" );
+    TQWhatsThis::add( focusStealing, wtstr );
+    TQWhatsThis::add( focusStealingLabel, wtstr );
+    connect(focusStealing, TQT_SIGNAL(activated(int)), TQT_SLOT(changed()));
+    
+    hideUtilityWindowsForInactive = new TQCheckBox( i18n( "Hide utility windows for inactive applications" ), this );
+    TQWhatsThis::add( hideUtilityWindowsForInactive,
+        i18n( "When turned on, utility windows (tool windows, torn-off menus,...) of inactive applications will be"
+              " hidden and will be shown only when the application becomes active. Note that applications"
+              " have to mark the windows with the proper window type for this feature to work." ));
+    connect(hideUtilityWindowsForInactive, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+    lay->addWidget( hideUtilityWindowsForInactive );
+
+    lay->addStretch();
+    load();
+
+}
+
+void KAdvancedConfig::setShadeHover(bool on) {
+    shadeHoverOn->setChecked(on);
+    shadeHover->setEnabled(on);
+}
+
+void KAdvancedConfig::setShadeHoverInterval(int k) {
+    shadeHover->setValue(k);
+}
+
+int KAdvancedConfig::getShadeHoverInterval() {
+
+    return shadeHover->value();
+}
+
+void KAdvancedConfig::shadeHoverChanged(bool a) {
+    shadeHover->setEnabled(a);
+}
+
+void KAdvancedConfig::setAnimateShade(bool a) {
+    animateShade->setChecked(a);
+}
+
+void KAdvancedConfig::setFocusStealing(int l) {
+    l = KMAX( 0, KMIN( 4, l ));
+    focusStealing->setCurrentItem(l);
+}
+
+void KAdvancedConfig::setHideUtilityWindowsForInactive(bool s) {
+    hideUtilityWindowsForInactive->setChecked( s );
+}
+
+void KAdvancedConfig::load( void )
+{
+    config->setGroup( "Windows" );
+
+    setAnimateShade(config->readBoolEntry(KWIN_ANIMSHADE, true));
+    setShadeHover(config->readBoolEntry(KWIN_SHADEHOVER, false));
+    setShadeHoverInterval(config->readNumEntry(KWIN_SHADEHOVER_INTERVAL, 250));
+
+    setElectricBorders(config->readNumEntry(KWM_ELECTRIC_BORDER, 0));
+    setElectricBorderDelay(config->readNumEntry(KWM_ELECTRIC_BORDER_DELAY, 150));
+
+//    setFocusStealing( config->readNumEntry(KWIN_FOCUS_STEALING, 2 ));
+    // TODO default to low for now
+    setFocusStealing( config->readNumEntry(KWIN_FOCUS_STEALING, 1 ));
+    setHideUtilityWindowsForInactive( config->readBoolEntry( KWIN_HIDE_UTILITY, true ));
+
+    emit KCModule::changed(false);
+}
+
+void KAdvancedConfig::save( void )
+{
+    int v;
+
+    config->setGroup( "Windows" );
+    config->writeEntry(KWIN_ANIMSHADE, animateShade->isChecked());
+    if (shadeHoverOn->isChecked())
+        config->writeEntry(KWIN_SHADEHOVER, "on");
+    else
+        config->writeEntry(KWIN_SHADEHOVER, "off");
+
+    v = getShadeHoverInterval();
+    if (v<0) v = 0;
+    config->writeEntry(KWIN_SHADEHOVER_INTERVAL, v);
+
+    config->writeEntry(KWM_ELECTRIC_BORDER, getElectricBorders());
+    config->writeEntry(KWM_ELECTRIC_BORDER_DELAY,getElectricBorderDelay());
+
+    config->writeEntry(KWIN_FOCUS_STEALING, focusStealing->currentItem());
+    config->writeEntry(KWIN_HIDE_UTILITY, hideUtilityWindowsForInactive->isChecked());
+
+    if (standAlone)
+    {
+        config->sync();
+        if ( !kapp->dcopClient()->isAttached() )
+            kapp->dcopClient()->attach();
+        kapp->dcopClient()->send("twin*", "", "reconfigure()", TQString(""));
+    }
+    emit KCModule::changed(false);
+}
+
+void KAdvancedConfig::defaults()
+{
+    setAnimateShade(true);
+    setShadeHover(false);
+    setShadeHoverInterval(250);
+    setElectricBorders(0);
+    setElectricBorderDelay(150);
+//    setFocusStealing(2);
+    // TODO default to low for now
+    setFocusStealing(1);
+    setHideUtilityWindowsForInactive( true );
+    emit KCModule::changed(true);
+}
+
+void KAdvancedConfig::setEBorders()
+{
+    delays->setEnabled(!active_disable->isChecked());
+}
+
+int KAdvancedConfig::getElectricBorders()
+{
+    if (active_move->isChecked())
+       return 1;
+    if (active_always->isChecked())
+       return 2;
+    return 0;
+}
+
+int KAdvancedConfig::getElectricBorderDelay()
+{
+    return delays->value();
+}
+
+void KAdvancedConfig::setElectricBorders(int i){
+    switch(i)
+    {
+      case 1: active_move->setChecked(true); break;
+      case 2: active_always->setChecked(true); break;
+      default: active_disable->setChecked(true); break;
+    }
+    setEBorders();
+}
+
+void KAdvancedConfig::setElectricBorderDelay(int delay)
+{
+    delays->setValue(delay);
+}
+
+
+KMovingConfig::~KMovingConfig ()
+{
+    if (standAlone)
+        delete config;
+}
+
+KMovingConfig::KMovingConfig (bool _standAlone, KConfig *_config, TQWidget *parent, const char *)
+    : KCModule(parent, "kcmkwm"), config(_config), standAlone(_standAlone)
+{
+    TQString wtstr;
+    TQBoxLayout *lay = new TQVBoxLayout (this, 0, KDialog::spacingHint());
+
+    windowsBox = new TQButtonGroup(i18n("Windows"), this);
+    windowsBox->setColumnLayout( 0, Qt::Horizontal );
+
+    TQBoxLayout *wLay = new TQVBoxLayout (windowsBox->tqlayout(), KDialog::spacingHint());
+
+    TQBoxLayout *bLay = new TQVBoxLayout;
+    wLay->addLayout(bLay);
+
+    opaque = new TQCheckBox(i18n("Di&splay content in moving windows"), windowsBox);
+    bLay->addWidget(opaque);
+    TQWhatsThis::add( opaque, i18n("Enable this option if you want a window's content to be fully shown"
+                                  " while moving it, instead of just showing a window 'skeleton'. The result may not be satisfying"
+                                  " on slow machines without graphic acceleration.") );
+
+    resizeOpaqueOn = new TQCheckBox(i18n("Display content in &resizing windows"), windowsBox);
+    bLay->addWidget(resizeOpaqueOn);
+    TQWhatsThis::add( resizeOpaqueOn, i18n("Enable this option if you want a window's content to be shown"
+                                          " while resizing it, instead of just showing a window 'skeleton'. The result may not be satisfying"
+                                          " on slow machines.") );
+
+    geometryTipOn = new TQCheckBox(i18n("Display window &geometry when moving or resizing"), windowsBox);
+    bLay->addWidget(geometryTipOn);
+    TQWhatsThis::add(geometryTipOn, i18n("Enable this option if you want a window's geometry to be displayed"
+                                        " while it is being moved or resized. The window position relative"
+                                        " to the top-left corner of the screen is displayed together with"
+                                        " its size."));
+
+    TQGridLayout *rLay = new TQGridLayout(2,3);
+    bLay->addLayout(TQT_TQLAYOUT(rLay));
+    rLay->setColStretch(0,0);
+    rLay->setColStretch(1,1);
+
+    minimizeAnimOn = new TQCheckBox(i18n("Animate minimi&ze and restore"),
+                                   windowsBox);
+    TQWhatsThis::add( minimizeAnimOn, i18n("Enable this option if you want an animation shown when"
+                                          " windows are minimized or restored." ) );
+    rLay->addWidget(minimizeAnimOn,0,0);
+
+    minimizeAnimSlider = new TQSlider(0,10,10,0,Qt::Horizontal, windowsBox);
+    minimizeAnimSlider->setSteps(1, 1);
+    // TQSlider::Below clashes with a X11/X.h #define
+    #undef Below
+    minimizeAnimSlider->setTickmarks(TQSlider::Below);
+    rLay->addMultiCellWidget(minimizeAnimSlider,0,0,1,2);
+
+    connect(minimizeAnimOn, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(setMinimizeAnim(bool)));
+    connect(minimizeAnimSlider, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(setMinimizeAnimSpeed(int)));
+
+    minimizeAnimSlowLabel= new TQLabel(i18n("Slow"),windowsBox);
+    minimizeAnimSlowLabel->tqsetAlignment(Qt::AlignTop|Qt::AlignLeft);
+    rLay->addWidget(minimizeAnimSlowLabel,1,1);
+
+    minimizeAnimFastLabel= new TQLabel(i18n("Fast"),windowsBox);
+    minimizeAnimFastLabel->tqsetAlignment(Qt::AlignTop|Qt::AlignRight);
+    rLay->addWidget(minimizeAnimFastLabel,1,2);
+
+    wtstr = i18n("Here you can set the speed of the animation shown when windows are"
+                 " minimized and restored. ");
+    TQWhatsThis::add( minimizeAnimSlider, wtstr );
+    TQWhatsThis::add( minimizeAnimSlowLabel, wtstr );
+    TQWhatsThis::add( minimizeAnimFastLabel, wtstr );
+
+    moveResizeMaximized = new TQCheckBox( i18n("Allow moving and resizing o&f maximized windows"), windowsBox);
+    bLay->addWidget(moveResizeMaximized);
+    TQWhatsThis::add(moveResizeMaximized, i18n("When enabled, this feature activates the border of maximized windows"
+                                              " and allows you to move or resize them,"
+                                              " just like for normal windows"));
+
+    TQBoxLayout *vLay = new TQHBoxLayout(bLay);
+
+    TQLabel *plcLabel = new TQLabel(i18n("&Placement:"),windowsBox);
+
+    placementCombo = new TQComboBox(false, windowsBox);
+    placementCombo->insertItem(i18n("Smart"), SMART_PLACEMENT);
+    placementCombo->insertItem(i18n("Maximizing"), MAXIMIZING_PLACEMENT);
+    placementCombo->insertItem(i18n("Cascade"), CASCADE_PLACEMENT);
+    placementCombo->insertItem(i18n("Random"), RANDOM_PLACEMENT);
+    placementCombo->insertItem(i18n("Centered"), CENTERED_PLACEMENT);
+    placementCombo->insertItem(i18n("Zero-Cornered"), ZEROCORNERED_PLACEMENT);
+    // CT: disabling is needed as long as functionality misses in twin
+    //placementCombo->insertItem(i18n("Interactive"), INTERACTIVE_PLACEMENT);
+    //placementCombo->insertItem(i18n("Manual"), MANUAL_PLACEMENT);
+    placementCombo->setCurrentItem(SMART_PLACEMENT);
+
+    // FIXME, when more policies have been added to KWin
+    wtstr = i18n("The placement policy determines where a new window"
+                 " will appear on the desktop."
+                 " <ul>"
+                 " <li><em>Smart</em> will try to achieve a minimum overlap of windows</li>"
+                 " <li><em>Maximizing</em> will try to maximize every window to fill the whole screen."
+                 " It might be useful to selectively affect placement of some windows using"
+                 " the window-specific settings.</li>"
+                 " <li><em>Cascade</em> will cascade the windows</li>"
+                 " <li><em>Random</em> will use a random position</li>"
+                 " <li><em>Centered</em> will place the window centered</li>"
+                 " <li><em>Zero-Cornered</em> will place the window in the top-left corner</li>"
+                 "</ul>") ;
+
+    TQWhatsThis::add( plcLabel, wtstr);
+    TQWhatsThis::add( placementCombo, wtstr);
+
+    plcLabel->setBuddy(placementCombo);
+    vLay->addWidget(plcLabel, 0);
+    vLay->addWidget(placementCombo, 1, Qt::AlignLeft);
+
+    bLay->addSpacing(10);
+
+    lay->addWidget(windowsBox);
+
+    //iTLabel = new TQLabel(i18n("  Allowed overlap:\n"
+    //                         "(% of desktop space)"),
+    //             plcBox);
+    //iTLabel->tqsetAlignment(AlignTop|AlignHCenter);
+    //pLay->addWidget(iTLabel,1,1);
+
+    //interactiveTrigger = new TQSpinBox(0, 500, 1, plcBox);
+    //pLay->addWidget(interactiveTrigger,1,2);
+
+    //pLay->addRowSpacing(2,KDialog::spacingHint());
+
+    //lay->addWidget(plcBox);
+
+
+    //CT 15mar98 - add EdgeResistance, BorderAttractor, WindowsAttractor config
+    MagicBox = new TQVButtonGroup(i18n("Snap Zones"), this);
+    MagicBox->setMargin(15);
+
+    BrdrSnap = new KIntNumInput(10, MagicBox);
+    BrdrSnap->setSpecialValueText( i18n("none") );
+    BrdrSnap->setRange( 0, MAX_BRDR_SNAP);
+    BrdrSnap->setLabel(i18n("&Border snap zone:"));
+    BrdrSnap->setSteps(1,10);
+    TQWhatsThis::add( BrdrSnap, i18n("Here you can set the snap zone for screen borders, i.e."
+                                    " the 'strength' of the magnetic field which will make windows snap to the border when"
+                                    " moved near it.") );
+
+    WndwSnap = new KIntNumInput(10, MagicBox);
+    WndwSnap->setSpecialValueText( i18n("none") );
+    WndwSnap->setRange( 0, MAX_WNDW_SNAP);
+    WndwSnap->setLabel(i18n("&Window snap zone:"));
+    BrdrSnap->setSteps(1,10);
+    TQWhatsThis::add( WndwSnap, i18n("Here you can set the snap zone for windows, i.e."
+                                    " the 'strength' of the magnetic field which will make windows snap to each other when"
+                                    " they're moved near another window.") );
+
+    OverlapSnap=new TQCheckBox(i18n("Snap windows onl&y when overlapping"),MagicBox);
+    TQWhatsThis::add( OverlapSnap, i18n("Here you can set that windows will be only"
+                                       " snapped if you try to overlap them, i.e. they will not be snapped if the windows"
+                                       " comes only near another window or border.") );
+
+    lay->addWidget(MagicBox);
+    lay->addStretch();
+
+    load();
+
+    // Any changes goes to slotChanged()
+    connect( opaque, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+    connect( resizeOpaqueOn, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+    connect( geometryTipOn, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+    connect( minimizeAnimOn, TQT_SIGNAL(clicked() ), TQT_SLOT(changed()));
+    connect( minimizeAnimSlider, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+    connect( moveResizeMaximized, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+    connect( placementCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(changed()));
+    connect( BrdrSnap, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+    connect( BrdrSnap, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotBrdrSnapChanged(int)));
+    connect( WndwSnap, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+    connect( WndwSnap, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotWndwSnapChanged(int)));
+    connect( OverlapSnap, TQT_SIGNAL(clicked()), TQT_SLOT(changed()));
+
+    // To get suffix to BrdrSnap and WndwSnap inputs with default values.
+    slotBrdrSnapChanged(BrdrSnap->value());
+    slotWndwSnapChanged(WndwSnap->value());
+}
+
+int KMovingConfig::getMove()
+{
+    return (opaque->isChecked())? OPAQUE : TRANSPARENT;
+}
+
+void KMovingConfig::setMove(int trans)
+{
+    opaque->setChecked(trans == OPAQUE);
+}
+
+void KMovingConfig::setGeometryTip(bool showGeometryTip)
+{
+    geometryTipOn->setChecked(showGeometryTip);
+}
+
+bool KMovingConfig::getGeometryTip()
+{
+    return geometryTipOn->isChecked();
+}
+
+// placement policy --- CT 31jan98 ---
+int KMovingConfig::getPlacement()
+{
+    return placementCombo->currentItem();
+}
+
+void KMovingConfig::setPlacement(int plac)
+{
+    placementCombo->setCurrentItem(plac);
+}
+
+bool KMovingConfig::getMinimizeAnim()
+{
+    return minimizeAnimOn->isChecked();
+}
+
+int KMovingConfig::getMinimizeAnimSpeed()
+{
+    return minimizeAnimSlider->value();
+}
+
+void KMovingConfig::setMinimizeAnim(bool anim)
+{
+    minimizeAnimOn->setChecked( anim );
+    minimizeAnimSlider->setEnabled( anim );
+    minimizeAnimSlowLabel->setEnabled( anim );
+    minimizeAnimFastLabel->setEnabled( anim );
+}
+
+void KMovingConfig::setMinimizeAnimSpeed(int speed)
+{
+    minimizeAnimSlider->setValue(speed);
+}
+
+int KMovingConfig::getResizeOpaque()
+{
+    return (resizeOpaqueOn->isChecked())? RESIZE_OPAQUE : RESIZE_TRANSPARENT;
+}
+
+void KMovingConfig::setResizeOpaque(int opaque)
+{
+    resizeOpaqueOn->setChecked(opaque == RESIZE_OPAQUE);
+}
+
+void KMovingConfig::setMoveResizeMaximized(bool a) {
+    moveResizeMaximized->setChecked(a);
+}
+
+void KMovingConfig::slotBrdrSnapChanged(int value) {
+    BrdrSnap->setSuffix(i18n(" pixel", " pixels", value));
+}
+
+void KMovingConfig::slotWndwSnapChanged(int value) {
+    WndwSnap->setSuffix(i18n(" pixel", " pixels", value));
+}
+
+void KMovingConfig::load( void )
+{
+    TQString key;
+
+    config->setGroup( "Windows" );
+
+    key = config->readEntry(KWIN_MOVE, "Opaque");
+    if( key == "Transparent")
+        setMove(TRANSPARENT);
+    else if( key == "Opaque")
+        setMove(OPAQUE);
+
+    //CT 17Jun1998 - variable animation speed from 0 (none!!) to 10 (max)
+    bool anim = config->readBoolEntry(KWIN_MINIMIZE_ANIM, true );
+    int animSpeed = config->readNumEntry(KWIN_MINIMIZE_ANIM_SPEED, 5);
+    if( animSpeed < 1 ) animSpeed = 0;
+    if( animSpeed > 10 ) animSpeed = 10;
+    setMinimizeAnim( anim );
+    setMinimizeAnimSpeed( animSpeed );
+
+    // DF: please keep the default consistent with twin (options.cpp line 145)
+    key = config->readEntry(KWIN_RESIZE_OPAQUE, "Opaque");
+    if( key == "Opaque")
+        setResizeOpaque(RESIZE_OPAQUE);
+    else if ( key == "Transparent")
+        setResizeOpaque(RESIZE_TRANSPARENT);
+
+    //KS 10Jan2003 - Geometry Tip during window move/resize
+    bool showGeomTip = config->readBoolEntry(KWIN_GEOMETRY, false);
+    setGeometryTip( showGeomTip );
+
+    // placement policy --- CT 19jan98 ---
+    key = config->readEntry(KWIN_PLACEMENT);
+    //CT 13mar98 interactive placement
+//   if( key.left(11) == "interactive") {
+//     setPlacement(INTERACTIVE_PLACEMENT);
+//     int comma_pos = key.find(',');
+//     if (comma_pos < 0)
+//       interactiveTrigger->setValue(0);
+//     else
+//       interactiveTrigger->setValue (key.right(key.length()
+//                           - comma_pos).toUInt(0));
+//     iTLabel->setEnabled(true);
+//     interactiveTrigger->show();
+//   }
+//   else {
+//     interactiveTrigger->setValue(0);
+//     iTLabel->setEnabled(false);
+//     interactiveTrigger->hide();
+    if( key == "Random")
+        setPlacement(RANDOM_PLACEMENT);
+    else if( key == "Cascade")
+        setPlacement(CASCADE_PLACEMENT); //CT 31jan98
+    //CT 31mar98 manual placement
+    else if( key == "manual")
+        setPlacement(MANUAL_PLACEMENT);
+    else if( key == "Centered")
+        setPlacement(CENTERED_PLACEMENT);
+    else if( key == "ZeroCornered")
+        setPlacement(ZEROCORNERED_PLACEMENT);
+    else if( key == "Maximizing")
+        setPlacement(MAXIMIZING_PLACEMENT);
+    else
+        setPlacement(SMART_PLACEMENT);
+//  }
+
+    setMoveResizeMaximized(config->readBoolEntry(KWIN_MOVE_RESIZE_MAXIMIZED, false));
+
+    int v;
+
+    v = config->readNumEntry(KWM_BRDR_SNAP_ZONE, KWM_BRDR_SNAP_ZONE_DEFAULT);
+    if (v > MAX_BRDR_SNAP) setBorderSnapZone(MAX_BRDR_SNAP);
+    else if (v < 0) setBorderSnapZone (0);
+    else setBorderSnapZone(v);
+
+    v = config->readNumEntry(KWM_WNDW_SNAP_ZONE, KWM_WNDW_SNAP_ZONE_DEFAULT);
+    if (v > MAX_WNDW_SNAP) setWindowSnapZone(MAX_WNDW_SNAP);
+    else if (v < 0) setWindowSnapZone (0);
+    else setWindowSnapZone(v);
+
+    OverlapSnap->setChecked(config->readBoolEntry("SnapOnlyWhenOverlapping",false));
+    emit KCModule::changed(false);
+}
+
+void KMovingConfig::save( void )
+{
+    int v;
+
+    config->setGroup( "Windows" );
+
+    v = getMove();
+    if (v == TRANSPARENT)
+        config->writeEntry(KWIN_MOVE,"Transparent");
+    else
+        config->writeEntry(KWIN_MOVE,"Opaque");
+
+    config->writeEntry(KWIN_GEOMETRY, getGeometryTip());
+
+    // placement policy --- CT 31jan98 ---
+    v =getPlacement();
+    if (v == RANDOM_PLACEMENT)
+        config->writeEntry(KWIN_PLACEMENT, "Random");
+    else if (v == CASCADE_PLACEMENT)
+        config->writeEntry(KWIN_PLACEMENT, "Cascade");
+    else if (v == CENTERED_PLACEMENT)
+        config->writeEntry(KWIN_PLACEMENT, "Centered");
+    else if (v == ZEROCORNERED_PLACEMENT)
+        config->writeEntry(KWIN_PLACEMENT, "ZeroCornered");
+    else if (v == MAXIMIZING_PLACEMENT)
+        config->writeEntry(KWIN_PLACEMENT, "Maximizing");
+//CT 13mar98 manual and interactive placement
+//   else if (v == MANUAL_PLACEMENT)
+//     config->writeEntry(KWIN_PLACEMENT, "Manual");
+//   else if (v == INTERACTIVE_PLACEMENT) {
+//       TQString tmpstr = TQString("Interactive,%1").arg(interactiveTrigger->value());
+//       config->writeEntry(KWIN_PLACEMENT, tmpstr);
+//   }
+    else
+        config->writeEntry(KWIN_PLACEMENT, "Smart");
+
+    config->writeEntry(KWIN_MINIMIZE_ANIM, getMinimizeAnim());
+    config->writeEntry(KWIN_MINIMIZE_ANIM_SPEED, getMinimizeAnimSpeed());
+
+    v = getResizeOpaque();
+    if (v == RESIZE_OPAQUE)
+        config->writeEntry(KWIN_RESIZE_OPAQUE, "Opaque");
+    else
+        config->writeEntry(KWIN_RESIZE_OPAQUE, "Transparent");
+
+    config->writeEntry(KWIN_MOVE_RESIZE_MAXIMIZED, moveResizeMaximized->isChecked());
+
+
+    config->writeEntry(KWM_BRDR_SNAP_ZONE,getBorderSnapZone());
+    config->writeEntry(KWM_WNDW_SNAP_ZONE,getWindowSnapZone());
+    config->writeEntry("SnapOnlyWhenOverlapping",OverlapSnap->isChecked());
+
+    if (standAlone)
+    {
+        config->sync();
+        if ( !kapp->dcopClient()->isAttached() )
+            kapp->dcopClient()->attach();
+        kapp->dcopClient()->send("twin*", "", "reconfigure()", TQString(""));
+    }
+    emit KCModule::changed(false);
+}
+
+void KMovingConfig::defaults()
+{
+    setMove(OPAQUE);
+    setResizeOpaque(RESIZE_TRANSPARENT);
+    setGeometryTip(false);
+    setPlacement(SMART_PLACEMENT);
+    setMoveResizeMaximized(false);
+
+    //copied from kcontrol/konq/twindesktop, aleXXX
+    setWindowSnapZone(KWM_WNDW_SNAP_ZONE_DEFAULT);
+    setBorderSnapZone(KWM_BRDR_SNAP_ZONE_DEFAULT);
+    OverlapSnap->setChecked(false);
+
+    setMinimizeAnim( true );
+    setMinimizeAnimSpeed( 5 );
+    emit KCModule::changed(true);
+}
+
+int KMovingConfig::getBorderSnapZone() {
+  return BrdrSnap->value();
+}
+
+void KMovingConfig::setBorderSnapZone(int pxls) {
+  BrdrSnap->setValue(pxls);
+}
+
+int KMovingConfig::getWindowSnapZone() {
+  return WndwSnap->value();
+}
+
+void KMovingConfig::setWindowSnapZone(int pxls) {
+  WndwSnap->setValue(pxls);
+}
+
+KTranslucencyConfig::~KTranslucencyConfig ()
+{
+    if (standAlone)
+        delete config;
+    if (kompmgr)
+        kompmgr->detach();
+}
+
+KTranslucencyConfig::KTranslucencyConfig (bool _standAlone, KConfig *_config, TQWidget *parent, const char *)
+    : KCModule(parent, "kcmkwm"), config(_config), standAlone(_standAlone)
+{
+  kompmgr = 0L;
+  resetKompmgr_ = FALSE;
+  TQVBoxLayout *lay = new TQVBoxLayout (this);
+  kompmgrAvailable_ = kompmgrAvailable();
+  if (!kompmgrAvailable_){
+  KActiveLabel *label = new KActiveLabel(i18n("<qt><b>It seems that alpha channel support is not available.</b><br><br>"
+                                 "Please make sure you have "
+                                 "<a href=\"http://www.freedesktop.org/\">Xorg &ge; 6.8</a>,"
+                                 " and installed the kompmgr that came with twin.<br>"
+                                 "Also, make sure you have the following entries in your XConfig (e.g. /etc/X11/xorg.conf):<br><br>"
+                                 "<i>Section \"Extensions\"<br>"
+                                 "Option \"Composite\" \"Enable\"<br>"
+                                 "EndSection</i><br><br>"
+                                 "And if your GPU provides hardware-accelerated Xrender support (mainly nVidia cards):<br><br>"
+                                 "<i>Option     \"RenderAccel\" \"true\"</i><br>"
+                                 "In <i>Section \"Device\"</i></qt>"), this);
+  lay->addWidget(label);
+  }
+  else
+  {
+  TQTabWidget *tabW = new TQTabWidget(this);
+  TQWidget *tGroup = new TQWidget(tabW);
+  TQVBoxLayout *vLay = new TQVBoxLayout (tGroup,KDialog::marginHint(), KDialog::spacingHint());
+  vLay->addSpacing(11); // to get the proper gb top offset
+  
+  onlyDecoTranslucent = new TQCheckBox(i18n("Apply translucency only to decoration"),tGroup);
+  vLay->addWidget(onlyDecoTranslucent);
+  
+  vLay->addSpacing(11);
+  
+  TQGridLayout *gLay = new TQGridLayout(vLay,4,2,KDialog::spacingHint());
+  gLay->setColStretch(1,1);
+
+  activeWindowTransparency = new TQCheckBox(i18n("Active windows:"),tGroup);
+  gLay->addWidget(activeWindowTransparency,0,0);
+  activeWindowOpacity = new KIntNumInput(100, tGroup);
+  activeWindowOpacity->setRange(0,100);
+  activeWindowOpacity->setSuffix("%");
+  gLay->addWidget(activeWindowOpacity,0,1);
+
+  inactiveWindowTransparency = new TQCheckBox(i18n("Inactive windows:"),tGroup);
+  gLay->addWidget(inactiveWindowTransparency,1,0);
+  inactiveWindowOpacity = new KIntNumInput(100, tGroup);
+  inactiveWindowOpacity->setRange(0,100);
+  inactiveWindowOpacity->setSuffix("%");
+  gLay->addWidget(inactiveWindowOpacity,1,1);
+
+  movingWindowTransparency = new TQCheckBox(i18n("Moving windows:"),tGroup);
+  gLay->addWidget(movingWindowTransparency,2,0);
+  movingWindowOpacity = new KIntNumInput(100, tGroup);
+  movingWindowOpacity->setRange(0,100);
+  movingWindowOpacity->setSuffix("%");
+  gLay->addWidget(movingWindowOpacity,2,1);
+
+  dockWindowTransparency = new TQCheckBox(i18n("Dock windows:"),tGroup);
+  gLay->addWidget(dockWindowTransparency,3,0);
+  dockWindowOpacity = new KIntNumInput(100, tGroup);
+  dockWindowOpacity->setRange(0,100);
+  dockWindowOpacity->setSuffix("%");
+  gLay->addWidget(dockWindowOpacity,3,1);
+  
+  vLay->addSpacing(11);
+
+  keepAboveAsActive = new TQCheckBox(i18n("Treat 'keep above' windows as active ones"),tGroup);
+  vLay->addWidget(keepAboveAsActive);
+
+  disableARGB = new TQCheckBox(i18n("Disable ARGB windows (ignores window alpha maps, fixes gtk1 apps)"),tGroup);
+  vLay->addWidget(disableARGB);
+
+  vLay->addStretch();
+  tabW->addTab(tGroup, i18n("Opacity"));
+
+  TQWidget *sGroup = new TQWidget(tabW);
+//   sGroup->setCheckable(TRUE);
+  TQVBoxLayout *vLay2 = new TQVBoxLayout (sGroup,11,6);
+  vLay2->addSpacing(11); // to get the proper gb top offset
+  useShadows = new TQCheckBox(i18n("Use shadows (standard effects should be disabled in the Styles module if this is checked)"),sGroup);
+  vLay2->addWidget(useShadows);
+
+  vLay2->addSpacing(11);
+
+  TQGridLayout *gLay2 = new TQGridLayout(vLay2,6,2);
+  gLay2->setColStretch(1,1);
+
+  TQLabel *label2 = new TQLabel(i18n("Base shadow size:"),sGroup);
+  gLay2->addWidget(label2,0,0);
+  inactiveWindowShadowSize = new KIntNumInput(6,sGroup);
+  inactiveWindowShadowSize->setRange(0,32);
+//   inactiveWindowShadowSize->setSuffix("px");
+  gLay2->addWidget(inactiveWindowShadowSize,0,1);
+
+  TQLabel *label1 = new TQLabel(i18n("Active window shadow size multiplier:"),sGroup);
+  gLay2->addWidget(label1,1,0);
+  activeWindowShadowSize = new KIntNumInput(12,sGroup);
+  activeWindowShadowSize->setRange(0,32);
+//   activeWindowShadowSize->setSuffix("px");
+  gLay2->addWidget(activeWindowShadowSize,1,1);
+
+  TQLabel *label3 = new TQLabel(i18n("Dock shadow size multiplier:"),sGroup);
+  gLay2->addWidget(label3,2,0);
+  dockWindowShadowSize = new KIntNumInput(6,sGroup);
+  dockWindowShadowSize->setRange(0,32);
+//   dockWindowShadowSize->setSuffix("px");
+  gLay2->addWidget(dockWindowShadowSize,2,1);
+
+  TQLabel *label3a = new TQLabel(i18n("Menu shadow size multiplier:"),sGroup);
+  gLay2->addWidget(label3a,3,0);
+  menuWindowShadowSize = new KIntNumInput(6,sGroup);
+  menuWindowShadowSize->setRange(0,32);
+//   menuWindowShadowSize->setSuffix("px");
+  gLay2->addWidget(menuWindowShadowSize,3,1);
+
+  // Menu shadow settings don't work
+  label3a->hide();
+  menuWindowShadowSize->hide();
+
+  TQLabel *label4 = new TQLabel(i18n("Vertical offset:"),sGroup);
+  gLay2->addWidget(label4,4,0);
+  shadowTopOffset = new KIntNumInput(80,sGroup);
+  shadowTopOffset->setSuffix("%");
+  shadowTopOffset->setRange(-200,200);
+  gLay2->addWidget(shadowTopOffset,4,1);
+
+  TQLabel *label5 = new TQLabel(i18n("Horizontal offset:"),sGroup);
+  gLay2->addWidget(label5,5,0);
+  shadowLeftOffset = new KIntNumInput(0,sGroup);
+  shadowLeftOffset->setSuffix("%");
+  shadowLeftOffset->setRange(-200,200);
+  gLay2->addWidget(shadowLeftOffset,5,1);
+
+  TQLabel *label6 = new TQLabel(i18n("Shadow color:"),sGroup);
+  gLay2->addWidget(label6,5,0);
+  shadowColor = new KColorButton(Qt::black,sGroup);
+  gLay2->addWidget(shadowColor,6,1);
+  gLay2->setColStretch(1,1);
+  vLay2->addSpacing(11);
+  removeShadowsOnMove = new TQCheckBox(i18n("Remove shadows on move"),sGroup);
+  vLay2->addWidget(removeShadowsOnMove);
+  removeShadowsOnResize = new TQCheckBox(i18n("Remove shadows on resize"),sGroup);
+  vLay2->addWidget(removeShadowsOnResize);
+  vLay2->addStretch();
+  tabW->addTab(sGroup, i18n("Shadows"));
+
+  TQWidget *eGroup = new TQWidget(this);
+  TQVBoxLayout *vLay3 = new TQVBoxLayout (eGroup,11,6);
+
+  fadeInWindows = new TQCheckBox(i18n("Fade-in windows (including popups)"),eGroup);
+  fadeInMenuWindows = new TQCheckBox(i18n("Fade-in menus (requires menu fade effect to be disabled in the Styles module)"),eGroup);
+  fadeOnOpacityChange = new TQCheckBox(i18n("Fade between opacity changes"),eGroup);
+  fadeInSpeed = new KIntNumInput(100, eGroup);
+  fadeInSpeed->setRange(1,100);
+  fadeInSpeed->setLabel(i18n("Fade-in speed:"));
+  fadeOutSpeed = new KIntNumInput(100, eGroup);
+  fadeOutSpeed->setRange(1,100);
+  fadeOutSpeed->setLabel(i18n("Fade-out speed:"));
+  vLay3->addWidget(fadeInWindows);
+  vLay3->addWidget(fadeInMenuWindows);
+  vLay3->addWidget(fadeOnOpacityChange);
+  vLay3->addWidget(fadeInSpeed);
+  vLay3->addWidget(fadeOutSpeed);
+  vLay3->addStretch();
+
+  tabW->addTab(eGroup, i18n("Effects"));
+
+  useTranslucency = new TQCheckBox(i18n("Enable the Trinity window composition manager"),this);
+  lay->addWidget(useTranslucency);
+  lay->addWidget(tabW);
+
+  connect(useTranslucency, TQT_SIGNAL(toggled(bool)), tabW, TQT_SLOT(setEnabled(bool)));
+
+  connect(activeWindowTransparency, TQT_SIGNAL(toggled(bool)), activeWindowOpacity, TQT_SLOT(setEnabled(bool)));
+  connect(inactiveWindowTransparency, TQT_SIGNAL(toggled(bool)), inactiveWindowOpacity, TQT_SLOT(setEnabled(bool)));
+  connect(movingWindowTransparency, TQT_SIGNAL(toggled(bool)), movingWindowOpacity, TQT_SLOT(setEnabled(bool)));
+  connect(dockWindowTransparency, TQT_SIGNAL(toggled(bool)), dockWindowOpacity, TQT_SLOT(setEnabled(bool)));
+
+  connect(useTranslucency, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(onlyDecoTranslucent, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(activeWindowTransparency, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(inactiveWindowTransparency, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(movingWindowTransparency, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(dockWindowTransparency, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(keepAboveAsActive, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(disableARGB, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(useShadows, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(removeShadowsOnResize, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(removeShadowsOnMove, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+
+  connect(activeWindowOpacity, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(inactiveWindowOpacity, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(movingWindowOpacity, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(dockWindowOpacity, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(dockWindowShadowSize, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(menuWindowShadowSize, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(activeWindowShadowSize, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(inactiveWindowShadowSize, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(shadowTopOffset, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(shadowLeftOffset, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(shadowColor, TQT_SIGNAL(changed(const TQColor&)), TQT_SLOT(changed()));
+  connect(fadeInWindows, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(fadeInMenuWindows, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(fadeOnOpacityChange, TQT_SIGNAL(toggled(bool)), TQT_SLOT(changed()));
+  connect(fadeInSpeed, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+  connect(fadeOutSpeed, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changed()));
+
+  connect(useShadows, TQT_SIGNAL(toggled(bool)), dockWindowShadowSize, TQT_SLOT(setEnabled(bool)));
+  connect(useShadows, TQT_SIGNAL(toggled(bool)), menuWindowShadowSize, TQT_SLOT(setEnabled(bool)));
+  connect(useShadows, TQT_SIGNAL(toggled(bool)), activeWindowShadowSize, TQT_SLOT(setEnabled(bool)));
+  connect(useShadows, TQT_SIGNAL(toggled(bool)), inactiveWindowShadowSize, TQT_SLOT(setEnabled(bool)));
+  connect(useShadows, TQT_SIGNAL(toggled(bool)), shadowTopOffset, TQT_SLOT(setEnabled(bool)));
+  connect(useShadows, TQT_SIGNAL(toggled(bool)), shadowLeftOffset, TQT_SLOT(setEnabled(bool)));
+  connect(useShadows, TQT_SIGNAL(toggled(bool)), shadowColor, TQT_SLOT(setEnabled(bool)));
+
+  load();
+
+  tabW->setEnabled(useTranslucency->isChecked());
+
+  connect(useTranslucency, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(showWarning(bool)));
+
+  // handle kompmgr restarts if necessary
+  connect(useTranslucency, TQT_SIGNAL(toggled(bool)), TQT_SLOT(resetKompmgr()));
+  connect(disableARGB, TQT_SIGNAL(toggled(bool)), TQT_SLOT(resetKompmgr()));
+  connect(useShadows, TQT_SIGNAL(toggled(bool)), TQT_SLOT(resetKompmgr()));
+  connect(inactiveWindowShadowSize, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(resetKompmgr()));
+  connect(shadowTopOffset, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(resetKompmgr()));
+  connect(shadowLeftOffset, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(resetKompmgr()));
+  connect(shadowColor, TQT_SIGNAL(changed(const TQColor&)), TQT_SLOT(resetKompmgr()));
+  connect(fadeInWindows, TQT_SIGNAL(toggled(bool)), TQT_SLOT(resetKompmgr()));
+  connect(fadeInMenuWindows, TQT_SIGNAL(toggled(bool)), TQT_SLOT(resetKompmgr()));
+  connect(fadeOnOpacityChange, TQT_SIGNAL(toggled(bool)), TQT_SLOT(resetKompmgr()));
+  connect(fadeInSpeed, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(resetKompmgr()));
+  connect(fadeOutSpeed, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(resetKompmgr()));
+
+  }
+}
+
+void KTranslucencyConfig::resetKompmgr()
+{
+    resetKompmgr_ = TRUE;
+}
+void KTranslucencyConfig::load( void )
+{
+
+    if (!kompmgrAvailable_)
+        return;
+  config->setGroup( "Notification Messages" );
+  useTranslucency->setChecked(config->readBoolEntry("UseTranslucency",false));
+
+  config->setGroup( "Translucency" );
+  activeWindowTransparency->setChecked(config->readBoolEntry("TranslucentActiveWindows",false));
+  inactiveWindowTransparency->setChecked(config->readBoolEntry("TranslucentInactiveWindows",false));
+  movingWindowTransparency->setChecked(config->readBoolEntry("TranslucentMovingWindows",false));
+  removeShadowsOnMove->setChecked(config->readBoolEntry("RemoveShadowsOnMove",false));
+  removeShadowsOnResize->setChecked(config->readBoolEntry("RemoveShadowsOnResize",false));
+  dockWindowTransparency->setChecked(config->readBoolEntry("TranslucentDocks",false));
+  keepAboveAsActive->setChecked(config->readBoolEntry("TreatKeepAboveAsActive",true));
+  onlyDecoTranslucent->setChecked(config->readBoolEntry("OnlyDecoTranslucent",false));
+
+  activeWindowOpacity->setValue(config->readNumEntry("ActiveWindowOpacity",100));
+  inactiveWindowOpacity->setValue(config->readNumEntry("InactiveWindowOpacity",75));
+  movingWindowOpacity->setValue(config->readNumEntry("MovingWindowOpacity",25));
+  dockWindowOpacity->setValue(config->readNumEntry("DockOpacity",80));
+
+  int ass, iss, dss, mss;
+  dss = config->readNumEntry("DockShadowSize", 33);
+  mss = config->readNumEntry("MenuShadowSize", 33);
+  ass = config->readNumEntry("ActiveWindowShadowSize", 133);
+  iss = config->readNumEntry("InactiveWindowShadowSize", 67);
+
+  activeWindowOpacity->setEnabled(activeWindowTransparency->isChecked());
+  inactiveWindowOpacity->setEnabled(inactiveWindowTransparency->isChecked());
+  movingWindowOpacity->setEnabled(movingWindowTransparency->isChecked());
+  dockWindowOpacity->setEnabled(dockWindowTransparency->isChecked());
+
+  KConfig conf_(TQDir::homeDirPath() + "/.xcompmgrrc");
+  conf_.setGroup("xcompmgr");
+
+  disableARGB->setChecked(conf_.readBoolEntry("DisableARGB",FALSE));
+
+  useShadows->setChecked(conf_.readEntry("Compmode","").compare("CompClientShadows") == 0);
+  shadowTopOffset->setValue(-1*(conf_.readNumEntry("ShadowOffsetY",-80)));
+  shadowLeftOffset->setValue(-1*(conf_.readNumEntry("ShadowOffsetX",0)));
+
+  int ss =  conf_.readNumEntry("ShadowRadius",6);
+  dockWindowShadowSize->setValue((int)(dss*ss/100.0));
+  menuWindowShadowSize->setValue((int)(mss*ss/100.0));
+  activeWindowShadowSize->setValue((int)(ass*ss/100.0));
+  inactiveWindowShadowSize->setValue((int)(iss*ss/100.0));
+
+  TQString hex = conf_.readEntry("ShadowColor","#000000");
+  uint r, g, b;
+  r = g = b = 256;
+
+  if (sscanf(hex.latin1(), "0x%02x%02x%02x", &r, &g, &b)!=3 || r > 255 || g > 255 || b > 255)
+    shadowColor->setColor(Qt::black);
+  else
+    shadowColor->setColor(TQColor(r,g,b));
+
+  fadeInWindows->setChecked(conf_.readBoolEntry("FadeWindows",FALSE));
+  fadeInMenuWindows->setChecked(conf_.readBoolEntry("FadeMenuWindows",FALSE));
+  fadeOnOpacityChange->setChecked(conf_.readBoolEntry("FadeTrans",FALSE));
+  fadeInSpeed->setValue((int)(conf_.readDoubleNumEntry("FadeInStep",0.070)*1000.0));
+  fadeOutSpeed->setValue((int)(conf_.readDoubleNumEntry("FadeOutStep",0.070)*1000.0));
+
+  emit KCModule::changed(false);
+}
+
+void KTranslucencyConfig::save( void )
+{
+    if (!kompmgrAvailable_)
+        return;
+  config->setGroup( "Notification Messages" );
+  config->writeEntry("UseTranslucency",useTranslucency->isChecked());
+
+  config->setGroup( "Translucency" );
+  config->writeEntry("TranslucentActiveWindows",activeWindowTransparency->isChecked());
+  config->writeEntry("TranslucentInactiveWindows",inactiveWindowTransparency->isChecked());
+  config->writeEntry("TranslucentMovingWindows",movingWindowTransparency->isChecked());
+  config->writeEntry("TranslucentDocks",dockWindowTransparency->isChecked());
+  config->writeEntry("TreatKeepAboveAsActive",keepAboveAsActive->isChecked());
+  config->writeEntry("ActiveWindowOpacity",activeWindowOpacity->value());
+  config->writeEntry("InactiveWindowOpacity",inactiveWindowOpacity->value());
+  config->writeEntry("MovingWindowOpacity",movingWindowOpacity->value());
+  config->writeEntry("DockOpacity",dockWindowOpacity->value());
+  // for simplification:
+  // xcompmgr supports a general shadow radius and additionally lets external apps set a multiplicator for each window
+  // (speed reasons, so the shadow matrix hasn't to be recreated for every window)
+  // we set inactive windows to 100%, the radius to the inactive window value and adjust the multiplicators for docks and active windows
+  // this way the user can set the three values without caring about the radius/multiplicator stuff
+   // additionally we find a value between big and small values to have a more smooth appereance
+   config->writeEntry("DockShadowSize",(int)(200.0 * dockWindowShadowSize->value() / (activeWindowShadowSize->value() + inactiveWindowShadowSize->value())));
+   config->writeEntry("MenuShadowSize",(int)(200.0 * menuWindowShadowSize->value() / (activeWindowShadowSize->value() + inactiveWindowShadowSize->value())));
+   config->writeEntry("ActiveWindowShadowSize",(int)(200.0 * activeWindowShadowSize->value() / (activeWindowShadowSize->value() + inactiveWindowShadowSize->value())));
+   config->writeEntry("InactiveWindowShadowSize",(int)(200.0 * inactiveWindowShadowSize->value() / (activeWindowShadowSize->value() + inactiveWindowShadowSize->value())));
+
+  config->writeEntry("RemoveShadowsOnMove",removeShadowsOnMove->isChecked());
+  config->writeEntry("RemoveShadowsOnResize",removeShadowsOnResize->isChecked());
+  config->writeEntry("OnlyDecoTranslucent", onlyDecoTranslucent->isChecked());
+  config->writeEntry("ResetKompmgr",resetKompmgr_);
+
+  KConfig *conf_ = new KConfig(TQDir::homeDirPath() + "/.xcompmgrrc");
+  conf_->setGroup("xcompmgr");
+
+  conf_->writeEntry("Compmode",useShadows->isChecked()?"CompClientShadows":"");
+  conf_->writeEntry("DisableARGB",disableARGB->isChecked());
+  conf_->writeEntry("ShadowOffsetY",-1*shadowTopOffset->value());
+  conf_->writeEntry("ShadowOffsetX",-1*shadowLeftOffset->value());
+
+
+  int r, g, b;
+  shadowColor->color().rgb( &r, &g, &b );
+  TQString hex;
+  hex.sprintf("0x%02X%02X%02X", r,g,b);
+  conf_->writeEntry("ShadowColor",hex);
+  conf_->writeEntry("ShadowRadius",(activeWindowShadowSize->value() + inactiveWindowShadowSize->value()) / 2);
+  conf_->writeEntry("FadeWindows",fadeInWindows->isChecked());
+  conf_->writeEntry("FadeMenuWindows",fadeInMenuWindows->isChecked());
+  conf_->writeEntry("FadeTrans",fadeOnOpacityChange->isChecked());
+  conf_->writeEntry("FadeInStep",fadeInSpeed->value()/1000.0);
+  conf_->writeEntry("FadeOutStep",fadeOutSpeed->value()/1000.0);
+
+  delete conf_;
+
+  if (standAlone)
+  {
+    config->sync();
+        if ( !kapp->dcopClient()->isAttached() )
+            kapp->dcopClient()->attach();
+        kapp->dcopClient()->send("twin*", "", "reconfigure()", TQString(""));
+  }
+  if (useTranslucency->isChecked())
+    startKompmgr();
+  emit KCModule::changed(false);
+}
+
+void KTranslucencyConfig::defaults()
+{
+    if (!kompmgrAvailable_)
+        return;
+  useTranslucency->setChecked(false);
+  onlyDecoTranslucent->setChecked(false);
+  activeWindowTransparency->setChecked(false);
+  inactiveWindowTransparency->setChecked(false);
+  movingWindowTransparency->setChecked(false);
+  dockWindowTransparency->setChecked(false);
+  keepAboveAsActive->setChecked(true);
+  disableARGB->setChecked(false);
+
+  activeWindowOpacity->setValue(100);
+  inactiveWindowOpacity->setValue(75);
+  movingWindowOpacity->setValue(25);
+  dockWindowOpacity->setValue(80);
+
+  dockWindowShadowSize->setValue(6);
+  menuWindowShadowSize->setValue(6);
+  activeWindowShadowSize->setValue(12);
+  inactiveWindowShadowSize->setValue(6);
+  shadowTopOffset->setValue(80);
+  shadowLeftOffset->setValue(0);
+
+  activeWindowOpacity->setEnabled(false);
+  inactiveWindowOpacity->setEnabled(false);
+  movingWindowOpacity->setEnabled(false);
+  dockWindowOpacity->setEnabled(false);
+  useShadows->setChecked(FALSE);
+  removeShadowsOnMove->setChecked(FALSE);
+  removeShadowsOnResize->setChecked(FALSE);
+  shadowColor->setColor(Qt::black);
+  fadeInWindows->setChecked(FALSE);
+  fadeInMenuWindows->setChecked(FALSE);
+  fadeOnOpacityChange->setChecked(FALSE);
+  fadeInSpeed->setValue(70);
+  fadeOutSpeed->setValue(70);
+  emit KCModule::changed(true);
+}
+
+
+bool KTranslucencyConfig::kompmgrAvailable()
+{
+    bool ret;
+    KProcess proc;
+    proc << "kompmgr" << "-v";
+    ret = proc.start(KProcess::DontCare, KProcess::AllOutput);
+    proc.detach();
+    return ret;
+}
+
+void KTranslucencyConfig::startKompmgr()
+{
+    bool ret;
+    KProcess proc;
+    proc << "kompmgr";
+    ret = proc.start(KProcess::DontCare);
+}
+
+void KTranslucencyConfig::showWarning(bool alphaActivated)
+{
+//    if (alphaActivated)
+//        KMessageBox::information(this, i18n("<qt>Translucency support is new and may cause problems<br> including crashes (sometimes the translucency engine, seldom even X).</qt>"), i18n("Warning"));
+}
+
+#include "windows.moc"