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.
1532 lines
37 KiB
1532 lines
37 KiB
/*****************************************************************
|
|
|
|
Copyright (c) 2000 Matthias Elter <elter@kde.org>
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
******************************************************************/
|
|
|
|
#include <tqapplication.h>
|
|
#include <tqcursor.h>
|
|
#include <tqimage.h>
|
|
#include <tqtimer.h>
|
|
|
|
#include <tdeapplication.h>
|
|
#include <tdeconfig.h>
|
|
#include <kdebug.h>
|
|
#include <tdeglobal.h>
|
|
#include <kiconloader.h>
|
|
#include <tdelocale.h>
|
|
// #include <kpixmapio.h>
|
|
#include <kstaticdeleter.h>
|
|
#include <twinmodule.h>
|
|
#include <kxerrorhandler.h>
|
|
#include <netwm.h>
|
|
#include "dcopclient.h"
|
|
|
|
#include "taskmanager.h"
|
|
#include "taskmanager.moc"
|
|
|
|
TaskManager* TaskManager::m_self = 0;
|
|
static KStaticDeleter<TaskManager> staticTaskManagerDeleter;
|
|
uint TaskManager::m_xCompositeEnabled = 0;
|
|
|
|
TaskManager* TaskManager::the()
|
|
{
|
|
if (!m_self)
|
|
{
|
|
staticTaskManagerDeleter.setObject(m_self, new TaskManager());
|
|
}
|
|
return m_self;
|
|
}
|
|
|
|
TaskManager::TaskManager()
|
|
: TQObject(),
|
|
_active(0),
|
|
_startup_info(0),
|
|
m_winModule(new KWinModule()),
|
|
m_trackGeometry(false)
|
|
{
|
|
TDEGlobal::locale()->insertCatalogue("libtaskmanager");
|
|
connect(m_winModule, TQ_SIGNAL(windowAdded(WId)),
|
|
this, TQ_SLOT(windowAdded(WId)));
|
|
connect(m_winModule, TQ_SIGNAL(windowRemoved(WId)),
|
|
this, TQ_SLOT(windowRemoved(WId)));
|
|
connect(m_winModule, TQ_SIGNAL(activeWindowChanged(WId)),
|
|
this, TQ_SLOT(activeWindowChanged(WId)));
|
|
connect(m_winModule, TQ_SIGNAL(currentDesktopChanged(int)),
|
|
this, TQ_SLOT(currentDesktopChanged(int)));
|
|
connect(m_winModule, TQ_SIGNAL(windowChanged(WId,unsigned int)),
|
|
this, TQ_SLOT(windowChanged(WId,unsigned int)));
|
|
|
|
// register existing windows
|
|
const TQValueList<WId> windows = m_winModule->windows();
|
|
TQValueList<WId>::ConstIterator end(windows.end());
|
|
for (TQValueList<WId>::ConstIterator it = windows.begin(); it != end; ++it)
|
|
{
|
|
windowAdded(*it);
|
|
}
|
|
|
|
// set active window
|
|
WId win = m_winModule->activeWindow();
|
|
activeWindowChanged(win);
|
|
configure_startup();
|
|
}
|
|
|
|
TaskManager::~TaskManager()
|
|
{
|
|
TDEGlobal::locale()->removeCatalogue("libtaskmanager");
|
|
}
|
|
|
|
void TaskManager::configure_startup()
|
|
{
|
|
TDEConfig c("tdelaunchrc", true);
|
|
c.setGroup("FeedbackStyle");
|
|
if (!c.readBoolEntry("TaskbarButton", false))
|
|
return;
|
|
_startup_info = new TDEStartupInfo( TDEStartupInfo::CleanOnCantDetect, this );
|
|
connect( _startup_info,
|
|
TQ_SIGNAL( gotNewStartup( const TDEStartupInfoId&, const TDEStartupInfoData& )),
|
|
TQ_SLOT( gotNewStartup( const TDEStartupInfoId&, const TDEStartupInfoData& )));
|
|
connect( _startup_info,
|
|
TQ_SIGNAL( gotStartupChange( const TDEStartupInfoId&, const TDEStartupInfoData& )),
|
|
TQ_SLOT( gotStartupChange( const TDEStartupInfoId&, const TDEStartupInfoData& )));
|
|
connect( _startup_info,
|
|
TQ_SIGNAL( gotRemoveStartup( const TDEStartupInfoId&, const TDEStartupInfoData& )),
|
|
TQ_SLOT( killStartup( const TDEStartupInfoId& )));
|
|
c.setGroup( "TaskbarButtonSettings" );
|
|
_startup_info->setTimeout( c.readUnsignedNumEntry( "Timeout", 30 ));
|
|
}
|
|
|
|
#ifdef THUMBNAILING_POSSIBLE
|
|
void TaskManager::setXCompositeEnabled(bool state)
|
|
{
|
|
Display *dpy = TQPaintDevice::x11AppDisplay();
|
|
|
|
if (!state)
|
|
{
|
|
if (!--m_xCompositeEnabled)
|
|
{
|
|
// unredirecting windows
|
|
for (int i = 0; i < ScreenCount(dpy); i++)
|
|
{
|
|
XCompositeUnredirectSubwindows(dpy, RootWindow(dpy, i),
|
|
CompositeRedirectAutomatic);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (m_xCompositeEnabled)
|
|
{
|
|
// we don't unlearn riding bike ;)
|
|
m_xCompositeEnabled++;
|
|
return;
|
|
}
|
|
|
|
// XComposite extension check
|
|
int event_base, error_base;
|
|
if (!XCompositeQueryExtension(dpy, &event_base, &error_base))
|
|
{
|
|
return;
|
|
}
|
|
|
|
int major = 0, minor = 99; // The highest version we support
|
|
XCompositeQueryVersion(dpy, &major, &minor);
|
|
|
|
// We use XCompositeNameWindowPixmap(), i.e. we need at least
|
|
// version 0.2.
|
|
if (major == 0 && minor < 2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// XRender extension check
|
|
if (!XRenderQueryExtension(dpy, &event_base, &error_base))
|
|
{
|
|
return;
|
|
}
|
|
|
|
major = 0, minor = 99; // The highest version we support
|
|
XRenderQueryVersion(dpy, &major, &minor);
|
|
|
|
// We use SetPictureTransform() and SetPictureFilter(), i.e. we
|
|
// need at least version 0.6.
|
|
if (major == 0 && minor < 6)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// XFixes extension check
|
|
if (!XFixesQueryExtension(dpy, &event_base, &error_base))
|
|
{
|
|
return;
|
|
}
|
|
|
|
major = 3, minor = 99; // The highest version we support
|
|
XFixesQueryVersion(dpy, &major, &minor);
|
|
|
|
// We use Region objects, i.e. we need at least version 2.0.
|
|
if (major < 2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// if we get here, we've got usable extensions
|
|
m_xCompositeEnabled++;
|
|
|
|
// redirecting windows to backing pixmaps
|
|
for (int i = 0; i < ScreenCount(dpy); i++)
|
|
{
|
|
XCompositeRedirectSubwindows(dpy, RootWindow(dpy, i),
|
|
CompositeRedirectAutomatic);
|
|
}
|
|
|
|
Task::Dict::iterator itEnd = m_tasksByWId.end();
|
|
for (Task::Dict::iterator it = m_tasksByWId.begin(); it != itEnd; ++it)
|
|
{
|
|
it.data()->updateWindowPixmap();
|
|
}
|
|
}
|
|
#else // THUMBNAILING_POSSIBLE
|
|
void TaskManager::setXCompositeEnabled(bool)
|
|
{
|
|
}
|
|
#endif // !THUMBNAILING_POSSIBLE
|
|
|
|
Task::Ptr TaskManager::findTask(WId w)
|
|
{
|
|
// TODO: might be able to be made more efficient if
|
|
// we check to see if w is a transient first?
|
|
// profiling would say whether this is worth the effort
|
|
|
|
Task::Dict::iterator it = m_tasksByWId.begin();
|
|
Task::Dict::iterator itEnd = m_tasksByWId.end();
|
|
|
|
for (; it != itEnd; ++it)
|
|
{
|
|
if (it.key() == w || it.data()->hasTransient(w))
|
|
{
|
|
return it.data();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
Task::Ptr TaskManager::findTask(int desktop, const TQPoint& p)
|
|
{
|
|
TQValueList<WId> list = winModule()->stackingOrder();
|
|
|
|
Task::Ptr task = 0;
|
|
int currentIndex = -1;
|
|
Task::Dict::iterator itEnd = m_tasksByWId.end();
|
|
for (Task::Dict::iterator it = m_tasksByWId.begin(); it != itEnd; ++it)
|
|
{
|
|
Task::Ptr t = it.data();
|
|
if (!t->isOnAllDesktops() && t->desktop() != desktop)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (t->isIconified() || t->isShaded())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (t->geometry().contains(p))
|
|
{
|
|
int index = list.findIndex(t->window());
|
|
if (index > currentIndex)
|
|
{
|
|
currentIndex = index;
|
|
task = t;
|
|
}
|
|
}
|
|
}
|
|
|
|
return task;
|
|
}
|
|
|
|
void TaskManager::windowAdded(WId w )
|
|
{
|
|
NETWinInfo info(tqt_xdisplay(), w, tqt_xrootwin(),
|
|
NET::WMWindowType | NET::WMPid | NET::WMState);
|
|
|
|
// ignore NET::Tool and other special window types
|
|
NET::WindowType wType =
|
|
info.windowType( NET::NormalMask | NET::DesktopMask | NET::DockMask |
|
|
NET::ToolbarMask | NET::MenuMask | NET::DialogMask |
|
|
NET::OverrideMask | NET::TopMenuMask |
|
|
NET::UtilityMask | NET::SplashMask );
|
|
|
|
if (wType != NET::Normal &&
|
|
wType != NET::Override &&
|
|
wType != NET::Unknown &&
|
|
wType != NET::Dialog &&
|
|
wType != NET::Utility)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// ignore windows that want to be ignored by the taskbar
|
|
if ((info.state() & NET::SkipTaskbar) != 0)
|
|
{
|
|
_skiptaskbar_windows.push_front( w ); // remember them though
|
|
return;
|
|
}
|
|
|
|
Window transient_for_tmp;
|
|
if (XGetTransientForHint( tqt_xdisplay(), (Window) w, &transient_for_tmp ))
|
|
{
|
|
WId transient_for = (WId) transient_for_tmp;
|
|
|
|
// check if it's transient for a skiptaskbar window
|
|
if( _skiptaskbar_windows.contains( transient_for ))
|
|
return;
|
|
|
|
// lets see if this is a transient for an existing task
|
|
if( transient_for != tqt_xrootwin()
|
|
&& transient_for != 0
|
|
&& wType != NET::Utility )
|
|
{
|
|
Task::Ptr t = findTask(transient_for);
|
|
if (t)
|
|
{
|
|
if (t->window() != w)
|
|
{
|
|
t->addTransient(w, info);
|
|
// kdDebug() << "TM: Transient " << w << " added for Task: " << t->window() << endl;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Task::Ptr t = new Task(w, this);
|
|
m_tasksByWId[w] = t;
|
|
|
|
// kdDebug() << "TM: Task added for WId: " << w << endl;
|
|
|
|
emit taskAdded(t);
|
|
}
|
|
|
|
void TaskManager::windowRemoved(WId w)
|
|
{
|
|
_skiptaskbar_windows.remove(w);
|
|
|
|
// find task
|
|
Task::Ptr t = findTask(w);
|
|
if (!t)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (t->window() == w)
|
|
{
|
|
m_tasksByWId.remove(w);
|
|
emit taskRemoved(t);
|
|
|
|
if (t == _active)
|
|
{
|
|
_active = 0;
|
|
}
|
|
|
|
//kdDebug() << "TM: Task for WId " << w << " removed." << endl;
|
|
}
|
|
else
|
|
{
|
|
t->removeTransient(w);
|
|
//kdDebug() << "TM: Transient " << w << " for Task " << t->window() << " removed." << endl;
|
|
}
|
|
}
|
|
|
|
void TaskManager::windowChanged(WId w, unsigned int dirty)
|
|
{
|
|
if (dirty & NET::WMState)
|
|
{
|
|
NETWinInfo info (tqt_xdisplay(), w, tqt_xrootwin(),
|
|
NET::WMState | NET::XAWMState);
|
|
if (info.state() & NET::SkipTaskbar)
|
|
{
|
|
windowRemoved(w);
|
|
_skiptaskbar_windows.push_front(w);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
_skiptaskbar_windows.remove(w);
|
|
if (info.mappingState() != NET::Withdrawn && !findTask(w))
|
|
{
|
|
// skipTaskBar state was removed and the window is still
|
|
// mapped, so add this window
|
|
windowAdded( w );
|
|
}
|
|
}
|
|
}
|
|
|
|
// check if any state we are interested in is marked dirty
|
|
if (!(dirty & (NET::WMVisibleName | NET::WMName | NET::WMIcon |
|
|
NET::WMState | NET::XAWMState | NET::WMDesktop) ||
|
|
(m_trackGeometry && dirty & NET::WMGeometry)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// find task
|
|
Task::Ptr t = findTask(w);
|
|
if (!t)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//kdDebug() << "TaskManager::windowChanged " << w << " " << dirty << endl;
|
|
|
|
if (dirty & NET::WMState)
|
|
{
|
|
t->updateDemandsAttentionState(w);
|
|
}
|
|
|
|
// refresh icon pixmap if necessary
|
|
if (dirty & NET::WMIcon)
|
|
{
|
|
t->refreshIcon();
|
|
|
|
// we're done with the icon processing, don't pass this on anymore
|
|
dirty ^= NET::WMIcon;
|
|
}
|
|
|
|
if (dirty)
|
|
{
|
|
// only refresh this stuff if we have other changes besides icons
|
|
t->refresh(dirty);
|
|
}
|
|
|
|
if (dirty & (NET::WMDesktop | NET::WMState | NET::XAWMState))
|
|
{
|
|
// moved to different desktop or is on all or change in iconification/withdrawnnes
|
|
emit windowChanged(t);
|
|
|
|
if (m_xCompositeEnabled && dirty & NET::WMState)
|
|
{
|
|
// update on restoring a minimized window
|
|
updateWindowPixmap(w);
|
|
}
|
|
|
|
}
|
|
else if (dirty & NET::WMGeometry)
|
|
{
|
|
emit windowChangedGeometry(t);
|
|
|
|
if (m_xCompositeEnabled)
|
|
{
|
|
// update on size changes, not on task drags
|
|
updateWindowPixmap(w);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void TaskManager::updateWindowPixmap(WId w)
|
|
{
|
|
if (!m_xCompositeEnabled)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Task::Ptr task = findTask(w);
|
|
if (task)
|
|
{
|
|
task->updateWindowPixmap();
|
|
}
|
|
}
|
|
|
|
void TaskManager::activeWindowChanged(WId w )
|
|
{
|
|
//kdDebug() << "TaskManager::activeWindowChanged" << endl;
|
|
|
|
Task::Ptr t = findTask( w );
|
|
if (!t) {
|
|
if (_active) {
|
|
_active->setActive(false);
|
|
_active = 0;
|
|
}
|
|
}
|
|
else {
|
|
if (_active)
|
|
_active->setActive(false);
|
|
|
|
_active = t;
|
|
_active->setActive(true);
|
|
}
|
|
}
|
|
|
|
void TaskManager::currentDesktopChanged(int desktop)
|
|
{
|
|
emit desktopChanged(desktop);
|
|
}
|
|
|
|
void TaskManager::gotNewStartup( const TDEStartupInfoId& id, const TDEStartupInfoData& data )
|
|
{
|
|
Startup::Ptr s = new Startup( id, data, this );
|
|
_startups.append(s);
|
|
|
|
emit startupAdded(s);
|
|
}
|
|
|
|
void TaskManager::gotStartupChange( const TDEStartupInfoId& id, const TDEStartupInfoData& data )
|
|
{
|
|
Startup::List::iterator itEnd = _startups.end();
|
|
for (Startup::List::iterator sIt = _startups.begin(); sIt != itEnd; ++sIt)
|
|
{
|
|
if ((*sIt)->id() == id)
|
|
{
|
|
(*sIt)->update(data);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TaskManager::killStartup( const TDEStartupInfoId& id )
|
|
{
|
|
Startup::List::iterator sIt = _startups.begin();
|
|
Startup::List::iterator itEnd = _startups.end();
|
|
Startup::Ptr s = 0;
|
|
for (; sIt != itEnd; ++sIt)
|
|
{
|
|
if ((*sIt)->id() == id)
|
|
{
|
|
s = *sIt;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!s)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_startups.erase(sIt);
|
|
emit startupRemoved(s);
|
|
}
|
|
|
|
void TaskManager::killStartup(Startup::Ptr s)
|
|
{
|
|
if (!s)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Startup::List::iterator sIt = _startups.begin();
|
|
Startup::List::iterator itEnd = _startups.end();
|
|
for (; sIt != itEnd; ++sIt)
|
|
{
|
|
if ((*sIt) == s)
|
|
{
|
|
_startups.erase(sIt);
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit startupRemoved(s);
|
|
}
|
|
|
|
TQString TaskManager::desktopName(int desk) const
|
|
{
|
|
return m_winModule->desktopName(desk);
|
|
}
|
|
|
|
int TaskManager::numberOfDesktops() const
|
|
{
|
|
return m_winModule->numberOfDesktops();
|
|
}
|
|
|
|
bool TaskManager::isOnTop(const Task* task)
|
|
{
|
|
if (!task)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
TQValueList<WId>::ConstIterator begin(m_winModule->stackingOrder().constBegin());
|
|
TQValueList<WId>::ConstIterator it = m_winModule->stackingOrder().fromLast();
|
|
do
|
|
{
|
|
Task::Dict::iterator taskItEnd = m_tasksByWId.end();
|
|
for (Task::Dict::iterator taskIt = m_tasksByWId.begin();
|
|
taskIt != taskItEnd; ++taskIt)
|
|
{
|
|
Task::Ptr t = taskIt.data();
|
|
if ((*it) == t->window())
|
|
{
|
|
if (t == task)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (!t->isIconified() &&
|
|
(t->isAlwaysOnTop() == task->isAlwaysOnTop()))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
} while (it-- != begin);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool TaskManager::isOnScreen(int screen, const WId wid)
|
|
{
|
|
if (screen == -1)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
KWin::WindowInfo wi = KWin::windowInfo(wid, NET::WMKDEFrameStrut);
|
|
|
|
// for window decos that fudge a bit and claim to extend beyond the
|
|
// edge of the screen, we just contract a bit.
|
|
TQRect window = wi.frameGeometry();
|
|
TQRect desktop = TQApplication::desktop()->screenGeometry(screen);
|
|
desktop.addCoords(5, 5, -5, -5);
|
|
return window.intersects(desktop);
|
|
}
|
|
|
|
Task::Task(WId win, TQObject *parent, const char *name)
|
|
: TQObject(parent, name),
|
|
_active(false),
|
|
_win(win),
|
|
m_frameId(win),
|
|
_info(KWin::windowInfo(_win, 0, NET::WM2AllowedActions)),
|
|
_lastWidth(0),
|
|
_lastHeight(0),
|
|
_lastResize(false),
|
|
_lastIcon(),
|
|
_thumbSize(0.2),
|
|
_thumb(),
|
|
_grab()
|
|
{
|
|
// try to load icon via net_wm
|
|
_pixmap = KWin::icon(_win, 16, 16, true);
|
|
|
|
// try to guess the icon from the classhint
|
|
if(_pixmap.isNull())
|
|
{
|
|
TDEGlobal::iconLoader()->loadIcon(className().lower(),
|
|
TDEIcon::Small,
|
|
TDEIcon::Small,
|
|
TDEIcon::DefaultState,
|
|
0, true);
|
|
}
|
|
|
|
// load xapp icon
|
|
if (_pixmap.isNull())
|
|
{
|
|
_pixmap = SmallIcon("kcmx");
|
|
}
|
|
|
|
#ifdef THUMBNAILING_POSSIBLE
|
|
m_windowPixmap = 0;
|
|
findWindowFrameId();
|
|
|
|
if (TaskManager::xCompositeEnabled())
|
|
{
|
|
updateWindowPixmap();
|
|
}
|
|
#endif // THUMBNAILING_POSSIBLE
|
|
}
|
|
|
|
Task::~Task()
|
|
{
|
|
#ifdef THUMBNAILING_POSSIBLE
|
|
if (m_windowPixmap)
|
|
{
|
|
XFreePixmap(TQPaintDevice::x11AppDisplay(), m_windowPixmap);
|
|
}
|
|
#endif // THUMBNAILING_POSSIBLE
|
|
}
|
|
|
|
// Task::findWindowFrameId()
|
|
// Code was copied from Kompose.
|
|
// Copyright (C) 2004 Hans Oischinger
|
|
// Permission granted on 2005-04-27.
|
|
void Task::findWindowFrameId()
|
|
{
|
|
#ifdef THUMBNAILING_POSSIBLE
|
|
Window target_win, parent, root;
|
|
Window *children;
|
|
uint nchildren;
|
|
|
|
target_win = _win;
|
|
for (;;)
|
|
{
|
|
if (!XQueryTree(TQPaintDevice::x11AppDisplay(), target_win, &root,
|
|
&parent, &children, &nchildren))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (children)
|
|
{
|
|
XFree(children); // it's a list, that's deallocated!
|
|
}
|
|
|
|
if (!parent || parent == root)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
target_win = parent;
|
|
}
|
|
}
|
|
|
|
m_frameId = target_win;
|
|
#endif // THUMBNAILING_POSSIBLE
|
|
}
|
|
|
|
void Task::refreshIcon()
|
|
{
|
|
// try to load icon via net_wm
|
|
_pixmap = KWin::icon(_win, 16, 16, true);
|
|
|
|
// try to guess the icon from the classhint
|
|
if(_pixmap.isNull())
|
|
{
|
|
TDEGlobal::iconLoader()->loadIcon(className().lower(),
|
|
TDEIcon::Small,
|
|
TDEIcon::Small,
|
|
TDEIcon::DefaultState,
|
|
0, true);
|
|
}
|
|
|
|
// load xapp icon
|
|
if (_pixmap.isNull())
|
|
{
|
|
_pixmap = SmallIcon("kcmx");
|
|
}
|
|
|
|
_lastIcon.resize(0,0);
|
|
emit iconChanged();
|
|
}
|
|
|
|
void Task::refresh(unsigned int dirty)
|
|
{
|
|
TQString name = visibleName();
|
|
_info = KWin::windowInfo(_win, 0, NET::WM2AllowedActions);
|
|
|
|
if (dirty != NET::WMName || name != visibleName())
|
|
{
|
|
emit changed(dirty == NET::WMGeometry);
|
|
}
|
|
}
|
|
|
|
void Task::setActive(bool a)
|
|
{
|
|
_active = a;
|
|
emit changed(false);
|
|
if ( a )
|
|
emit activated();
|
|
else
|
|
emit deactivated();
|
|
}
|
|
|
|
bool Task::isMaximized() const
|
|
{
|
|
return _info.valid() && (_info.state() & NET::Max);
|
|
}
|
|
|
|
bool Task::isMinimized() const
|
|
{
|
|
return _info.valid() && _info.isMinimized();
|
|
}
|
|
|
|
bool Task::isIconified() const
|
|
{
|
|
return _info.valid() && _info.isMinimized();
|
|
}
|
|
|
|
bool Task::isAlwaysOnTop() const
|
|
{
|
|
return _info.valid() && (_info.state() & NET::StaysOnTop);
|
|
}
|
|
|
|
bool Task::isKeptBelowOthers() const
|
|
{
|
|
return _info.valid() && (_info.state() & NET::KeepBelow);
|
|
}
|
|
|
|
bool Task::isFullScreen() const
|
|
{
|
|
return _info.valid() && (_info.state() & NET::FullScreen);
|
|
}
|
|
|
|
bool Task::isShaded() const
|
|
{
|
|
return _info.valid() && (_info.state() & NET::Shaded);
|
|
}
|
|
|
|
bool Task::isOnCurrentDesktop() const
|
|
{
|
|
return _info.valid() && _info.isOnCurrentDesktop();
|
|
}
|
|
|
|
bool Task::isOnAllDesktops() const
|
|
{
|
|
return _info.valid() && _info.onAllDesktops();
|
|
}
|
|
|
|
bool Task::isActive() const
|
|
{
|
|
return _active;
|
|
}
|
|
|
|
bool Task::isOnTop() const
|
|
{
|
|
return TaskManager::the()->isOnTop(this);
|
|
}
|
|
|
|
bool Task::isModified() const
|
|
{
|
|
static TQString modStr = TQString::fromUtf8("[") +
|
|
i18n("modified") +
|
|
TQString::fromUtf8("]");
|
|
int modStrPos = _info.visibleName().find(modStr);
|
|
|
|
return ( modStrPos != -1 );
|
|
}
|
|
|
|
bool Task::demandsAttention() const
|
|
{
|
|
return (_info.valid() && (_info.state() & NET::DemandsAttention)) ||
|
|
_transients_demanding_attention.count() > 0;
|
|
}
|
|
|
|
bool Task::isOnScreen( int screen ) const
|
|
{
|
|
return TaskManager::isOnScreen( screen, _win );
|
|
}
|
|
|
|
void Task::updateDemandsAttentionState( WId w )
|
|
{
|
|
if (window() != w)
|
|
{
|
|
// 'w' is a transient for this task
|
|
NETWinInfo i( tqt_xdisplay(), w, tqt_xrootwin(), NET::WMState );
|
|
if(i.state() & NET::DemandsAttention)
|
|
{
|
|
if (!_transients_demanding_attention.contains(w))
|
|
{
|
|
_transients_demanding_attention.append(w);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_transients_demanding_attention.remove( w );
|
|
}
|
|
}
|
|
}
|
|
|
|
void Task::addTransient( WId w, const NETWinInfo& info )
|
|
{
|
|
_transients.append(w);
|
|
if (info.state() & NET::DemandsAttention)
|
|
{
|
|
_transients_demanding_attention.append(w);
|
|
emit changed(false);
|
|
}
|
|
}
|
|
|
|
void Task::removeTransient(WId w)
|
|
{
|
|
_transients.remove(w);
|
|
_transients_demanding_attention.remove(w);
|
|
}
|
|
|
|
TQString Task::className()
|
|
{
|
|
XClassHint hint;
|
|
if(XGetClassHint(tqt_xdisplay(), _win, &hint)) {
|
|
TQString nh( hint.res_name );
|
|
XFree( hint.res_name );
|
|
XFree( hint.res_class );
|
|
return nh;
|
|
}
|
|
return TQString::null;
|
|
}
|
|
|
|
TQString Task::classClass()
|
|
{
|
|
XClassHint hint;
|
|
if(XGetClassHint(tqt_xdisplay(), _win, &hint)) {
|
|
TQString ch( hint.res_class );
|
|
XFree( hint.res_name );
|
|
XFree( hint.res_class );
|
|
return ch;
|
|
}
|
|
return TQString::null;
|
|
}
|
|
|
|
TQPixmap Task::icon( int width, int height, bool allowResize )
|
|
{
|
|
if ( (width == _lastWidth)
|
|
&& (height == _lastHeight)
|
|
&& (allowResize == _lastResize )
|
|
&& (!_lastIcon.isNull()) )
|
|
return _lastIcon;
|
|
|
|
TQPixmap newIcon = KWin::icon( _win, width, height, allowResize );
|
|
if ( !newIcon.isNull() ) {
|
|
_lastIcon = newIcon;
|
|
_lastWidth = width;
|
|
_lastHeight = height;
|
|
_lastResize = allowResize;
|
|
}
|
|
|
|
return newIcon;
|
|
}
|
|
|
|
TQPixmap Task::bestIcon( int size, bool &isStaticIcon )
|
|
{
|
|
TQPixmap pixmap;
|
|
isStaticIcon = false;
|
|
|
|
switch( size ) {
|
|
case TDEIcon::SizeSmall:
|
|
{
|
|
pixmap = icon( 16, 16, true );
|
|
|
|
// Icon of last resort
|
|
if( pixmap.isNull() ) {
|
|
pixmap = TDEGlobal::iconLoader()->loadIcon( "go",
|
|
TDEIcon::NoGroup,
|
|
TDEIcon::SizeSmall );
|
|
isStaticIcon = true;
|
|
}
|
|
}
|
|
break;
|
|
case TDEIcon::SizeMedium:
|
|
{
|
|
//
|
|
// Try 34x34 first for KDE 2.1 icons with shadows, if we don't
|
|
// get one then try 32x32.
|
|
//
|
|
pixmap = icon( 34, 34, false );
|
|
|
|
if ( (( pixmap.width() != 34 ) || ( pixmap.height() != 34 )) &&
|
|
(( pixmap.width() != 32 ) || ( pixmap.height() != 32 )) )
|
|
{
|
|
pixmap = icon( 32, 32, true );
|
|
}
|
|
|
|
// Icon of last resort
|
|
if( pixmap.isNull() ) {
|
|
pixmap = TDEGlobal::iconLoader()->loadIcon( "go",
|
|
TDEIcon::NoGroup,
|
|
TDEIcon::SizeMedium );
|
|
isStaticIcon = true;
|
|
}
|
|
}
|
|
break;
|
|
case TDEIcon::SizeLarge:
|
|
{
|
|
// If there's a 48x48 icon in the hints then use it
|
|
pixmap = icon( size, size, false );
|
|
|
|
// If not, try to get one from the classname
|
|
if ( pixmap.isNull() || pixmap.width() != size || pixmap.height() != size ) {
|
|
pixmap = TDEGlobal::iconLoader()->loadIcon( className(),
|
|
TDEIcon::NoGroup,
|
|
size,
|
|
TDEIcon::DefaultState,
|
|
0L,
|
|
true );
|
|
isStaticIcon = true;
|
|
}
|
|
|
|
// If we still don't have an icon then scale the one in the hints
|
|
if ( pixmap.isNull() || ( pixmap.width() != size ) || ( pixmap.height() != size ) ) {
|
|
pixmap = icon( size, size, true );
|
|
isStaticIcon = false;
|
|
}
|
|
|
|
// Icon of last resort
|
|
if( pixmap.isNull() ) {
|
|
pixmap = TDEGlobal::iconLoader()->loadIcon( "go",
|
|
TDEIcon::NoGroup,
|
|
size );
|
|
isStaticIcon = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return pixmap;
|
|
}
|
|
|
|
bool Task::idMatch( const TQString& id1, const TQString& id2 )
|
|
{
|
|
if ( id1.isEmpty() || id2.isEmpty() )
|
|
return false;
|
|
|
|
if ( id1.contains( id2 ) > 0 )
|
|
return true;
|
|
|
|
if ( id2.contains( id1 ) > 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void Task::move()
|
|
{
|
|
bool on_current = _info.isOnCurrentDesktop();
|
|
|
|
if (!on_current)
|
|
{
|
|
KWin::setCurrentDesktop(_info.desktop());
|
|
KWin::forceActiveWindow(_win);
|
|
}
|
|
|
|
if (_info.isMinimized())
|
|
{
|
|
KWin::deIconifyWindow(_win);
|
|
}
|
|
|
|
TQRect geom = _info.geometry();
|
|
TQCursor::setPos(geom.center());
|
|
|
|
NETRootInfo ri(tqt_xdisplay(), NET::WMMoveResize);
|
|
ri.moveResizeRequest(_win, geom.center().x(),
|
|
geom.center().y(), NET::Move);
|
|
}
|
|
|
|
void Task::resize()
|
|
{
|
|
bool on_current = _info.isOnCurrentDesktop();
|
|
|
|
if (!on_current)
|
|
{
|
|
KWin::setCurrentDesktop(_info.desktop());
|
|
KWin::forceActiveWindow(_win);
|
|
}
|
|
|
|
if (_info.isMinimized())
|
|
{
|
|
KWin::deIconifyWindow(_win);
|
|
}
|
|
|
|
TQRect geom = _info.geometry();
|
|
TQCursor::setPos(geom.bottomRight());
|
|
|
|
NETRootInfo ri(tqt_xdisplay(), NET::WMMoveResize);
|
|
ri.moveResizeRequest(_win, geom.bottomRight().x(),
|
|
geom.bottomRight().y(), NET::BottomRight);
|
|
}
|
|
|
|
void Task::setMaximized(bool maximize)
|
|
{
|
|
KWin::WindowInfo info = KWin::windowInfo(_win, NET::WMState | NET::XAWMState | NET::WMDesktop);
|
|
bool on_current = info.isOnCurrentDesktop();
|
|
|
|
if (!on_current)
|
|
{
|
|
KWin::setCurrentDesktop(info.desktop());
|
|
}
|
|
|
|
if (info.isMinimized())
|
|
{
|
|
KWin::deIconifyWindow(_win);
|
|
}
|
|
|
|
NETWinInfo ni(tqt_xdisplay(), _win, tqt_xrootwin(), NET::WMState);
|
|
|
|
if (maximize)
|
|
{
|
|
ni.setState(NET::Max, NET::Max);
|
|
}
|
|
else
|
|
{
|
|
ni.setState(0, NET::Max);
|
|
}
|
|
|
|
if (!on_current)
|
|
{
|
|
KWin::forceActiveWindow(_win);
|
|
}
|
|
}
|
|
|
|
void Task::toggleMaximized()
|
|
{
|
|
setMaximized(!isMaximized());
|
|
}
|
|
|
|
void Task::restore()
|
|
{
|
|
KWin::WindowInfo info = KWin::windowInfo(_win, NET::WMState | NET::XAWMState | NET::WMDesktop);
|
|
bool on_current = info.isOnCurrentDesktop();
|
|
|
|
if (!on_current)
|
|
{
|
|
KWin::setCurrentDesktop(info.desktop());
|
|
}
|
|
|
|
if( info.isMinimized())
|
|
{
|
|
KWin::deIconifyWindow(_win);
|
|
}
|
|
|
|
NETWinInfo ni(tqt_xdisplay(), _win, tqt_xrootwin(), NET::WMState);
|
|
ni.setState(0, NET::Max);
|
|
|
|
if (!on_current)
|
|
{
|
|
KWin::forceActiveWindow( _win );
|
|
}
|
|
}
|
|
|
|
void Task::setIconified(bool iconify)
|
|
{
|
|
if (iconify)
|
|
{
|
|
KWin::iconifyWindow(_win);
|
|
}
|
|
else
|
|
{
|
|
KWin::WindowInfo info = KWin::windowInfo(_win, NET::WMState | NET::XAWMState | NET::WMDesktop);
|
|
bool on_current = info.isOnCurrentDesktop();
|
|
|
|
if (!on_current)
|
|
{
|
|
KWin::setCurrentDesktop(info.desktop());
|
|
}
|
|
|
|
KWin::deIconifyWindow(_win);
|
|
|
|
if (!on_current)
|
|
{
|
|
KWin::forceActiveWindow(_win);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Task::toggleIconified()
|
|
{
|
|
setIconified(!isIconified());
|
|
}
|
|
|
|
void Task::close()
|
|
{
|
|
NETRootInfo ri( tqt_xdisplay(), NET::CloseWindow );
|
|
ri.closeWindowRequest( _win );
|
|
}
|
|
|
|
void Task::raise()
|
|
{
|
|
// kdDebug(1210) << "Task::raise(): " << name() << endl;
|
|
KWin::raiseWindow( _win );
|
|
}
|
|
|
|
void Task::lower()
|
|
{
|
|
// kdDebug(1210) << "Task::lower(): " << name() << endl;
|
|
KWin::lowerWindow( _win );
|
|
}
|
|
|
|
void Task::activate()
|
|
{
|
|
// kdDebug(1210) << "Task::activate():" << name() << endl;
|
|
WId w = _win;
|
|
if (_transients_demanding_attention.count() > 0)
|
|
{
|
|
w = _transients_demanding_attention.last();
|
|
}
|
|
KWin::forceActiveWindow( w );
|
|
}
|
|
|
|
void Task::activateRaiseOrIconify()
|
|
{
|
|
if (!isActive() || isIconified())
|
|
{
|
|
activate();
|
|
}
|
|
else if (!isOnTop())
|
|
{
|
|
raise();
|
|
}
|
|
else
|
|
{
|
|
setIconified(true);
|
|
}
|
|
}
|
|
|
|
void Task::toDesktop(int desk)
|
|
{
|
|
NETWinInfo ni(tqt_xdisplay(), _win, tqt_xrootwin(), NET::WMDesktop);
|
|
if (desk == 0)
|
|
{
|
|
if (_info.valid() && _info.onAllDesktops())
|
|
{
|
|
ni.setDesktop(TaskManager::the()->winModule()->currentDesktop());
|
|
KWin::forceActiveWindow(_win);
|
|
}
|
|
else
|
|
{
|
|
ni.setDesktop(NETWinInfo::OnAllDesktops);
|
|
}
|
|
|
|
return;
|
|
}
|
|
ni.setDesktop(desk);
|
|
if(desk == TaskManager::the()->winModule()->currentDesktop())
|
|
KWin::forceActiveWindow(_win);
|
|
}
|
|
|
|
void Task::toCurrentDesktop()
|
|
{
|
|
toDesktop(TaskManager::the()->winModule()->currentDesktop());
|
|
}
|
|
|
|
void Task::setAlwaysOnTop(bool stay)
|
|
{
|
|
NETWinInfo ni( tqt_xdisplay(), _win, tqt_xrootwin(), NET::WMState);
|
|
if(stay)
|
|
ni.setState( NET::StaysOnTop, NET::StaysOnTop );
|
|
else
|
|
ni.setState( 0, NET::StaysOnTop );
|
|
}
|
|
|
|
void Task::toggleAlwaysOnTop()
|
|
{
|
|
setAlwaysOnTop( !isAlwaysOnTop() );
|
|
}
|
|
|
|
void Task::setKeptBelowOthers(bool below)
|
|
{
|
|
NETWinInfo ni(tqt_xdisplay(), _win, tqt_xrootwin(), NET::WMState);
|
|
|
|
if (below)
|
|
{
|
|
ni.setState(NET::KeepBelow, NET::KeepBelow);
|
|
}
|
|
else
|
|
{
|
|
ni.setState(0, NET::KeepBelow);
|
|
}
|
|
}
|
|
|
|
void Task::toggleKeptBelowOthers()
|
|
{
|
|
setKeptBelowOthers(!isKeptBelowOthers());
|
|
}
|
|
|
|
void Task::setFullScreen(bool fullscreen)
|
|
{
|
|
NETWinInfo ni(tqt_xdisplay(), _win, tqt_xrootwin(), NET::WMState);
|
|
|
|
if (fullscreen)
|
|
{
|
|
ni.setState(NET::FullScreen, NET::FullScreen);
|
|
}
|
|
else
|
|
{
|
|
ni.setState(0, NET::FullScreen);
|
|
}
|
|
}
|
|
|
|
void Task::toggleFullScreen()
|
|
{
|
|
setFullScreen(!isFullScreen());
|
|
}
|
|
|
|
void Task::setShaded(bool shade)
|
|
{
|
|
NETWinInfo ni( tqt_xdisplay(), _win, tqt_xrootwin(), NET::WMState);
|
|
if(shade)
|
|
ni.setState( NET::Shaded, NET::Shaded );
|
|
else
|
|
ni.setState( 0, NET::Shaded );
|
|
}
|
|
|
|
void Task::toggleShaded()
|
|
{
|
|
setShaded( !isShaded() );
|
|
}
|
|
|
|
void Task::publishIconGeometry(TQRect rect)
|
|
{
|
|
if (rect == m_iconGeometry)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_iconGeometry = rect;
|
|
NETWinInfo ni(tqt_xdisplay(), _win, tqt_xrootwin(), 0);
|
|
NETRect r;
|
|
|
|
if (rect.isValid())
|
|
{
|
|
r.pos.x = rect.x();
|
|
r.pos.y = rect.y();
|
|
r.size.width = rect.width();
|
|
r.size.height = rect.height();
|
|
}
|
|
ni.setIconGeometry(r);
|
|
}
|
|
|
|
void Task::updateThumbnail()
|
|
{
|
|
if ( !_info.valid() ||
|
|
!isOnCurrentDesktop() ||
|
|
!isActive() ||
|
|
!_grab.isNull() ) // We're already processing one...
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// We do this as a two stage process to remove the delay caused
|
|
// by the thumbnail generation. This makes things much smoother
|
|
// on slower machines.
|
|
//
|
|
TQWidget *rootWin = tqApp->desktop();
|
|
TQRect geom = _info.geometry();
|
|
_grab = TQPixmap::grabWindow(rootWin->winId(),
|
|
geom.x(), geom.y(),
|
|
geom.width(), geom.height());
|
|
|
|
if (!_grab.isNull())
|
|
{
|
|
TQTimer::singleShot(200, this, TQ_SLOT(generateThumbnail()));
|
|
}
|
|
}
|
|
|
|
void Task::generateThumbnail()
|
|
{
|
|
if ( _grab.isNull() )
|
|
return;
|
|
|
|
TQImage img = _grab.convertToImage();
|
|
|
|
double width = img.width();
|
|
double height = img.height();
|
|
width = width * _thumbSize;
|
|
height = height * _thumbSize;
|
|
|
|
img = img.smoothScale( tqRound(width), tqRound(height) );
|
|
_thumb = img;
|
|
_grab.resize( 0, 0 ); // Makes grab a null image.
|
|
|
|
emit thumbnailChanged();
|
|
}
|
|
|
|
#ifdef THUMBNAILING_POSSIBLE
|
|
TQPixmap Task::thumbnail(int maxDimension)
|
|
{
|
|
if (!TaskManager::xCompositeEnabled() || !m_windowPixmap)
|
|
{
|
|
return TQPixmap();
|
|
}
|
|
|
|
Display *dpy = TQPaintDevice::x11AppDisplay();
|
|
|
|
XWindowAttributes winAttr;
|
|
XGetWindowAttributes(dpy, m_frameId, &winAttr);
|
|
XRenderPictFormat *format = XRenderFindVisualFormat(dpy, winAttr.visual);
|
|
|
|
XRenderPictureAttributes picAttr;
|
|
picAttr.subwindow_mode = IncludeInferiors; // Don't clip child widgets
|
|
|
|
Picture picture = XRenderCreatePicture(dpy, m_windowPixmap, format,
|
|
CPSubwindowMode, &picAttr);
|
|
|
|
// Get shaped windows handled correctly.
|
|
XserverRegion region = XFixesCreateRegionFromWindow(dpy, m_frameId,
|
|
WindowRegionBounding);
|
|
XFixesSetPictureClipRegion(dpy, picture, 0, 0, region);
|
|
XFixesDestroyRegion(dpy, region);
|
|
|
|
double factor;
|
|
if (winAttr.width > winAttr.height)
|
|
{
|
|
factor = (double)maxDimension / (double)winAttr.width;
|
|
}
|
|
else
|
|
{
|
|
factor = (double)maxDimension / (double)winAttr.height;
|
|
}
|
|
int thumbnailWidth = (int)(winAttr.width * factor);
|
|
int thumbnailHeight = (int)(winAttr.height * factor);
|
|
|
|
TQPixmap thumbnail(thumbnailWidth, thumbnailHeight);
|
|
thumbnail.fill(TQApplication::palette().active().background());
|
|
|
|
#if 0 // TQImage::smoothScale() scaling
|
|
TQPixmap full(winAttr.width, winAttr.height);
|
|
full.fill(TQApplication::palette().active().background());
|
|
|
|
bool hasAlpha = format->type == PictTypeDirect && format->direct.alphaMask;
|
|
|
|
XRenderComposite(dpy,
|
|
hasAlpha ? PictOpOver : PictOpSrc,
|
|
picture, // src
|
|
None, // mask
|
|
full.x11RenderHandle(), // dst
|
|
0, 0, // src offset
|
|
0, 0, // mask offset
|
|
0, 0, // dst offset
|
|
winAttr.width, winAttr.height);
|
|
|
|
KPixmapIO io;
|
|
TQImage image = io.convertToImage(full);
|
|
thumbnail = io.convertToPixmap(image.smoothScale(thumbnailWidth,
|
|
thumbnailHeight));
|
|
#else // XRENDER scaling
|
|
// Scaling matrix
|
|
XTransform transformation = {{
|
|
{ XDoubleToFixed(1), XDoubleToFixed(0), XDoubleToFixed( 0) },
|
|
{ XDoubleToFixed(0), XDoubleToFixed(1), XDoubleToFixed( 0) },
|
|
{ XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(factor) }
|
|
}};
|
|
|
|
XRenderSetPictureTransform(dpy, picture, &transformation);
|
|
XRenderSetPictureFilter(dpy, picture, FilterBest, 0, 0);
|
|
|
|
XRenderComposite(TQPaintDevice::x11AppDisplay(),
|
|
PictOpOver, // we're filtering, alpha values are probable
|
|
picture, // src
|
|
None, // mask
|
|
thumbnail.x11RenderHandle(), // dst
|
|
0, 0, // src offset
|
|
0, 0, // mask offset
|
|
0, 0, // dst offset
|
|
thumbnailWidth, thumbnailHeight);
|
|
#endif
|
|
XRenderFreePicture(dpy, picture);
|
|
|
|
return thumbnail;
|
|
}
|
|
#else // THUMBNAILING_POSSIBLE
|
|
TQPixmap Task::thumbnail(int /* maxDimension */)
|
|
{
|
|
return TQPixmap();
|
|
}
|
|
#endif // THUMBNAILING_POSSIBLE
|
|
|
|
void Task::updateWindowPixmap()
|
|
{
|
|
#ifdef THUMBNAILING_POSSIBLE
|
|
if (!TaskManager::xCompositeEnabled() || !isOnCurrentDesktop() ||
|
|
isMinimized())
|
|
{
|
|
return;
|
|
}
|
|
|
|
Display *dpy = TQPaintDevice::x11AppDisplay();
|
|
|
|
if (m_windowPixmap)
|
|
{
|
|
XFreePixmap(dpy, m_windowPixmap);
|
|
}
|
|
|
|
KXErrorHandler err;
|
|
m_windowPixmap = XCompositeNameWindowPixmap(dpy, m_frameId);
|
|
if( err.error( true ))
|
|
m_windowPixmap = None;
|
|
#endif // THUMBNAILING_POSSIBLE
|
|
}
|
|
|
|
void Task::tileTo(int position)
|
|
{
|
|
TQByteArray params;
|
|
TQDataStream stream(params, IO_WriteOnly);
|
|
stream << _win << position;
|
|
TDEApplication::kApplication()->dcopClient()->send("twin", "KWinInterface", "tileWindowToBorder(unsigned long int, int)", params);
|
|
}
|
|
|
|
Startup::Startup(const TDEStartupInfoId& id, const TDEStartupInfoData& data,
|
|
TQObject * parent, const char *name)
|
|
: TQObject(parent, name), _id(id), _data(data)
|
|
{
|
|
}
|
|
|
|
Startup::~Startup()
|
|
{
|
|
}
|
|
|
|
void Startup::update(const TDEStartupInfoData& data)
|
|
{
|
|
_data.update(data);
|
|
emit changed();
|
|
}
|
|
|
|
int TaskManager::currentDesktop() const
|
|
{
|
|
return m_winModule->currentDesktop();
|
|
}
|
|
|
|
TaskDrag::TaskDrag(const Task::List& tasks, TQWidget* source, const char* name)
|
|
: TQStoredDrag("taskbar/task", source, name)
|
|
{
|
|
TQByteArray data;
|
|
TQDataStream stream(data, IO_WriteOnly);
|
|
|
|
Task::List::const_iterator itEnd = tasks.constEnd();
|
|
for (Task::List::const_iterator it = tasks.constBegin(); it != itEnd; ++it)
|
|
{
|
|
stream << (*it)->window();
|
|
}
|
|
|
|
setEncodedData(data);
|
|
}
|
|
|
|
TaskDrag::~TaskDrag()
|
|
{
|
|
}
|
|
|
|
bool TaskDrag::canDecode(const TQMimeSource* e)
|
|
{
|
|
return e->provides("taskbar/task");
|
|
}
|
|
|
|
Task::List TaskDrag::decode( const TQMimeSource* e )
|
|
{
|
|
TQByteArray data(e->encodedData("taskbar/task"));
|
|
Task::List tasks;
|
|
|
|
if (data.size())
|
|
{
|
|
TQDataStream stream(data, IO_ReadOnly);
|
|
while (!stream.atEnd())
|
|
{
|
|
WId id;
|
|
stream >> id;
|
|
if (Task::Ptr task = TaskManager::the()->findTask(id))
|
|
{
|
|
tasks.append(task);
|
|
}
|
|
}
|
|
}
|
|
|
|
return tasks;
|
|
}
|
|
|