bool RKWardApplication::x11EventFilter (XEvent *e) {
if (detect_x11_creations) {
if (e->type == CreateNotify) {
if (e->xcreatewindow.parent == QX11Info::appRootWindow ()) {
KWindowInfo info = KWindowInfo (e->xcreatewindow.window, NET::WMName | NET::WMWindowType);
// at this point, we used to check, whether this window has some name or another. This heuristic allowed to sieve out helper windows of the window manager. However, since R 2.8.0, sometimes the window is mapped, before it has been given a name.
// Now we rely on the fact (we hope it *is* a fact), that the device window is always the first one created.
if ((info.windowType (0xFFFF) != 0) && (!created_window)) {
created_window = e->xcreatewindow.window;
return true;
}
} else {
RK_ASSERT (false);
}
}
}
if (e->type == PropertyNotify) {
if (e->xproperty.atom == wm_name_property) {
if (name_watchers_list.contains (e->xproperty.window)) {
KWindowInfo wininfo = KWindowInfo (e->xproperty.window, NET::WMName);
name_watchers_list[e->xproperty.window]->setCaption (wininfo.name ());
return true;
}
}
}
return KApplication::x11EventFilter (e);
}
void WindowListModel::onWindowAdded(WId id)
{
KWindowInfo kwi = KWindowSystem::self()->windowInfo(id, NET::WMName | NET::WMVisibleName | NET::WMVisibleIconName | NET::WMWindowType);
if( ( kwi.windowType(NET::NormalMask) == NET::Normal ) && ( id != m_kdevWinId ) ) {
beginInsertRows( QModelIndex(), m_winList.count(), m_winList.count() + 1 );
m_winList.append( kwi );
// qDebug() << "onWindowAdded " << kwi.visibleName() << "(" << id << ")";
endInsertRows();
}
}
void SwitchWindow::wheelEvent(QGraphicsSceneWheelEvent *event)
{
//TODO somehow find the "next" or "previous" window
//without changing hte window order (don't want to always go between two windows)
if (m_windowsOrder.isEmpty()) {
m_windowsOrder = KWindowSystem::stackingOrder();
} else {
if (!m_clearOrderTimer) {
m_clearOrderTimer = new QTimer(this);
connect(m_clearOrderTimer, SIGNAL(timeout()), this, SLOT(clearWindowsOrder()));
m_clearOrderTimer->setSingleShot(true);
m_clearOrderTimer->setInterval(1000);
}
m_clearOrderTimer->start();
}
const WId activeWindow = KWindowSystem::activeWindow();
const bool up = event->delta() > 0;
bool next = false;
WId first = 0;
WId last = 0;
for (int i = 0; i < m_windowsOrder.count(); ++i) {
const WId id = m_windowsOrder.at(i);
const KWindowInfo info(id, NET::WMDesktop | NET::WMVisibleName | NET::WMWindowType);
if (info.windowType(NET::NormalMask | NET::DialogMask | NET::UtilityMask) != -1 && info.isOnCurrentDesktop()) {
if (next) {
KWindowSystem::forceActiveWindow(id);
return;
}
if (first == 0) {
first = id;
}
if (id == activeWindow) {
if (up) {
next = true;
} else if (last) {
KWindowSystem::forceActiveWindow(last);
return;
}
}
last = id;
}
}
KWindowSystem::forceActiveWindow(up ? first : last);
}
void AddRuleMenu::showing()
{
int x;
//dispose previous items
// try
// {
// for (x = 0; x != actions().count(); ++x)
// {
// delete actions().at(x);
// }
// }
// catch(...)
// {
// fprintf(stderr, "[AddRuleMenu:%p]: Algorithm `dispose previous items` crashed :(\n");
// }
clear();
//populate menu
QList<WId> list = KWindowSystem::windows();
int desktop = controller->getIndex();
WId id;
KWindowInfo* info;
static int window_supported_types = NET::NormalMask | NET::DialogMask | NET::OverrideMask | NET::UtilityMask |
NET::DesktopMask | NET::DockMask | NET::TopMenuMask | NET::SplashMask |
NET::ToolbarMask | NET::MenuMask;
for (x = 0; x != list.count(); ++x)
{
id = list.at(x);
info = new KWindowInfo(id, NET::WMDesktop | NET::WMWindowType, NET::WM2WindowClass);
if (info->windowType(window_supported_types) == NET::Normal)
if (!desktop || info->desktop() == desktop)
addAction(new DesktopRule(this, info->windowClassName(), QIcon(KWindowSystem::icon(id)), info->windowClassName()));
}
addSeparator();
addAction(new DesktopRule(this, "Always disabled", QIcon(), "*"));
addAction(new DesktopRule(this, "Always enabled", QIcon(), "#"));
}
void WindowList::showMenu(bool onlyCurrentDesktop)
{
QList<WId> windows = KWindowSystem::windows();
QList<QAction*> actionList;
QList< QList<QAction*> > windowList;
int amount = 0;
int number = 0;
qDeleteAll(m_listMenu->actions());
//m_listMenu->clear();
if (!onlyCurrentDesktop) {
m_listMenu->addTitle(i18n("Actions"));
QAction *unclutterAction = m_listMenu->addAction(i18n("Unclutter Windows"));
QAction *cascadeAction = m_listMenu->addAction(i18n("Cascade Windows"));
connect(unclutterAction, SIGNAL(triggered()), m_listMenu, SLOT(slotUnclutterWindows()));
connect(cascadeAction, SIGNAL(triggered()), m_listMenu, SLOT(slotCascadeWindows()));
}
for (int i = 0; i <= KWindowSystem::numberOfDesktops(); ++i) {
windowList.append(QList<QAction*>());
}
for (int i = 0; i < windows.count(); ++i) {
KWindowInfo window = KWindowSystem::windowInfo(windows.at(i), (NET::WMGeometry | NET::WMFrameExtents | NET::WMWindowType | NET::WMDesktop | NET::WMState | NET::XAWMState | NET::WMVisibleName));
NET::WindowType type = window.windowType(NET::NormalMask | NET::DialogMask | NET::OverrideMask | NET::UtilityMask | NET::DesktopMask | NET::DockMask | NET::TopMenuMask | NET::SplashMask | NET::ToolbarMask | NET::MenuMask);
if ((onlyCurrentDesktop && !window.isOnDesktop(KWindowSystem::currentDesktop())) || type == NET::Desktop || type == NET::Dock || type == NET::TopMenu || type == NET::Splash || type == NET::Menu || type == NET::Toolbar || window.hasState(NET::SkipPager)) {
windows.removeAt(i);
--i;
continue;
}
++amount;
QAction *action = new QAction(QIcon(KWindowSystem::icon(windows.at(i))), window.visibleName(), this);
action->setData((unsigned long long) windows.at(i));
QString window_title = QString(action->text());
window_title.truncate(55);
action->setText(window_title);
QFont font = QFont(action->font());
if (window.isMinimized()) {
font.setItalic(true);
} else if (KWindowSystem::activeWindow() == windows.at(i)) {
font.setUnderline(true);
font.setBold(true);
}
action->setFont(font);
number = ((onlyCurrentDesktop || window.onAllDesktops()) ? 0 : window.desktop());
QList<QAction*> subList = windowList.value(number);
subList.append(action);
windowList.replace(number, subList);
}
const bool useSubMenus = (!onlyCurrentDesktop && KWindowSystem::numberOfDesktops() > 1 && (amount / KWindowSystem::numberOfDesktops()) > 5);
if (amount && useSubMenus) {
m_listMenu->addTitle(i18n("Desktops"));
}
for (int i = 0; i <= KWindowSystem::numberOfDesktops(); ++i) {
if (windowList.value(i).isEmpty()) {
continue;
}
KMenu *subMenu = NULL;
QAction *subMenuAction = NULL;
QString title = (i ? KWindowSystem::desktopName(i) : (onlyCurrentDesktop ? i18n("Current desktop") : i18n("On all desktops")));
if (useSubMenus) {
subMenuAction = m_listMenu->addAction(title);
subMenu = new KMenu(m_listMenu);
subMenu->installEventFilter(this);
} else {
m_listMenu->addTitle(title);
}
for (int j = 0; j < windowList.value(i).count(); ++j) {
if (useSubMenus) {
subMenu->addAction(windowList.value(i).value(j));
} else {
m_listMenu->addAction(windowList.value(i).value(j));
}
}
if (useSubMenus) {
subMenuAction->setMenu(subMenu);
}
}
if (!amount) {
qDeleteAll(m_listMenu->actions());
m_listMenu->clear();
QAction *noWindows = m_listMenu->addAction(i18n("No windows"));
noWindows->setEnabled(false);
}
if (formFactor() == Plasma::Vertical || formFactor() == Plasma::Horizontal) {
m_listMenu->popup(popupPosition(m_listMenu->sizeHint()));
} else {
m_listMenu->popup(QCursor::pos());
}
}
void
KWD::Decorator::handleWindowAdded (WId id)
{
QMap <WId, KWD::Window *>::ConstIterator it;
KWD::Window *client = 0;
WId select, frame = 0;
WId oframe = 0, iframe = 0;
KWD::Window::Type type = KWD::Window::Normal;
QWidgetList widgets;
QRect geometry;
/* avoid adding any of our own top level windows */
foreach (QWidget *widget, QApplication::topLevelWidgets ()) {
if (widget->winId () == id)
return;
}
if (KWD::readWindowProperty (id, Atoms::switchSelectWindow,
(long *) &select))
{
if (!mSwitcher)
mSwitcher = new Switcher (mCompositeWindow, id);
if (mSwitcher->xid () != id)
{
delete mSwitcher;
mSwitcher = new Switcher (mCompositeWindow, id);
}
geometry = mSwitcher->geometry ();
frame = None;
}
else
{
KWindowInfo wInfo;
KWD::trapXError ();
wInfo = KWindowSystem::windowInfo (id, NET::WMGeometry);
if (KWD::popXError ())
return;
if (!wInfo.valid ())
return;
KWD::readWindowProperty (id, Atoms::netInputFrameWindow, (long *) &iframe);
KWD::readWindowProperty (id, Atoms::netOutputFrameWindow, (long *) &oframe);
geometry = wInfo.geometry ();
wInfo = KWindowSystem::windowInfo (id, NET::WMWindowType, 0);
switch (wInfo.windowType (~0)) {
case NET::Normal:
case NET::Dialog:
case NET::Toolbar:
case NET::Menu:
case NET::Utility:
case NET::Splash:
case NET::Unknown:
/* decorate these window types */
break;
default:
return;
}
if (iframe)
{
type = KWD::Window::Normal;
frame = iframe;
}
else
{
type = KWD::Window::Normal2D;
frame = oframe;
}
}
KWD::trapXError ();
XSelectInput (QX11Info::display (), id,
StructureNotifyMask | PropertyChangeMask);
KWD::popXError ();
if (frame)
{
XWindowAttributes attr;
KWD::trapXError ();
XGetWindowAttributes (QX11Info::display (), frame, &attr);
if (KWD::popXError ())
frame = None;
}
if (frame)
{
if (!mClients.contains (id))
{
client = new KWD::Window (mCompositeWindow, id, frame, type,
geometry);
mClients.insert (id, client);
mFrames.insert (frame, client);
}
else
{
client = mClients[id];
mFrames.remove (client->frameId ());
mFrames.insert (frame, client);
client->updateFrame (frame);
}
if (mWindowsMenu.removeOne (id))
mClients[id]->setAppMenuAvailable ();
}
else
{
if (mClients.contains (id))
client = mClients[id];
if (client)
{
mClients.remove (client->windowId ());
mFrames.remove (client->frameId ());
delete client;
}
}
}
