You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
745 lines
22 KiB
745 lines
22 KiB
/* kastasker.cpp |
|
** |
|
** Copyright (C) 2001-2004 Richard Moore <rich@kde.org> |
|
** Contributor: Mosfet |
|
** All rights reserved. |
|
** |
|
** KasBar is dual-licensed: you can choose the GPL or the BSD license. |
|
** Short forms of both licenses are included below. |
|
*/ |
|
|
|
/* |
|
** 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 in a file called COPYING; if not, write to |
|
** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
|
** MA 02110-1301, USA. |
|
*/ |
|
|
|
/* |
|
** Redistribution and use in source and binary forms, with or without |
|
** modification, are permitted provided that the following conditions |
|
** are met: |
|
** 1. Redistributions of source code must retain the above copyright |
|
** notice, this list of conditions and the following disclaimer. |
|
** 2. Redistributions in binary form must reproduce the above copyright |
|
** notice, this list of conditions and the following disclaimer in the |
|
** documentation and/or other materials provided with the distribution. |
|
** |
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND |
|
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
** ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
|
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|
** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|
** SUCH DAMAGE. |
|
*/ |
|
|
|
/* |
|
** Bug reports and questions can be sent to kde-devel@kde.org |
|
*/ |
|
#include <tqapplication.h> |
|
#include <tqtimer.h> |
|
|
|
#include <tdeactionclasses.h> |
|
#include <tdeconfig.h> |
|
#include <kdebug.h> |
|
#include <tdelocale.h> |
|
#include <tdepopupmenu.h> |
|
#include <kiconloader.h> |
|
|
|
//#include <tdeconfiggroupsaver.h> |
|
|
|
#include <taskmanager.h> |
|
|
|
#include "kasaboutdlg.h" |
|
#include "kastaskitem.h" |
|
#include "kasprefsdlg.h" |
|
#include "kasstartupitem.h" |
|
#include "kasgroupitem.h" |
|
#include "kasgrouper.h" |
|
#include "kasclockitem.h" |
|
#include "kasloaditem.h" |
|
|
|
#include "kastasker.h" |
|
#include "kastasker.moc" |
|
|
|
static const int SWITCH_DESKTOPS_REGROUP_DELAY = 50; |
|
|
|
KasTasker::KasTasker( Orientation o, TQWidget* parent, const char* name, WFlags f ) |
|
: KasBar( o, parent, name, f ), |
|
menu( 0 ), |
|
conf( 0 ), |
|
grouper( 0 ), |
|
standalone_( false ), |
|
enableThumbs_( true ), |
|
embedThumbs_( false ), |
|
thumbnailSize_( 0.2 ), |
|
enableNotifier_( true ), |
|
showModified_( true ), |
|
showProgress_( false ), |
|
showAllWindows_( true ), |
|
thumbUpdateDelay_( 10 ), |
|
groupWindows_( false ), |
|
groupInactiveDesktops_( false ), |
|
showAttention_( true ), |
|
showClock_( false ), |
|
clockItem(0), |
|
showLoad_( false ), |
|
loadItem(0) |
|
{ |
|
setAcceptDrops( true ); |
|
connect(TaskManager::the(), TQT_SIGNAL(taskAdded(Task::Ptr)), TQT_SLOT(addTask(Task::Ptr))); |
|
connect(TaskManager::the(), TQT_SIGNAL(taskRemoved(Task::Ptr)), TQT_SLOT(removeTask(Task::Ptr))); |
|
connect(TaskManager::the(), TQT_SIGNAL(startupAdded(Startup::Ptr)), TQT_SLOT(addStartup(Startup::Ptr))); |
|
connect(TaskManager::the(), TQT_SIGNAL(startupRemoved(Startup::Ptr)), TQT_SLOT(removeStartup(Startup::Ptr))); |
|
connect(TaskManager::the(), TQT_SIGNAL(desktopChanged(int)), TQT_SLOT(refreshAllLater())); |
|
// connect( manager, TQT_SIGNAL( windowChanged( Task::Ptr ) ), TQT_SLOT( refreshAllLater() ) ); |
|
|
|
connect( this, TQT_SIGNAL( itemSizeChanged( int ) ), TQT_SLOT( refreshAll() ) ); |
|
|
|
connect( this, TQT_SIGNAL( detachedPositionChanged(const TQPoint &) ), TQT_SLOT( writeLayout() ) ); |
|
connect( this, TQT_SIGNAL( directionChanged() ), TQT_SLOT( writeLayout() ) ); |
|
} |
|
|
|
KasTasker::KasTasker( Orientation o, KasTasker *master, TQWidget* parent, const char* name, WFlags f ) |
|
: KasBar( o, master, parent, name, f ), |
|
menu( 0 ), |
|
conf( 0 ), |
|
grouper( 0 ), |
|
standalone_( master->standalone_ ), |
|
enableThumbs_( master->enableThumbs_ ), |
|
embedThumbs_( master->embedThumbs_ ), |
|
thumbnailSize_( master->thumbnailSize_ ), |
|
enableNotifier_( master->enableNotifier_ ), |
|
showModified_( master->showModified_ ), |
|
showProgress_( master->showProgress_ ), |
|
showAllWindows_( master->showAllWindows_ ), |
|
thumbUpdateDelay_( master->thumbUpdateDelay_ ), |
|
groupWindows_( false ), |
|
groupInactiveDesktops_( false ), |
|
showAttention_( master->showAttention_ ), |
|
showClock_( false ), |
|
clockItem(0), |
|
showLoad_( false ), |
|
loadItem(0) |
|
{ |
|
setAcceptDrops( true ); |
|
} |
|
|
|
KasTasker::~KasTasker() |
|
{ |
|
delete menu; |
|
delete grouper; |
|
} |
|
|
|
TDEPopupMenu *KasTasker::contextMenu() |
|
{ |
|
if ( !menu ) { |
|
menu = new TDEPopupMenu; |
|
|
|
showAllWindowsAction = new TDEToggleAction( i18n("Show &All Windows"), TDEShortcut(), |
|
TQT_TQOBJECT(this), "toggle_show_all_windows" ); |
|
showAllWindowsAction->setChecked( showAllWindows() ); |
|
showAllWindowsAction->plug( menu ); |
|
connect( showAllWindowsAction, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setShowAllWindows(bool)) ); |
|
connect( TQT_TQOBJECT(this), TQT_SIGNAL(showAllWindowsChanged(bool)), showAllWindowsAction, TQT_SLOT(setChecked(bool)) ); |
|
|
|
groupWindowsAction = new TDEToggleAction( i18n("&Group Windows"), TDEShortcut(), |
|
TQT_TQOBJECT(this), "toggle_group_windows" ); |
|
groupWindowsAction->setChecked( groupWindows() ); |
|
groupWindowsAction->plug( menu ); |
|
connect( groupWindowsAction, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setGroupWindows(bool)) ); |
|
connect( TQT_TQOBJECT(this), TQT_SIGNAL(groupWindowsChanged(bool)), groupWindowsAction, TQT_SLOT(setChecked(bool)) ); |
|
|
|
showClockAction = new TDEToggleAction( i18n("Show &Clock"), TDEShortcut(), TQT_TQOBJECT(this), "toggle_show_clock" ); |
|
showClockAction->setChecked( showClock() ); |
|
showClockAction->plug( menu ); |
|
connect( showClockAction, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setShowClock(bool)) ); |
|
connect( TQT_TQOBJECT(this), TQT_SIGNAL(showClockChanged(bool)), showClockAction, TQT_SLOT(setChecked(bool)) ); |
|
|
|
showLoadAction = new TDEToggleAction( i18n("Show &Load Meter"), TDEShortcut(), TQT_TQOBJECT(this), "toggle_show_load" ); |
|
showLoadAction->setChecked( showLoad() ); |
|
showLoadAction->plug( menu ); |
|
connect( showLoadAction, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setShowLoad(bool)) ); |
|
connect( TQT_TQOBJECT(this), TQT_SIGNAL(showLoadChanged(bool)), showLoadAction, TQT_SLOT(setChecked(bool)) ); |
|
|
|
menu->insertSeparator(); |
|
|
|
if ( !standalone_ ) { |
|
toggleDetachedAction = new TDEToggleAction( i18n("&Floating"), TDEShortcut(), TQT_TQOBJECT(this), "toggle_detached" ); |
|
toggleDetachedAction->setChecked( isDetached() ); |
|
toggleDetachedAction->plug( menu ); |
|
connect( toggleDetachedAction, TQT_SIGNAL(toggled(bool)), TQT_SLOT(setDetached(bool)) ); |
|
connect( TQT_TQOBJECT(this), TQT_SIGNAL(detachedChanged(bool)), toggleDetachedAction, TQT_SLOT(setChecked(bool)) ); |
|
} |
|
|
|
rotateBarAction = new TDEAction( i18n("R&otate Bar"), TQString("rotate"), TDEShortcut(), |
|
TQT_TQOBJECT(this), TQT_SLOT( toggleOrientation() ), |
|
TQT_TQOBJECT(this), "rotate_bar" ); |
|
rotateBarAction->plug( menu ); |
|
connect( TQT_TQOBJECT(this), TQT_SIGNAL(detachedChanged(bool)), rotateBarAction, TQT_SLOT(setEnabled(bool)) ); |
|
connect( rotateBarAction, TQT_SIGNAL(activated()), TQT_SLOT(writeConfigLater()) ); |
|
|
|
menu->insertItem( SmallIcon("reload"), i18n("&Refresh"), TQT_TQOBJECT(this), TQT_SLOT( refreshAll() ) ); |
|
|
|
menu->insertSeparator(); |
|
|
|
menu->insertItem( SmallIcon("configure"), i18n("&Configure Kasbar..."), TQT_TQOBJECT(this), TQT_SLOT( showPreferences() ) ); |
|
|
|
// Help menu |
|
TDEPopupMenu *help = new TDEPopupMenu; |
|
help->insertItem( SmallIcon("about"), i18n("&About Kasbar"), TQT_TQOBJECT(this), TQT_SLOT( showAbout() ) ); |
|
menu->insertItem( SmallIcon("help"), i18n("&Help"), help ); |
|
|
|
if ( standalone_ ) { |
|
menu->insertSeparator(); |
|
menu->insertItem( SmallIcon("system-log-out"), i18n("&Quit"), tqApp, TQT_SLOT( quit() ) ); |
|
} |
|
} |
|
|
|
return menu; |
|
} |
|
|
|
KasTasker *KasTasker::createChildBar( Orientation o, TQWidget *parent, const char *name ) |
|
{ |
|
KasTasker *child = new KasTasker( o, this, parent, name ); |
|
child->conf = this->conf; |
|
return child; |
|
} |
|
|
|
KasTaskItem *KasTasker::findItem( Task::Ptr t ) |
|
{ |
|
KasTaskItem *result = 0; |
|
for ( uint i = 0; i < itemCount(); i++ ) { |
|
if ( itemAt(i)->inherits( "KasTaskItem" ) ) { |
|
KasTaskItem *curr = static_cast<KasTaskItem *> (itemAt( i )); |
|
if ( curr->task() == t ) { |
|
result = curr; |
|
break; |
|
} |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
KasStartupItem *KasTasker::findItem( Startup::Ptr s ) |
|
{ |
|
KasStartupItem *result = 0; |
|
for ( uint i = 0; i < itemCount(); i++ ) { |
|
if ( itemAt(i)->inherits( "KasStartupItem" ) ) { |
|
KasStartupItem *curr = static_cast<KasStartupItem *> (itemAt( i )); |
|
if ( curr->startup() == s ) { |
|
result = curr; |
|
break; |
|
} |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
void KasTasker::addTask( Task::Ptr t ) |
|
{ |
|
KasItem *item = 0; |
|
|
|
if ( onlyShowMinimized_ && !t->isMinimized() ) |
|
return; |
|
|
|
if ( showAllWindows_ || t->isOnCurrentDesktop() ) { |
|
if ( grouper ) |
|
item = grouper->maybeGroup( t ); |
|
if ( !item ) { |
|
item = new KasTaskItem( this, t ); |
|
append( item ); |
|
} |
|
|
|
// |
|
// Ensure the window manager knows where we put the icon. |
|
// |
|
TQPoint p = mapToGlobal( itemPos( item ) ); |
|
TQSize s( itemExtent(), itemExtent() ); |
|
t->publishIconGeometry( TQRect( p, s ) ); |
|
} |
|
} |
|
|
|
void KasTasker::removeTask( Task::Ptr t ) |
|
{ |
|
KasTaskItem *i = findItem( t ); |
|
if ( !i ) |
|
return; |
|
|
|
remove( i ); |
|
refreshIconGeometry(); |
|
} |
|
|
|
KasGroupItem *KasTasker::convertToGroup( Task::Ptr t ) |
|
{ |
|
KasTaskItem *ti = findItem( t ); |
|
int i = indexOf( ti ); |
|
KasGroupItem *gi = new KasGroupItem( this ); |
|
gi->addTask( t ); |
|
removeTask( t ); |
|
insert( i, gi ); |
|
|
|
connect(TaskManager::the(), TQT_SIGNAL(taskRemoved(Task::Ptr)), gi, TQT_SLOT(removeTask(Task::Ptr))); |
|
|
|
return gi; |
|
} |
|
|
|
void KasTasker::moveToMain( KasGroupItem *gi, Task::Ptr t ) |
|
{ |
|
int i = indexOf( gi ); |
|
if ( i != -1 ) { |
|
remove( gi ); |
|
insert( i, new KasTaskItem( this, t ) ); |
|
} |
|
else |
|
append( new KasTaskItem( this, t ) ); |
|
|
|
refreshIconGeometry(); |
|
} |
|
|
|
void KasTasker::moveToMain( KasGroupItem *gi ) |
|
{ |
|
bool updates = isUpdatesEnabled(); |
|
setUpdatesEnabled( false ); |
|
|
|
int i = indexOf( gi ); |
|
|
|
for ( int ti = 0 ; ti < gi->taskCount() ; ti++ ) { |
|
Task::Ptr t = gi->task( ti ); |
|
insert( i, new KasTaskItem( this, t ) ); |
|
} |
|
|
|
gi->hidePopup(); |
|
remove( gi ); |
|
|
|
setUpdatesEnabled( updates ); |
|
updateLayout(); |
|
} |
|
|
|
void KasTasker::addStartup( Startup::Ptr s ) |
|
{ |
|
if ( enableNotifier_ ) |
|
append( new KasStartupItem( this, s ) ); |
|
} |
|
|
|
void KasTasker::removeStartup( Startup::Ptr s ) |
|
{ |
|
KasStartupItem *i = findItem( s ); |
|
remove( i ); |
|
} |
|
|
|
void KasTasker::refreshAll() |
|
{ |
|
bool updates = isUpdatesEnabled(); |
|
setUpdatesEnabled( false ); |
|
|
|
clear(); |
|
|
|
if ( showClock_ ) { |
|
showClock_ = false; |
|
setShowClock( true ); |
|
} |
|
|
|
if ( showLoad_ ) { |
|
showLoad_ = false; |
|
setShowLoad( true ); |
|
} |
|
|
|
Task::Dict l = TaskManager::the()->tasks(); |
|
for ( Task::Dict::iterator t = l.begin(); t != l.end(); ++t ) { |
|
addTask( t.data() ); |
|
} |
|
|
|
setUpdatesEnabled( updates ); |
|
updateLayout(); |
|
} |
|
|
|
void KasTasker::refreshAllLater() |
|
{ |
|
TQTimer::singleShot( SWITCH_DESKTOPS_REGROUP_DELAY, this, TQT_SLOT( refreshAll() ) ); |
|
} |
|
|
|
void KasTasker::refreshIconGeometry() |
|
{ |
|
for ( uint i = 0; i < itemCount(); i++ ) { |
|
if ( itemAt(i)->inherits( "KasTaskItem" ) ) { |
|
KasTaskItem *curr = static_cast<KasTaskItem *> (itemAt( i )); |
|
|
|
TQPoint p = mapToGlobal( itemPos( curr ) ); |
|
TQSize s( itemExtent(), itemExtent() ); |
|
curr->task()->publishIconGeometry( TQRect( p, s ) ); |
|
} |
|
} |
|
} |
|
|
|
void KasTasker::setNotifierEnabled( bool enable ) |
|
{ |
|
enableNotifier_ = enable; |
|
} |
|
|
|
void KasTasker::setThumbnailSize( double size ) |
|
{ |
|
thumbnailSize_ = size; |
|
} |
|
|
|
void KasTasker::setThumbnailSize( int percent ) |
|
{ |
|
double amt = (double) percent / 100.0; |
|
setThumbnailSize( amt ); |
|
} |
|
|
|
void KasTasker::setThumbnailsEnabled( bool enable ) |
|
{ |
|
enableThumbs_ = enable; |
|
} |
|
|
|
void KasTasker::setShowModified( bool enable ) |
|
{ |
|
showModified_ = enable; |
|
update(); |
|
} |
|
|
|
void KasTasker::setShowProgress( bool enable ) |
|
{ |
|
showProgress_ = enable; |
|
update(); |
|
} |
|
|
|
void KasTasker::setShowAttention( bool enable ) |
|
{ |
|
showAttention_ = enable; |
|
update(); |
|
} |
|
|
|
void KasTasker::setShowAllWindows( bool enable ) |
|
{ |
|
if ( showAllWindows_ != enable ) { |
|
showAllWindows_ = enable; |
|
refreshAll(); |
|
if ( !showAllWindows_ ) { |
|
connect(TaskManager::the(), TQT_SIGNAL(desktopChanged(int)), TQT_SLOT(refreshAll())); |
|
// connect( manager, TQT_SIGNAL( windowChanged( Task::Ptr ) ), TQT_SLOT( refreshAll() ) ); |
|
} |
|
else { |
|
disconnect(TaskManager::the(), TQT_SIGNAL(desktopChanged(int)), this, TQT_SLOT(refreshAll())); |
|
// disconnect( manager, TQT_SIGNAL( windowChanged( Task::Ptr ) ), this, TQT_SLOT( refreshAll() ) ); |
|
} |
|
|
|
emit showAllWindowsChanged( enable ); |
|
} |
|
} |
|
|
|
void KasTasker::setThumbnailUpdateDelay( int secs ) |
|
{ |
|
thumbUpdateDelay_ = secs; |
|
} |
|
|
|
void KasTasker::setEmbedThumbnails( bool enable ) |
|
{ |
|
if ( embedThumbs_ == enable ) |
|
return; |
|
|
|
embedThumbs_ = enable; |
|
update(); |
|
} |
|
|
|
void KasTasker::setShowClock( bool enable ) |
|
{ |
|
if ( showClock_ == enable ) |
|
return; |
|
|
|
showClock_ = enable; |
|
|
|
if ( enable ) { |
|
clockItem = new KasClockItem( this ); |
|
insert( 0, clockItem ); |
|
} |
|
else if ( clockItem ) { |
|
remove( clockItem ); |
|
clockItem = 0; |
|
} |
|
|
|
|
|
emit showClockChanged( showClock_ ); |
|
writeConfigLater(); |
|
} |
|
|
|
void KasTasker::setShowLoad( bool enable ) |
|
{ |
|
if ( showLoad_ == enable ) |
|
return; |
|
|
|
showLoad_ = enable; |
|
|
|
if ( enable ) { |
|
loadItem = new KasLoadItem( this ); |
|
insert( showClock_ ? 1 : 0, loadItem ); |
|
} |
|
else if ( loadItem ) { |
|
remove( loadItem ); |
|
loadItem = 0; |
|
} |
|
|
|
emit showLoadChanged( showLoad_ ); |
|
writeConfigLater(); |
|
} |
|
|
|
void KasTasker::setGroupWindows( bool enable ) |
|
{ |
|
if ( groupWindows_ != enable ) { |
|
groupWindows_ = enable; |
|
if ( enable && (!grouper) ) |
|
grouper = new KasGrouper( this ); |
|
refreshAll(); |
|
|
|
emit groupWindowsChanged( enable ); |
|
} |
|
} |
|
|
|
void KasTasker::setGroupInactiveDesktops( bool enable ) |
|
{ |
|
if ( groupInactiveDesktops_ != enable ) { |
|
groupInactiveDesktops_ = enable; |
|
if ( enable && (!grouper) ) |
|
grouper = new KasGrouper( this ); |
|
|
|
refreshAll(); |
|
} |
|
} |
|
|
|
void KasTasker::setOnlyShowMinimized( bool enable ) |
|
{ |
|
if ( onlyShowMinimized_ != enable ) { |
|
onlyShowMinimized_ = enable; |
|
refreshAll(); |
|
} |
|
} |
|
|
|
void KasTasker::setStandAlone( bool enable ) |
|
{ |
|
standalone_ = enable; |
|
} |
|
|
|
// |
|
// Configuration Loader |
|
// |
|
|
|
void KasTasker::setConfig( TDEConfig *conf ) |
|
{ |
|
this->conf = conf; |
|
} |
|
|
|
void KasTasker::readConfig() |
|
{ |
|
readConfig(conf); |
|
} |
|
|
|
void KasTasker::writeConfigLater() |
|
{ |
|
TQTimer::singleShot( 10, this, TQT_SLOT( writeConfig() ) ); |
|
} |
|
|
|
void KasTasker::writeConfig() |
|
{ |
|
writeConfig(conf); |
|
} |
|
|
|
void KasTasker::readConfig( TDEConfig *conf ) |
|
{ |
|
if ( !conf ) { |
|
kdWarning() << "KasTasker::readConfig() got a null TDEConfig" << endl; |
|
return; |
|
} |
|
|
|
if ( master() ) { |
|
kdWarning() << "KasTasker::readConfig() for child bar" << endl; |
|
return; |
|
} |
|
|
|
bool updates = isUpdatesEnabled(); |
|
setUpdatesEnabled( false ); |
|
|
|
|
|
// |
|
// Appearance Settings. |
|
// |
|
TDEConfigGroupSaver saver( conf, "Appearance" ); |
|
|
|
int ext = conf->readNumEntry( "ItemExtent", -1 ); |
|
if ( ext > 0 ) |
|
setItemExtent( ext ); |
|
else |
|
setItemSize( conf->readNumEntry( "ItemSize", KasBar::Medium ) ); |
|
|
|
setTint( conf->readBoolEntry( "EnableTint", false ) ); |
|
setTintColor( conf->readColorEntry( "TintColor", &TQt::black ) ); |
|
setTintAmount( conf->readDoubleNumEntry( "TintAmount", 0.1 ) ); |
|
setTransparent( conf->readBoolEntry( "Transparent", true ) ); |
|
setPaintInactiveFrames( conf->readBoolEntry( "PaintInactiveFrames", true ) ); |
|
|
|
// |
|
// Painting colors |
|
// |
|
conf->setGroup("Colors"); |
|
|
|
KasResources *res = resources(); |
|
res->setLabelPenColor( conf->readColorEntry( "LabelPenColor", &TQt::white ) ); |
|
res->setLabelBgColor( conf->readColorEntry( "LabelBgColor", &TQt::black ) ); |
|
res->setInactivePenColor( conf->readColorEntry( "InactivePenColor", &TQt::black ) ); |
|
res->setInactiveBgColor( conf->readColorEntry( "InactiveBgColor", &TQt::white ) ); |
|
res->setActivePenColor( conf->readColorEntry( "ActivePenColor", &TQt::black ) ); |
|
res->setActiveBgColor( conf->readColorEntry( "ActiveBgColor", &TQt::white ) ); |
|
res->setProgressColor( conf->readColorEntry( "ProgressColor", &TQt::green ) ); |
|
res->setAttentionColor( conf->readColorEntry( "AttentionColor", &TQt::red ) ); |
|
|
|
// |
|
// Thumbnail Settings |
|
// |
|
conf->setGroup("Thumbnails"); |
|
setThumbnailsEnabled( conf->readBoolEntry( "Thumbnails", true ) ); |
|
setThumbnailSize( conf->readDoubleNumEntry( "ThumbnailSize", 0.2 ) ); |
|
setThumbnailUpdateDelay( conf->readNumEntry( "ThumbnailUpdateDelay", 10 ) ); |
|
setEmbedThumbnails( conf->readBoolEntry( "EmbedThumbnails", false ) ); |
|
|
|
// |
|
// Behaviour Settings |
|
// |
|
conf->setGroup("Behaviour"); |
|
setNotifierEnabled( conf->readBoolEntry( "StartupNotifier", true ) ); |
|
setShowModified( conf->readBoolEntry( "ModifiedIndicator", true ) ); |
|
setShowProgress( conf->readBoolEntry( "ProgressIndicator", false ) ); |
|
setShowAttention( conf->readBoolEntry( "AttentionIndicator", true ) ); |
|
setShowAllWindows( conf->readBoolEntry( "ShowAllWindows", true ) ); |
|
setGroupWindows( conf->readBoolEntry( "GroupWindows", true ) ); |
|
setGroupInactiveDesktops( conf->readBoolEntry( "GroupInactiveDesktops", false ) ); |
|
setOnlyShowMinimized( conf->readBoolEntry( "OnlyShowMinimized", false ) ); |
|
|
|
// |
|
// Layout Settings |
|
// |
|
conf->setGroup("Layout"); |
|
|
|
setDirection( (Direction) conf->readNumEntry( "Direction", TQBoxLayout::LeftToRight ) ); |
|
setOrientation( (Qt::Orientation) conf->readNumEntry( "Orientation", Qt::Horizontal ) ); |
|
setMaxBoxes( conf->readUnsignedNumEntry( "MaxBoxes", 0 ) ); |
|
|
|
TQPoint pos(100, 100); |
|
setDetachedPosition( conf->readPointEntry( "DetachedPosition", &pos ) ); |
|
setDetached( conf->readBoolEntry( "Detached", false ) ); |
|
|
|
// |
|
// Custom Items |
|
// |
|
conf->setGroup("Custom Items"); |
|
setShowClock( conf->readBoolEntry( "ShowClock", true ) ); |
|
setShowLoad( conf->readBoolEntry( "ShowLoad", true ) ); |
|
|
|
// fillBg = conf->readBoolEntry( "FillIconBackgrounds", /*true*/ false ); |
|
// fillActiveBg = conf->readBoolEntry( "FillActiveIconBackground", true ); |
|
// enablePopup = conf->readBoolEntry( "EnablePopup", true ); |
|
|
|
setUpdatesEnabled( updates ); |
|
emit configChanged(); |
|
} |
|
|
|
void KasTasker::writeConfig( TDEConfig *conf ) |
|
{ |
|
if ( !conf ) { |
|
kdWarning() << "KasTasker::writeConfig() got a null TDEConfig" << endl; |
|
return; |
|
} |
|
|
|
if ( master() ) { |
|
kdWarning() << "KasTasker::writeConfig() for child bar" << endl; |
|
return; |
|
} |
|
|
|
conf->setGroup("Appearance"); |
|
conf->writeEntry( "ItemSize", itemSize() ); |
|
conf->writeEntry( "ItemExtent", itemExtent() ); |
|
conf->writeEntry( "Transparent", isTransparent() ); |
|
conf->writeEntry( "EnableTint", hasTint() ); |
|
conf->writeEntry( "TintColor", tintColor() ); |
|
conf->writeEntry( "TintAmount", tintAmount() ); |
|
conf->writeEntry( "PaintInactiveFrames", paintInactiveFrames() ); |
|
|
|
conf->setGroup("Colors"); |
|
conf->writeEntry( "LabelPenColor", resources()->labelPenColor() ); |
|
conf->writeEntry( "LabelBgColor", resources()->labelBgColor() ); |
|
conf->writeEntry( "InactivePenColor", resources()->inactivePenColor() ); |
|
conf->writeEntry( "InactiveBgColor", resources()->inactiveBgColor() ); |
|
conf->writeEntry( "ActivePenColor", resources()->activePenColor() ); |
|
conf->writeEntry( "ActiveBgColor", resources()->activeBgColor() ); |
|
conf->writeEntry( "ProgressColor", resources()->progressColor() ); |
|
conf->writeEntry( "AttentionColor", resources()->attentionColor() ); |
|
|
|
conf->setGroup("Thumbnails"); |
|
conf->writeEntry( "Thumbnails", thumbnailsEnabled() ); |
|
conf->writeEntry( "ThumbnailSize", thumbnailSize() ); |
|
conf->writeEntry( "ThumbnailUpdateDelay", thumbnailUpdateDelay() ); |
|
conf->writeEntry( "EmbedThumbnails", embedThumbnails() ); |
|
|
|
conf->setGroup("Behaviour"); |
|
conf->writeEntry( "StartupNotifier", notifierEnabled() ); |
|
conf->writeEntry( "ModifiedIndicator", showModified() ); |
|
conf->writeEntry( "ProgressIndicator", showProgress() ); |
|
conf->writeEntry( "AttentionIndicator", showAttention() ); |
|
conf->writeEntry( "ShowAllWindows", showAllWindows() ); |
|
conf->writeEntry( "GroupWindows", groupWindows() ); |
|
conf->writeEntry( "GroupInactiveDesktops", groupInactiveDesktops() ); |
|
conf->writeEntry( "OnlyShowMinimized", onlyShowMinimized() ); |
|
|
|
conf->setGroup("Layout"); |
|
conf->writeEntry( "Orientation", orientation() ); |
|
conf->writeEntry( "Direction", direction() ); |
|
conf->writeEntry( "Detached", isDetached() ); |
|
|
|
conf->setGroup("Custom Items"); |
|
conf->writeEntry( "ShowClock", showClock() ); |
|
conf->writeEntry( "ShowLoad", showLoad() ); |
|
} |
|
|
|
void KasTasker::writeLayout() |
|
{ |
|
if ( !conf ) |
|
return; |
|
|
|
conf->setGroup("Layout"); |
|
conf->writeEntry( "Orientation", orientation() ); |
|
conf->writeEntry( "Direction", direction() ); |
|
conf->writeEntry( "Detached", isDetached() ); |
|
conf->writeEntry( "DetachedPosition", detachedPosition() ); |
|
conf->sync(); |
|
} |
|
|
|
void KasTasker::showPreferences() |
|
{ |
|
KasPrefsDialog *dlg = new KasPrefsDialog( this ); |
|
dlg->exec(); |
|
delete dlg; |
|
|
|
readConfig(); |
|
} |
|
|
|
void KasTasker::showAbout() |
|
{ |
|
KasAboutDialog *dlg = new KasAboutDialog( 0 ); |
|
dlg->exec(); |
|
delete dlg; |
|
} |
|
|
|
|