int KWM::desktop(Window w){
static Atom a = 0;
if (!a)
a = XInternAtom(qt_xdisplay(), "KWM_WIN_DESKTOP", False);
if (isSticky(w))
return currentDesktop();
long result = 1;
if (!getSimpleProperty(w, a, result) || result <= 0){
result = currentDesktop();
moveToDesktop(w, (int) result);
kwm_error = TRUE; // restore error
}
return (int) result;
}
QRect KWM::setProperties(Window w, const QString &props){
int a;
int data[13];
int d1,d2,d3,d4;
int n = 0;
QRect result;
QString arg = props.data();
while ((a = arg.find('+', 0)) != -1){
if (n<13)
data[n++]=arg.left(a).toInt();
arg.remove(0,a+1);
}
if (n<13)
data[n++] = arg.toInt();
if (n!=13){
// fprintf(stderr, "KWM::setProperties: <bad properties error>\n");
return result;
}
n = 0;
moveToDesktop(w, data[n++]);
d1 = data[n++];
d2 = data[n++];
d3 = data[n++];
d4 = data[n++];
result = QRect(d1,d2,d3,d4);
setGeometry(w, result);
d1 = data[n++];
d2 = data[n++];
d3 = data[n++];
d4 = data[n++];
setGeometryRestore(w, QRect(d1,d2,d3,d4));
setIconify(w, (data[n++] != 0) );
setMaximize(w, (data[n] != 0), data[n] );n++;
setSticky(w, (data[n++] != 0) );
setDecoration(w, data[n++] );
return result;
}
void TaskbarProxy::showMenu (const QString& widStr, int x, int y)
{
auto& w = Util::XWrapper::Instance ();
const auto& wid = widStr.toULong ();
const auto state = w.GetWindowState (wid);
const auto actions = w.GetWindowActions (wid);
auto menu = new QMenu;
menu->setAttribute (Qt::WA_DeleteOnClose);
{
auto minimizeAct = menu->addAction (tr ("Minimize"));
minimizeAct->setCheckable (true);
if (state & Util::WinStateFlag::Hidden)
minimizeAct->setChecked (true);
else
minimizeAct->setEnabled (actions & Util::AllowedActionFlag::Minimize);
minimizeAct->setProperty ("Actor",
QVariant::fromValue<Actor_f> ([this, state] (const QString& wid)
{
state & Util::WinStateFlag::Hidden ?
raiseWindow (wid) :
minimizeWindow (wid);
}));
}
{
auto maximizeAct = menu->addAction (tr ("Maximize"));
maximizeAct->setCheckable (true);
const bool isMaximized = state & Util::WinStateFlag::MaximizedHorz ||
state & Util::WinStateFlag::MaximizedVert;
if (isMaximized)
maximizeAct->setChecked (true);
else
maximizeAct->setEnabled (actions & Util::AllowedActionFlag::MaximizeHorz ||
actions & Util::AllowedActionFlag::MaximizeVert);
maximizeAct->setProperty ("Actor",
QVariant::fromValue<Actor_f> ([this, isMaximized] (const QString& wid)
{
isMaximized ? unmaximizeWindow (wid) : maximizeWindow (wid);
}));
}
auto moreMenu = menu->addMenu (tr ("More"));
{
auto keepAbove = moreMenu->addAction (tr ("Keep above others"));
keepAbove->setEnabled (actions & Util::AllowedActionFlag::MoveToTop);
keepAbove->setCheckable (true);
const bool isTop = state & Util::WinStateFlag::OnTop;
keepAbove->setChecked (isTop);
keepAbove->setProperty ("Actor",
QVariant::fromValue<Actor_f> ([this, isTop] (const QString& wid)
{ moveWindowTo (wid, isTop ? "normal" : "top"); }));
keepAbove->setIcon (Proxy_->GetIconThemeManager ()->GetIcon ("go-top"));
}
{
auto keepBelow = moreMenu->addAction (tr ("Keep below others"));
keepBelow->setEnabled (actions & Util::AllowedActionFlag::MoveToBottom);
keepBelow->setCheckable (true);
const bool isBottom = state & Util::WinStateFlag::OnBottom;
keepBelow->setChecked (isBottom);
keepBelow->setProperty ("Actor",
QVariant::fromValue<Actor_f> ([this, isBottom] (const QString& wid)
{ moveWindowTo (wid, isBottom ? "normal" : "bottom"); }));
keepBelow->setIcon (Proxy_->GetIconThemeManager ()->GetIcon ("go-bottom"));
}
{
auto shadeAct = moreMenu->addAction (tr ("Shade"));
shadeAct->setEnabled (actions & Util::AllowedActionFlag::Shade);
shadeAct->setCheckable (true);
shadeAct->setChecked (state & Util::WinStateFlag::Shaded);
shadeAct->setProperty ("Actor",
QVariant::fromValue<Actor_f> ([this] (const QString& wid)
{ toggleShadeWindow (wid); }));
}
QMenu *desksMenu = 0;
{
const auto numDesks = w.GetDesktopCount ();
if (numDesks > 1)
{
desksMenu = menu->addMenu (tr ("Move to desktop"));
const auto winDesk = w.GetWindowDesktop (wid);
auto addAct = [this, actions, winDesk, desksMenu] (int num, const QString& name)
{
auto act = desksMenu->addAction (name);
act->setEnabled (actions & Util::AllowedActionFlag::ChangeDesktop);
act->setCheckable (true);
act->setChecked (winDesk == num);
act->setProperty ("Actor",
QVariant::fromValue<Actor_f> ([this, num] (const QString& wid)
{ moveToDesktop (wid, num); }));
};
const auto& deskNames = w.GetDesktopNames ();
for (int i = 0; i < numDesks; ++i)
addAct (i, deskNames.value (i, QString::number (i)));
desksMenu->addSeparator ();
addAct (0xFFFFFFFF, tr ("All desktops"));
}
}
menu->addSeparator ();
{
auto closeAct = menu->addAction (tr ("Close"));
closeAct->setEnabled (actions & Util::AllowedActionFlag::Close);
closeAct->setProperty ("Actor",
QVariant::fromValue<Actor_f> ([this] (const QString& wid)
{ closeWindow (wid); }));
closeAct->setIcon (Proxy_->GetIconThemeManager ()->GetIcon ("window-close"));
}
auto allActions = menu->actions () + moreMenu->actions ();
if (desksMenu)
allActions += desksMenu->actions ();
for (auto act : allActions)
{
act->setProperty ("WID", widStr);
connect (act,
SIGNAL (triggered ()),
this,
SLOT (handleAction ()));
}
menu->popup ({ x, y });
}
