/*
* groupMinimizeWindows
*
*/
static void
groupMinimizeWindows (CompWindow *top,
GroupSelection *group,
Bool minimize)
{
int i;
for (i = 0; i < group->nWins; i++)
{
CompWindow *w = group->windows[i];
if (w->id == top->id)
continue;
if (minimize)
minimizeWindow (w);
else
unminimizeWindow (w);
}
}
void KviMainWindow::installAccelerators()
{
m_pAccellerators->append(KviShortcut::create(KVI_SHORTCUTS_WIN_PREV,this,SLOT(switchToPrevWindow()),0,Qt::ApplicationShortcut));
m_pAccellerators->append(KviShortcut::create(KVI_SHORTCUTS_WIN_NEXT,this,SLOT(switchToNextWindow()),0,Qt::ApplicationShortcut));
m_pAccellerators->append(KviShortcut::create(KVI_SHORTCUTS_WIN_PREV_CONTEXT,this,SLOT(switchToPrevWindowInContext()),0,Qt::ApplicationShortcut));
m_pAccellerators->append(KviShortcut::create(KVI_SHORTCUTS_WIN_NEXT_CONTEXT,this,SLOT(switchToNextWindowInContext()),0,Qt::ApplicationShortcut));
m_pAccellerators->append(KviShortcut::create(KVI_SHORTCUTS_WIN_PREV_HIGHLIGHT,this,SLOT(switchToPrevHighlightedWindow()),0,Qt::ApplicationShortcut));
m_pAccellerators->append(KviShortcut::create(KVI_SHORTCUTS_WIN_NEXT_HIGHLIGHT,this,SLOT(switchToNextHighlightedWindow()),0,Qt::ApplicationShortcut));
m_pAccellerators->append(KviShortcut::create(KVI_SHORTCUTS_WIN_MAXIMIZE,this,SLOT(maximizeWindow()),0,Qt::ApplicationShortcut));
m_pAccellerators->append(KviShortcut::create(KVI_SHORTCUTS_WIN_MINIMIZE,this,SLOT(minimizeWindow()),0,Qt::ApplicationShortcut));
static int accel_table[] = {
Qt::Key_1 + Qt::ControlModifier, // script accels...
Qt::Key_2 + Qt::ControlModifier,
Qt::Key_3 + Qt::ControlModifier,
Qt::Key_4 + Qt::ControlModifier,
Qt::Key_5 + Qt::ControlModifier,
Qt::Key_6 + Qt::ControlModifier,
Qt::Key_7 + Qt::ControlModifier,
Qt::Key_8 + Qt::ControlModifier,
Qt::Key_9 + Qt::ControlModifier,
Qt::Key_0 + Qt::ControlModifier,
Qt::Key_F2,
Qt::Key_F3,
Qt::Key_F4,
Qt::Key_F5,
Qt::Key_F6,
Qt::Key_F7,
Qt::Key_F8,
Qt::Key_F9,
Qt::Key_F10,
Qt::Key_F11,
Qt::Key_F12,
0
};
int i=0, keys=0;
while((keys = accel_table[i]))
{
m_pAccellerators->append(KviShortcut::create(keys,this,SLOT(accelActivated()),SLOT(accelActivated()),Qt::ApplicationShortcut));
i++;
}
}
void Mac::OSXStyle::initWindowMenu(QMainWindow *mw) {
if (!windowMenu && mw) {
windowMenu=new QMenu(tr("&Window"), mw);
closeAct=Ui::ActionCollection::get()->createAction("close-window", tr("Close"));
minAct=Ui::ActionCollection::get()->createAction("minimize-window", tr("Minimize"));
zoomAct=Ui::ActionCollection::get()->createAction("zoom-window", tr("Zoom"));
windowMenu->addAction(closeAct);
windowMenu->addAction(minAct);
windowMenu->addAction(zoomAct);
windowMenu->addSeparator();
addWindow(mw);
mw->menuBar()->addMenu(windowMenu);
actions[mw]->setChecked(true);
connect(qApp, SIGNAL(focusWindowChanged(QWindow *)), SLOT(focusWindowChanged(QWindow *)));
closeAct->setShortcut(Qt::ControlModifier+Qt::Key_W);
minAct->setShortcut(Qt::ControlModifier+Qt::Key_M);
connect(closeAct, SIGNAL(triggered()), SLOT(closeWindow()));
connect(minAct, SIGNAL(triggered()), SLOT(minimizeWindow()));
connect(zoomAct, SIGNAL(triggered()), SLOT(zoomWindow()));
controlActions(mw);
}
}
static Bool
sessionReadWindow (CompWindow *w)
{
CompDisplay *d = w->screen->display;
XWindowChanges xwc;
unsigned int xwcm = 0;
char *title, *role, *clientId, *command;
SessionWindowList *cur;
SESSION_CORE (&core);
SESSION_DISPLAY (d);
/* optimization: don't mess around with getting X properties
if there is nothing to match */
if (!sc->windowList)
return FALSE;
if (!isSessionWindow (w))
return FALSE;
clientId = sessionGetClientLeaderProperty (w, sd->clientIdAtom);
if (!clientId && !sd->opt[SESSION_DISPLAY_OPTION_SAVE_LEGACY].value.b)
return FALSE;
command = sessionGetClientLeaderProperty (w, sd->commandAtom);
title = sessionGetWindowTitle (w);
role = sessionGetTextProperty (d, w->id, sd->roleAtom);
for (cur = sc->windowList; cur; cur = cur->next)
{
if (clientId && cur->clientId && strcmp (clientId, cur->clientId) == 0)
{
/* try to match role as well if possible (see ICCCM 5.1) */
if (role && cur->role)
{
if (strcmp (role, cur->role) == 0)
break;
}
else
{
if (sessionMatchWindowClass (w, cur))
break;
}
}
else if (sd->opt[SESSION_DISPLAY_OPTION_SAVE_LEGACY].value.b)
{
if (cur->command && command && sessionMatchWindowClass (w, cur))
{
/* match by command, class and name as second try */
break;
}
else if (title && cur->title && strcmp (title, cur->title) == 0)
{
/* last resort: match by window title */
break;
}
}
}
if (clientId)
free (clientId);
if (command)
free (command);
if (title)
free (title);
if (role)
free (role);
if (!cur)
return FALSE;
/* found a window */
changeWindowState (w, (w->state & ~SAVED_WINDOW_STATE) | cur->state);
if (cur->geometryValid)
{
xwcm = CWX | CWY;
xwc.x = cur->geometry.x + w->input.left;
xwc.y = cur->geometry.y + w->input.top;
if (!sessionWindowIsOnAllViewports (w))
{
xwc.x -= (w->screen->x * w->screen->width);
xwc.y -= (w->screen->y * w->screen->height);
}
if (cur->geometry.width != w->serverWidth)
{
xwc.width = cur->geometry.width;
xwcm |= CWWidth;
}
if (cur->geometry.height != w->serverHeight)
{
xwc.height = cur->geometry.height;
xwcm |= CWHeight;
}
if (w->mapNum && (xwcm & (CWWidth | CWHeight)))
sendSyncRequest (w);
configureXWindow (w, xwcm, &xwc);
w->placed = TRUE;
}
if (cur->minimized)
minimizeWindow (w);
if (cur->workspace != -1)
setDesktopForWindow (w, cur->workspace);
updateWindowAttributes (w, CompStackingUpdateModeNone);
/* remove item from list */
sessionRemoveWindowListItem (cur);
return TRUE;
}
void MinimizeWindow::executeFinish(const QHash<QString, QVariant>& /*attrs*/) {
if (!at_start) {
minimizeWindow();
}
}
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 });
}
