X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2FWindow.cc;h=e3ecd944cc40e36ddbd5b090a2e88bfcf59ea3fa;hb=22869af55c6eba6df528e21b9edc5f905aad2690;hp=c32acbdfc738208a890185f1c2b6dcb888f853a8;hpb=3312a209d7882a32253d715ee24bcaa717af75c2;p=chaz%2Fopenbox diff --git a/src/Window.cc b/src/Window.cc index c32acbdf..e3ecd944 100644 --- a/src/Window.cc +++ b/src/Window.cc @@ -38,12 +38,15 @@ extern "C" { # include # endif // HAVE_STDIO_H #endif // DEBUG -} -#include +#ifdef HAVE_STDLIB_H + #include +#endif // HAVE_STDLIB_H +} #include "i18n.hh" #include "blackbox.hh" +#include "Clientmenu.hh" #include "Font.hh" #include "GCCache.hh" #include "Iconmenu.hh" @@ -57,6 +60,12 @@ extern "C" { #include "Slit.hh" using std::string; +using std::abs; + +// change this to change what modifier keys openbox uses for mouse bindings +// for example: Mod1Mask | ControlMask +// or: ControlMask| ShiftMask +const unsigned int ModMask = Mod1Mask; /* * Initializes the class with default values/the window's set initial values. @@ -85,21 +94,11 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { return; } - // set the eventmask early in the game so that we make sure we get - // all the events we are interested in - XSetWindowAttributes attrib_set; - attrib_set.event_mask = PropertyChangeMask | FocusChangeMask | - StructureNotifyMask; - attrib_set.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask | - ButtonMotionMask; - XChangeWindowAttributes(blackbox->getXDisplay(), client.window, - CWEventMask|CWDontPropagate, &attrib_set); - // fetch client size and placement XWindowAttributes wattrib; - if ((! XGetWindowAttributes(blackbox->getXDisplay(), - client.window, &wattrib)) || - (! wattrib.screen) || wattrib.override_redirect) { + if (! XGetWindowAttributes(blackbox->getXDisplay(), + client.window, &wattrib) || + ! wattrib.screen || wattrib.override_redirect) { #ifdef DEBUG fprintf(stderr, "BlackboxWindow::BlackboxWindow(): XGetWindowAttributes failed\n"); @@ -109,6 +108,16 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { return; } + // set the eventmask early in the game so that we make sure we get + // all the events we are interested in + XSetWindowAttributes attrib_set; + attrib_set.event_mask = PropertyChangeMask | FocusChangeMask | + StructureNotifyMask; + attrib_set.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask | + ButtonMotionMask; + XChangeWindowAttributes(blackbox->getXDisplay(), client.window, + CWEventMask|CWDontPropagate, &attrib_set); + flags.moving = flags.resizing = flags.shaded = flags.visible = flags.iconic = flags.focused = flags.stuck = flags.modal = flags.send_focus_message = flags.shaped = flags.skip_taskbar = @@ -140,10 +149,12 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { Decor_Iconify | Decor_Maximize; functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize; - client.wm_hint_flags = client.normal_hint_flags = 0; + client.normal_hint_flags = 0; client.window_group = None; client.transient_for = 0; + current_state = NormalState; + /* get the initial size and location of client window (relative to the _root window_). This position is the reference point used with the @@ -152,42 +163,31 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { client.rect.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height); client.old_bw = wattrib.border_width; - windowmenu = 0; lastButtonPressTime = 0; timer = new BTimer(blackbox, this); timer->setTimeout(blackbox->getAutoRaiseDelay()); + windowmenu = new Windowmenu(this); + + // get size, aspect, minimum/maximum size and other hints set by the + // client + if (! getBlackboxHints()) { getMWMHints(); getNetWMHints(); } - // get size, aspect, minimum/maximum size and other hints set by the - // client getWMProtocols(); getWMHints(); getWMNormalHints(); - if (client.initial_state == WithdrawnState) { - screen->getSlit()->addClient(client.window); - delete this; - return; - } - - if (isKDESystrayWindow()) { - screen->addSystrayWindow(client.window); - delete this; - return; - } - frame.window = createToplevelWindow(); - frame.plate = createChildWindow(frame.window); - associateClientWindow(); blackbox->saveWindowSearch(frame.window, this); + + frame.plate = createChildWindow(frame.window); blackbox->saveWindowSearch(frame.plate, this); - blackbox->saveWindowSearch(client.window, this); // determine if this is a transient window getTransientInfo(); @@ -197,31 +197,19 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { getWindowType(); // adjust the window decorations/behavior based on the window type + switch (window_type) { case Type_Desktop: - // desktop windows are not managed by us, we just make sure they stay on the - // bottom. - return; - case Type_Dock: - // docks (such as kicker) cannot be moved, and appear on all workspaces - functions &= ~(Func_Move); - flags.stuck = True; - case Type_Toolbar: case Type_Menu: + case Type_Toolbar: case Type_Utility: - // these windows have minimal decorations, only a titlebar, and cannot - // be resized or iconified - decorations &= ~(Decor_Maximize | Decor_Handle | Decor_Border | - Decor_Iconify); - functions &= ~(Func_Resize | Func_Maximize | Func_Iconify); - break; - case Type_Splash: - // splash screens have no functionality or decorations, they are left up - // to the application which created them + // none of these windows are decorated or manipulated by the window manager decorations = 0; functions = 0; + blackbox_attrib.workspace = 0; // we do need to belong to a workspace + flags.stuck = True; // we show up on all workspaces break; case Type_Dialog: @@ -234,6 +222,8 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { // normal windows retain all of the possible decorations and functionality break; } + + setAllowedActions(); // further adjeust the window's decorations/behavior based on window sizes if ((client.normal_hint_flags & PMinSize) && @@ -243,9 +233,16 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { decorations &= ~(Decor_Maximize | Decor_Handle); functions &= ~(Func_Resize | Func_Maximize); } - upsize(); + + if (decorations & Decor_Titlebar) + createTitlebar(); - setAllowedActions(); + if (decorations & Decor_Handle) + createHandle(); + + // apply the size and gravity hint to the frame + + upsize(); bool place_window = True; if (blackbox->isStartup() || isTransient() || @@ -260,19 +257,14 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { screen->addStrut(&client.strut); updateStrut(); - if (decorations & Decor_Titlebar) - createTitlebar(); - - if (decorations & Decor_Handle) - createHandle(); - #ifdef SHAPE - if (blackbox->hasShapeExtensions() && flags.shaped) { + if (blackbox->hasShapeExtensions() && flags.shaped) configureShape(); - } #endif // SHAPE - - windowmenu = new Windowmenu(this); + + // get the window's title before adding it to the workspace + getWMName(); + getWMIconName(); if (blackbox_attrib.workspace >= screen->getWorkspaceCount()) screen->getCurrentWorkspace()->addWindow(this, place_window); @@ -280,37 +272,62 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { screen->getWorkspace(blackbox_attrib.workspace)-> addWindow(this, place_window); + /* + the server needs to be grabbed here to prevent client's from sending + events while we are in the process of configuring their window. + We hold the grab until after we are done moving the window around. + */ + + XGrabServer(blackbox->getXDisplay()); + + associateClientWindow(); + + blackbox->saveWindowSearch(client.window, this); + if (! place_window) { // don't need to call configure if we are letting the workspace // place the window configure(frame.rect.x(), frame.rect.y(), frame.rect.width(), frame.rect.height()); + } + positionWindows(); + + XUngrabServer(blackbox->getXDisplay()); + + // now that we know where to put the window and what it should look like + // we apply the decorations + decorate(); + + grabButtons(); + + XMapSubwindows(blackbox->getXDisplay(), frame.window); + + // this ensures the title, buttons, and other decor are properly displayed + redrawWindowFrame(); + // preserve the window's initial state on first map, and its current state // across a restart - if (! getState()) { - if (client.wm_hint_flags & StateHint) - current_state = client.initial_state; - else - current_state = NormalState; - } + unsigned long initial_state = current_state; + if (! getState()) + current_state = initial_state; // get sticky state from our parent window if we've got one if (isTransient() && client.transient_for != (BlackboxWindow *) ~0ul && client.transient_for->isStuck() != flags.stuck) - stick(); + flags.stuck = True; if (flags.shaded) { flags.shaded = False; - unsigned long orig_state = current_state; + initial_state = current_state; shade(); /* At this point in the life of a window, current_state should only be set to IconicState if the window was an *icon*, not if it was shaded. */ - if (orig_state != IconicState) + if (initial_state != IconicState) current_state = NormalState; } @@ -319,27 +336,8 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { stick(); } - if (flags.maximized && (functions & Func_Maximize)) { + if (flags.maximized && (functions & Func_Maximize)) remaximize(); - } - - /* - When the window is mapped (and also when its attributes are restored), the - current_state that was set here will be used. - It is set to Normal if the window is to be mapped or it is set to Iconic - if the window is to be iconified. - *Note* that for sticky windows, the same rules apply here, they are in - fact never set to Iconic since there is no way for us to tell if a sticky - window was iconified previously. - */ - - positionWindows(); - decorate(); - grabButtons(); - - XMapSubwindows(blackbox->getXDisplay(), frame.window); - - redrawWindowFrame(); } @@ -454,15 +452,15 @@ Window BlackboxWindow::createChildWindow(Window parent, Cursor cursor) { void BlackboxWindow::associateClientWindow(void) { XSetWindowBorderWidth(blackbox->getXDisplay(), client.window, 0); - getWMName(); - getWMIconName(); XChangeSaveSet(blackbox->getXDisplay(), client.window, SetModeInsert); XSelectInput(blackbox->getXDisplay(), frame.plate, SubstructureRedirectMask); - XGrabServer(blackbox->getXDisplay()); - + /* + note we used to grab around this call to XReparentWindow however the + server is now grabbed before this method is called + */ unsigned long event_mask = PropertyChangeMask | FocusChangeMask | StructureNotifyMask; XSelectInput(blackbox->getXDisplay(), client.window, @@ -470,12 +468,9 @@ void BlackboxWindow::associateClientWindow(void) { XReparentWindow(blackbox->getXDisplay(), client.window, frame.plate, 0, 0); XSelectInput(blackbox->getXDisplay(), client.window, event_mask); - XUngrabServer(blackbox->getXDisplay()); - XRaiseWindow(blackbox->getXDisplay(), frame.plate); XMapSubwindows(blackbox->getXDisplay(), frame.plate); - #ifdef SHAPE if (blackbox->hasShapeExtensions()) { XShapeSelectInput(blackbox->getXDisplay(), client.window, @@ -837,34 +832,35 @@ void BlackboxWindow::reconfigure(void) { void BlackboxWindow::grabButtons(void) { - if ((! screen->isSloppyFocus()) || screen->doClickRaise()) + if (! screen->isSloppyFocus() || screen->doClickRaise()) // grab button 1 for changing focus/raising blackbox->grabButton(Button1, 0, frame.plate, True, ButtonPressMask, - GrabModeSync, GrabModeSync, frame.plate, None); - + GrabModeSync, GrabModeSync, frame.plate, None, + screen->allowScrollLock()); + if (functions & Func_Move) - blackbox->grabButton(Button1, Mod1Mask, frame.window, True, + blackbox->grabButton(Button1, ModMask, frame.window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, - GrabModeAsync, frame.window, - blackbox->getMoveCursor()); + GrabModeAsync, frame.window, None, + screen->allowScrollLock()); if (functions & Func_Resize) - blackbox->grabButton(Button3, Mod1Mask, frame.window, True, + blackbox->grabButton(Button3, ModMask, frame.window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, - GrabModeAsync, frame.window, None); + GrabModeAsync, frame.window, None, + screen->allowScrollLock()); // alt+middle lowers the window - blackbox->grabButton(Button2, Mod1Mask, frame.window, True, + blackbox->grabButton(Button2, ModMask, frame.window, True, ButtonReleaseMask, GrabModeAsync, GrabModeAsync, - frame.window, None); + frame.window, None, + screen->allowScrollLock()); } void BlackboxWindow::ungrabButtons(void) { - if ((! screen->isSloppyFocus()) || screen->doClickRaise()) - blackbox->ungrabButton(Button1, 0, frame.plate); - - blackbox->ungrabButton(Button1, Mod1Mask, frame.window); - blackbox->ungrabButton(Button2, Mod1Mask, frame.window); - blackbox->ungrabButton(Button3, Mod1Mask, frame.window); + blackbox->ungrabButton(Button1, 0, frame.plate); + blackbox->ungrabButton(Button1, ModMask, frame.window); + blackbox->ungrabButton(Button2, ModMask, frame.window); + blackbox->ungrabButton(Button3, ModMask, frame.window); } @@ -1060,7 +1056,6 @@ void BlackboxWindow::getWMProtocols(void) { */ void BlackboxWindow::getWMHints(void) { focus_mode = F_Passive; - client.initial_state = NormalState; // remove from current window group if (client.window_group) { @@ -1087,19 +1082,21 @@ void BlackboxWindow::getWMHints(void) { } if (wmhint->flags & StateHint) - client.initial_state = wmhint->initial_state; + current_state = wmhint->initial_state; if (wmhint->flags & WindowGroupHint) { client.window_group = wmhint->window_group; // add window to the appropriate group BWindowGroup *group = blackbox->searchGroup(client.window_group); - if (! group) // no group found, create it! - group = new BWindowGroup(blackbox, client.window_group); - group->addWindow(this); + if (! group) { // no group found, create it! + new BWindowGroup(blackbox, client.window_group); + group = blackbox->searchGroup(client.window_group); + } + if (group) + group->addWindow(this); } - client.wm_hint_flags = wmhint->flags; XFree(wmhint); } @@ -1339,17 +1336,12 @@ bool BlackboxWindow::getBlackboxHints(void) { if (blackbox_hint->flags & AttribDecoration) { switch (blackbox_hint->decoration) { case DecorNone: - // clear all decorations except close - decorations &= Decor_Close; - // clear all functions except close - functions &= Func_Close; - + decorations = 0; break; case DecorTiny: decorations |= Decor_Titlebar | Decor_Iconify; decorations &= ~(Decor_Border | Decor_Handle | Decor_Maximize); - functions |= Func_Move | Func_Iconify; functions &= ~(Func_Resize | Func_Maximize); break; @@ -1357,7 +1349,6 @@ bool BlackboxWindow::getBlackboxHints(void) { case DecorTool: decorations |= Decor_Titlebar; decorations &= ~(Decor_Iconify | Decor_Border | Decor_Handle); - functions |= Func_Move; functions &= ~(Func_Resize | Func_Maximize | Func_Iconify); break; @@ -1366,8 +1357,6 @@ bool BlackboxWindow::getBlackboxHints(void) { default: decorations |= Decor_Titlebar | Decor_Border | Decor_Handle | Decor_Iconify | Decor_Maximize; - functions |= Func_Resize | Func_Move | Func_Iconify | Func_Maximize; - break; } @@ -1383,8 +1372,7 @@ bool BlackboxWindow::getBlackboxHints(void) { void BlackboxWindow::getTransientInfo(void) { if (client.transient_for && client.transient_for != (BlackboxWindow *) ~0ul) { - // the transient for hint was removed, so we need to tell our - // previous transient_for that we are going away + // reset transient_for in preparation of looking for a new owner client.transient_for->client.transientList.remove(this); } @@ -1435,15 +1423,6 @@ void BlackboxWindow::getTransientInfo(void) { } -bool BlackboxWindow::isKDESystrayWindow(void) { - Window systray; - if (xatom->getValue(client.window, XAtom::kde_net_wm_system_tray_window_for, - XAtom::window, systray) && systray) - return True; - return False; -} - - BlackboxWindow *BlackboxWindow::getTransientFor(void) const { if (client.transient_for && client.transient_for != (BlackboxWindow*) ~0ul) @@ -1561,24 +1540,21 @@ void BlackboxWindow::configureShape(void) { bool BlackboxWindow::setInputFocus(void) { if (flags.focused) return True; - assert(! flags.iconic && - (flags.stuck || // window must be on the current workspace or sticky - blackbox_attrib.workspace == screen->getCurrentWorkspaceID())); -#if 0 - // if the window is not visible, mark the window as wanting focus rather - // than give it focus. - if (! flags.visible) { - Workspace *wkspc = screen->getWorkspace(blackbox_attrib.workspace); - wkspc->setLastFocusedWindow(this); - return True; - } -#endif - if (! frame.rect.intersects(screen->getRect())) { - // client is outside the screen, move it to the center - configure((screen->getWidth() - frame.rect.width()) / 2, - (screen->getHeight() - frame.rect.height()) / 2, - frame.rect.width(), frame.rect.height()); - } + assert(flags.stuck || // window must be on the current workspace or sticky + blackbox_attrib.workspace == screen->getCurrentWorkspaceID()); + + /* + We only do this check for normal windows and dialogs because other windows + do this on purpose, such as kde's kicker, and we don't want to go moving + it. + */ + if (window_type == Type_Normal || window_type == Type_Dialog) + if (! frame.rect.intersects(screen->getRect())) { + // client is outside the screen, move it to the center + configure((screen->getWidth() - frame.rect.width()) / 2, + (screen->getHeight() - frame.rect.height()) / 2, + frame.rect.width(), frame.rect.height()); + } if (client.transientList.size() > 0) { // transfer focus to any modal transients @@ -1592,8 +1568,6 @@ bool BlackboxWindow::setInputFocus(void) { if (focus_mode == F_LocallyActive || focus_mode == F_Passive) { XSetInputFocus(blackbox->getXDisplay(), client.window, RevertToPointerRoot, CurrentTime); - - blackbox->setFocusedWindow(this); } else { /* we could set the focus to none, since the window doesn't accept focus, * but we shouldn't set focus to nothing since this would surely make @@ -1656,6 +1630,11 @@ void BlackboxWindow::iconify(void) { setState(IconicState); screen->getWorkspace(blackbox_attrib.workspace)->removeWindow(this); + if (flags.stuck) { + for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i) + if (i != blackbox_attrib.workspace) + screen->getWorkspace(i)->removeWindow(this, True); + } if (isTransient()) { if (client.transient_for != (BlackboxWindow *) ~0ul && @@ -1689,7 +1668,7 @@ void BlackboxWindow::show(void) { XMapSubwindows(blackbox->getXDisplay(), frame.window); XMapWindow(blackbox->getXDisplay(), frame.window); -#ifdef DEBUG +#if 0 int real_x, real_y; Window child; XTranslateCoordinates(blackbox->getXDisplay(), client.window, @@ -1807,8 +1786,21 @@ void BlackboxWindow::maximize(unsigned int button) { blackbox_attrib.premax_h = client.rect.height() + frame.margin.top + frame.margin.bottom; - const Rect &screen_area = screen->availableArea(); - frame.changing = screen_area; +#ifdef XINERAMA + if (screen->isXineramaActive() && blackbox->doXineramaMaximizing()) { + // find the area to use + RectList availableAreas = screen->allAvailableAreas(); + RectList::iterator it, end = availableAreas.end(); + + for (it = availableAreas.begin(); it != end; ++it) + if (it->intersects(frame.rect)) break; + if (it == end) // the window isn't inside an area + it = availableAreas.begin(); // so just default to the first one + + frame.changing = *it; + } else +#endif // XINERAMA + frame.changing = screen->availableArea(); switch(button) { case 1: @@ -1854,6 +1846,27 @@ void BlackboxWindow::maximize(unsigned int button) { // re-maximizes the window to take into account availableArea changes void BlackboxWindow::remaximize(void) { + if (flags.shaded) { + // we only update the window's attributes otherwise we lose the shade bit + switch(flags.maximized) { + case 1: + blackbox_attrib.flags |= AttribMaxHoriz | AttribMaxVert; + blackbox_attrib.attrib |= AttribMaxHoriz | AttribMaxVert; + break; + + case 2: + blackbox_attrib.flags |= AttribMaxVert; + blackbox_attrib.attrib |= AttribMaxVert; + break; + + case 3: + blackbox_attrib.flags |= AttribMaxHoriz; + blackbox_attrib.attrib |= AttribMaxHoriz; + break; + } + return; + } + // save the original dimensions because maximize will wipe them out int premax_x = blackbox_attrib.premax_x, premax_y = blackbox_attrib.premax_y, @@ -1927,14 +1940,17 @@ void BlackboxWindow::stick(void) { blackbox_attrib.attrib ^= AttribOmnipresent; flags.stuck = False; + + for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i) + if (i != blackbox_attrib.workspace) + screen->getWorkspace(i)->removeWindow(this, True); if (! flags.iconic) screen->reassociateWindow(this, BSENTINEL, True); - else - // temporary fix since sticky windows suck. set the hint to what we - // actually hold in our data. - xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal, - blackbox_attrib.workspace); + // temporary fix since sticky windows suck. set the hint to what we + // actually hold in our data. + xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal, + blackbox_attrib.workspace); setState(current_state); } else { @@ -1947,6 +1963,10 @@ void BlackboxWindow::stick(void) { // value than that contained in the class' data. xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal, 0xffffffff); + + for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i) + if (i != blackbox_attrib.workspace) + screen->getWorkspace(i)->addWindow(this, False, True); setState(current_state); } @@ -2056,8 +2076,17 @@ void BlackboxWindow::setFocusFlag(bool focus) { else timer->stop(); } - if (isFocused()) + if (flags.focused) blackbox->setFocusedWindow(this); + + if (! flags.iconic) { + // iconic windows arent in a workspace menu! + if (flags.stuck) + screen->getCurrentWorkspace()->setFocused(this, isFocused()); + else + screen->getWorkspace(blackbox_attrib.workspace)-> + setFocused(this, flags.focused); + } } @@ -2198,8 +2227,8 @@ void BlackboxWindow::restoreAttributes(void) { current_state = NormalState; } - if (net->flags & AttribOmnipresent && net->attrib & AttribOmnipresent) { - flags.stuck = False; + if (net->flags & AttribOmnipresent && net->attrib & AttribOmnipresent && + ! flags.stuck) { stick(); // if the window was on another workspace, it was going to be hidden. this @@ -2229,6 +2258,56 @@ void BlackboxWindow::restoreAttributes(void) { blackbox_attrib.premax_h = h; } + if (net->flags & AttribDecoration) { + switch (net->decoration) { + case DecorNone: + decorations = 0; + + break; + + default: + case DecorNormal: + decorations |= Decor_Titlebar | Decor_Handle | Decor_Border | + Decor_Iconify | Decor_Maximize; + + break; + + case DecorTiny: + decorations |= Decor_Titlebar | Decor_Iconify; + decorations &= ~(Decor_Border | Decor_Handle | Decor_Maximize); + + break; + + case DecorTool: + decorations |= Decor_Titlebar; + decorations &= ~(Decor_Iconify | Decor_Border | Decor_Handle); + + break; + } + + // sanity check the new decor + if (! (functions & Func_Resize) || isTransient()) + decorations &= ~(Decor_Maximize | Decor_Handle); + if (! (functions & Func_Maximize)) + decorations &= ~Decor_Maximize; + + if (decorations & Decor_Titlebar) { + if (functions & Func_Close) // close button is controlled by function + decorations |= Decor_Close; // not decor type + } else { + if (flags.shaded) // we can not be shaded if we lack a titlebar + shade(); + } + + if (flags.visible && frame.window) { + XMapSubwindows(blackbox->getXDisplay(), frame.window); + XMapWindow(blackbox->getXDisplay(), frame.window); + } + + reconfigure(); + setState(current_state); + } + // with the state set it will then be the map event's job to read the // window's state and behave accordingly @@ -2526,9 +2605,22 @@ void BlackboxWindow::mapRequestEvent(const XMapRequestEvent *re) { default: show(); screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this); - if (! blackbox->isStartup() && (isTransient() || screen->doFocusNew())) { - XSync(blackbox->getXDisplay(), False); // make sure the frame is mapped.. - setInputFocus(); + if (isNormal()) { + if (! blackbox->isStartup()) { + XSync(blackbox->getXDisplay(), False); // make sure the frame is mapped + if (screen->doFocusNew()|| (isTransient() && getTransientFor() && + getTransientFor()->isFocused())) { + setInputFocus(); + } + if (screen->getPlacementPolicy() == BScreen::ClickMousePlacement) { + int x, y, rx, ry; + Window c, r; + unsigned int m; + XQueryPointer(blackbox->getXDisplay(), screen->getRootWindow(), + &r, &c, &rx, &ry, &x, &y, &m); + beginMove(rx, ry); + } + } } break; } @@ -2724,7 +2816,7 @@ void BlackboxWindow::configureRequestEvent(const XConfigureRequestEvent *cr) { configure(req.x(), req.y(), req.width(), req.height()); } - if (cr->value_mask & CWStackMode) { + if (cr->value_mask & CWStackMode && !isDesktop()) { switch (cr->detail) { case Below: case BottomIf: @@ -2749,7 +2841,7 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) { if (frame.maximize_button == be->window && be->button <= 3) { redrawMaximizeButton(True); - } else if (be->button == 1 || (be->button == 3 && be->state == Mod1Mask)) { + } else if (be->button == 1 || (be->button == 3 && be->state == ModMask)) { if (! flags.focused) setInputFocus(); @@ -2875,7 +2967,7 @@ void BlackboxWindow::buttonReleaseEvent(const XButtonEvent *re) { } else if (flags.resizing) { endResize(); } else if (re->window == frame.window) { - if (re->button == 2 && re->state == Mod1Mask) + if (re->button == 2 && re->state == ModMask) XUngrabPointer(blackbox->getXDisplay(), CurrentTime); } } @@ -2935,35 +3027,179 @@ void BlackboxWindow::doMove(int x_root, int y_root) { dx -= frame.border_w; dy -= frame.border_w; - const int snap_distance = screen->getEdgeSnapThreshold(); + if (screen->doWorkspaceWarping()) + if (doWorkspaceWarping(x_root, y_root, dx, dy)) + return; + + doWindowSnapping(dx, dy); + + if (screen->doOpaqueMove()) { + configure(dx, dy, frame.rect.width(), frame.rect.height()); + } else { + XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(), + screen->getOpGC(), + frame.changing.x(), + frame.changing.y(), + frame.changing.width() - 1, + frame.changing.height() - 1); + + frame.changing.setPos(dx, dy); + + XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(), + screen->getOpGC(), + frame.changing.x(), + frame.changing.y(), + frame.changing.width() - 1, + frame.changing.height() - 1); + } + + screen->showPosition(dx, dy); +} + - if (snap_distance) { - // window corners - const int wleft = dx, - wright = dx + frame.rect.width() - 1, - wtop = dy, - wbottom = dy + frame.rect.height() - 1; +bool BlackboxWindow::doWorkspaceWarping(int x_root, int y_root, + int dx, int dy) { + // workspace warping + bool warp = False; + unsigned int dest = screen->getCurrentWorkspaceID(); + if (x_root <= 0) { + warp = True; - if (screen->getWindowToWindowSnap()) { - Workspace *w = screen->getWorkspace(getWorkspaceNumber()); - assert(w); + if (dest > 0) dest--; + else dest = screen->getNumberOfWorkspaces() - 1; - // try snap to another window - for (unsigned int i = 0, c = w->getCount(); i < c; ++i) { - BlackboxWindow *snapwin = w->getWindow(i); - if (snapwin == this) - continue; // don't snap to self + } else if (x_root >= screen->getRect().right()) { + warp = True; - bool snapped = False; - - const Rect &winrect = snapwin->frameRect(); - int dleft = std::abs(wright - winrect.left()), - dright = std::abs(wleft - winrect.right()), - dtop = std::abs(wbottom - winrect.top()), - dbottom = std::abs(wtop - winrect.bottom()); + if (dest < screen->getNumberOfWorkspaces() - 1) dest++; + else dest = 0; + } + if (! warp) + return false; - if (wtop >= (signed)(winrect.y() - frame.rect.height() + 1) && - wtop < (signed)(winrect.y() + winrect.height() - 1)) { + endMove(); + bool focus = flags.focused; // had focus while moving? + if (! flags.stuck) + screen->reassociateWindow(this, dest, False); + screen->changeWorkspaceID(dest); + if (focus) + setInputFocus(); + + /* + If the XWarpPointer is done after the configure, we can end up + grabbing another window, so made sure you do it first. + */ + int dest_x; + if (x_root <= 0) { + dest_x = screen->getRect().right() - 1; + XWarpPointer(blackbox->getXDisplay(), None, + screen->getRootWindow(), 0, 0, 0, 0, + dest_x, y_root); + + configure(dx + (screen->getRect().width() - 1), dy, + frame.rect.width(), frame.rect.height()); + } else { + dest_x = 0; + XWarpPointer(blackbox->getXDisplay(), None, + screen->getRootWindow(), 0, 0, 0, 0, + dest_x, y_root); + + configure(dx - (screen->getRect().width() - 1), dy, + frame.rect.width(), frame.rect.height()); + } + + beginMove(dest_x, y_root); + return true; +} + + +void BlackboxWindow::doWindowSnapping(int &dx, int &dy) { + // how much resistance to edges to provide + const int resistance_size = screen->getResistanceSize(); + + // how far away to snap + const int snap_distance = screen->getSnapThreshold(); + + // how to snap windows + const int snap_to_windows = screen->getWindowToWindowSnap(); + const int snap_to_edges = screen->getWindowToEdgeSnap(); + // the amount of space away from the edge to provide resistance/snap + const int snap_offset = 0; + + // find the geomeetery where the moving window currently is + const Rect &moving = screen->doOpaqueMove() ? frame.rect : frame.changing; + + // window corners + const int wleft = dx - snap_offset, + wright = dx + frame.rect.width() - 1 + snap_offset, + wtop = dy - snap_offset, + wbottom = dy + frame.rect.height() - 1 + snap_offset; + + if (snap_to_windows) { + RectList rectlist; + + Workspace *w = screen->getWorkspace(getWorkspaceNumber()); + assert(w); + + // add windows on the workspace to the rect list + const BlackboxWindowList& stack_list = w->getStackingList(); + BlackboxWindowList::const_iterator st_it, st_end = stack_list.end(); + for (st_it = stack_list.begin(); st_it != st_end; ++st_it) + rectlist.push_back( (*st_it)->frameRect() ); + + // add the toolbar and the slit to the rect list. + // (only if they are not hidden) + Toolbar *tbar = screen->getToolbar(); + Slit *slit = screen->getSlit(); + Rect tbar_rect, slit_rect; + unsigned int bwidth = screen->getBorderWidth() * 2; + + if (! (screen->doHideToolbar() || tbar->isHidden())) { + tbar_rect.setRect(tbar->getX(), tbar->getY(), tbar->getWidth() + bwidth, + tbar->getHeight() + bwidth); + rectlist.push_back(tbar_rect); + } + + if (! slit->isHidden()) { + slit_rect.setRect(slit->getX(), slit->getY(), slit->getWidth() + bwidth, + slit->getHeight() + bwidth); + rectlist.push_back(slit_rect); + } + + RectList::const_iterator it, end = rectlist.end(); + for (it = rectlist.begin(); it != end; ++it) { + bool snapped = False; + const Rect &winrect = *it; + + if (snap_to_windows == BScreen::WindowResistance) + // if the window is already over top of this snap target, then + // resistance is futile, so just ignore it + if (winrect.intersects(moving)) + continue; + + int dleft, dright, dtop, dbottom; + + // if the windows are in the same plane vertically + if (wtop >= (signed)(winrect.y() - frame.rect.height() + 1) && + wtop < (signed)(winrect.y() + winrect.height() - 1)) { + + if (snap_to_windows == BScreen::WindowResistance) { + dleft = wright - winrect.left(); + dright = winrect.right() - wleft; + + // snap left of other window? + if (dleft >= 0 && dleft < resistance_size) { + dx = winrect.left() - frame.rect.width(); + snapped = True; + } + // snap right of other window? + else if (dright >= 0 && dright < resistance_size) { + dx = winrect.right() + 1; + snapped = True; + } + } else { // BScreen::WindowSnap + dleft = abs(wright - winrect.left()); + dright = abs(wleft - winrect.right()); // snap left of other window? if (dleft < snap_distance && dleft <= dright) { @@ -2974,25 +3210,61 @@ void BlackboxWindow::doMove(int x_root, int y_root) { else if (dright < snap_distance) { dx = winrect.right() + 1; snapped = True; - } + } + } - if (snapped) { - if (screen->getWindowCornerSnap()) { - // try corner-snap to its other sides - dtop = std::abs(wtop - winrect.top()); - dbottom = std::abs(wbottom - winrect.bottom()); + if (snapped) { + if (screen->getWindowCornerSnap()) { + // try corner-snap to its other sides + if (snap_to_windows == BScreen::WindowResistance) { + dtop = winrect.top() - wtop; + dbottom = wbottom - winrect.bottom(); + if (dtop > 0 && dtop < resistance_size) { + // if we're already past the top edge, then don't provide + // resistance + if (moving.top() >= winrect.top()) + dy = winrect.top(); + } else if (dbottom > 0 && dbottom < resistance_size) { + // if we're already past the bottom edge, then don't provide + // resistance + if (moving.bottom() <= winrect.bottom()) + dy = winrect.bottom() - frame.rect.height() + 1; + } + } else { // BScreen::WindowSnap + dtop = abs(wtop - winrect.top()); + dbottom = abs(wbottom - winrect.bottom()); if (dtop < snap_distance && dtop <= dbottom) dy = winrect.top(); else if (dbottom < snap_distance) dy = winrect.bottom() - frame.rect.height() + 1; } - - continue; } + + continue; } + } + + // if the windows are on the same plane horizontally + if (wleft >= (signed)(winrect.x() - frame.rect.width() + 1) && + wleft < (signed)(winrect.x() + winrect.width() - 1)) { + + if (snap_to_windows == BScreen::WindowResistance) { + dtop = wbottom - winrect.top(); + dbottom = winrect.bottom() - wtop; - if (wleft >= (signed)(winrect.x() - frame.rect.width() + 1) && - wleft < (signed)(winrect.x() + winrect.width() - 1)) { + // snap top of other window? + if (dtop >= 0 && dtop < resistance_size) { + dy = winrect.top() - frame.rect.height(); + snapped = True; + } + // snap bottom of other window? + else if (dbottom >= 0 && dbottom < resistance_size) { + dy = winrect.bottom() + 1; + snapped = True; + } + } else { // BScreen::WindowSnap + dtop = abs(wbottom - winrect.top()); + dbottom = abs(wtop - winrect.bottom()); // snap top of other window? if (dtop < snap_distance && dtop <= dbottom) { @@ -3005,88 +3277,110 @@ void BlackboxWindow::doMove(int x_root, int y_root) { snapped = True; } - if (snapped) { - if (screen->getWindowCornerSnap()) { - // try corner-snap to its other sides - dleft = std::abs(wleft - winrect.left()); - dright = std::abs(wright - winrect.right()); + } + + if (snapped) { + if (screen->getWindowCornerSnap()) { + // try corner-snap to its other sides + if (snap_to_windows == BScreen::WindowResistance) { + dleft = winrect.left() - wleft; + dright = wright - winrect.right(); + if (dleft > 0 && dleft < resistance_size) { + // if we're already past the left edge, then don't provide + // resistance + if (moving.left() >= winrect.left()) + dx = winrect.left(); + } else if (dright > 0 && dright < resistance_size) { + // if we're already past the right edge, then don't provide + // resistance + if (moving.right() <= winrect.right()) + dx = winrect.right() - frame.rect.width() + 1; + } + } else { // BScreen::WindowSnap + dleft = abs(wleft - winrect.left()); + dright = abs(wright - winrect.right()); if (dleft < snap_distance && dleft <= dright) dx = winrect.left(); else if (dright < snap_distance) dx = winrect.right() - frame.rect.width() + 1; } - - continue; } + + continue; } } } - - // try snap to the screen's available area - Rect srect = screen->availableArea(); - - int dleft = std::abs(wleft - srect.left()), - dright = std::abs(wright - srect.right()), - dtop = std::abs(wtop - srect.top()), - dbottom = std::abs(wbottom - srect.bottom()); - - // snap left? - if (dleft < snap_distance && dleft <= dright) - dx = srect.left(); - // snap right? - else if (dright < snap_distance) - dx = srect.right() - frame.rect.width() + 1; - - // snap top? - if (dtop < snap_distance && dtop <= dbottom) - dy = srect.top(); - // snap bottom? - else if (dbottom < snap_distance) - dy = srect.bottom() - frame.rect.height() + 1; - - srect = screen->getRect(); // now get the full screen - - dleft = std::abs(wleft - srect.left()), - dright = std::abs(wright - srect.right()), - dtop = std::abs(wtop - srect.top()), - dbottom = std::abs(wbottom - srect.bottom()); - - // snap left? - if (dleft < snap_distance && dleft <= dright) - dx = srect.left(); - // snap right? - else if (dright < snap_distance) - dx = srect.right() - frame.rect.width() + 1; - - // snap top? - if (dtop < snap_distance && dtop <= dbottom) - dy = srect.top(); - // snap bottom? - else if (dbottom < snap_distance) - dy = srect.bottom() - frame.rect.height() + 1; } - if (screen->doOpaqueMove()) { - configure(dx, dy, frame.rect.width(), frame.rect.height()); - } else { - XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(), - screen->getOpGC(), - frame.changing.x(), - frame.changing.y(), - frame.changing.width() - 1, - frame.changing.height() - 1); - - frame.changing.setPos(dx, dy); + if (snap_to_edges) { + RectList rectlist; + + // snap to the screen edges (and screen boundaries for xinerama) +#ifdef XINERAMA + if (screen->isXineramaActive() && blackbox->doXineramaSnapping()) { + rectlist.insert(rectlist.begin(), + screen->getXineramaAreas().begin(), + screen->getXineramaAreas().end()); + } else +#endif // XINERAMA + rectlist.push_back(screen->getRect()); + + RectList::const_iterator it, end = rectlist.end(); + for (it = rectlist.begin(); it != end; ++it) { + const Rect &srect = *it; + + if (snap_to_edges == BScreen::WindowResistance) { + // if we're not in the rectangle then don't snap to it. + if (! srect.contains(moving)) + continue; + } else { // BScreen::WindowSnap + // if we're not in the rectangle then don't snap to it. + if (! srect.intersects(Rect(wleft, wtop, frame.rect.width(), + frame.rect.height()))) + continue; + } - XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(), - screen->getOpGC(), - frame.changing.x(), - frame.changing.y(), - frame.changing.width() - 1, - frame.changing.height() - 1); + if (snap_to_edges == BScreen::WindowResistance) { + int dleft = srect.left() - wleft, + dright = wright - srect.right(), + dtop = srect.top() - wtop, + dbottom = wbottom - srect.bottom(); + + // snap left? + if (dleft > 0 && dleft < resistance_size) + dx = srect.left(); + // snap right? + else if (dright > 0 && dright < resistance_size) + dx = srect.right() - frame.rect.width() + 1; + + // snap top? + if (dtop > 0 && dtop < resistance_size) + dy = srect.top(); + // snap bottom? + else if (dbottom > 0 && dbottom < resistance_size) + dy = srect.bottom() - frame.rect.height() + 1; + } else { // BScreen::WindowSnap + int dleft = abs(wleft - srect.left()), + dright = abs(wright - srect.right()), + dtop = abs(wtop - srect.top()), + dbottom = abs(wbottom - srect.bottom()); + + // snap left? + if (dleft < snap_distance && dleft <= dright) + dx = srect.left(); + // snap right? + else if (dright < snap_distance) + dx = srect.right() - frame.rect.width() + 1; + + // snap top? + if (dtop < snap_distance && dtop <= dbottom) + dy = srect.top(); + // snap bottom? + else if (dbottom < snap_distance) + dy = srect.bottom() - frame.rect.height() + 1; + } + } } - - screen->showPosition(dx, dy); } @@ -3292,7 +3586,7 @@ void BlackboxWindow::motionNotifyEvent(const XMotionEvent *me) { } else if ((functions & Func_Resize) && (me->state & Button1Mask && (me->window == frame.right_grip || me->window == frame.left_grip)) || - (me->state & Button3Mask && me->state & Mod1Mask && + (me->state & Button3Mask && me->state & ModMask && me->window == frame.window)) { unsigned int zones = screen->getResizeZones(); Corner corner; @@ -3352,7 +3646,8 @@ void BlackboxWindow::restore(bool remap) { XSelectInput(blackbox->getXDisplay(), frame.plate, NoEventMask); // do not leave a shaded window as an icon unless it was an icon - if (flags.shaded && ! flags.iconic) setState(NormalState); + if (flags.shaded && ! flags.iconic) + setState(NormalState); restoreGravity(client.rect); @@ -3383,7 +3678,7 @@ void BlackboxWindow::timeout(void) { } -void BlackboxWindow::changeBlackboxHints(BlackboxHints *net) { +void BlackboxWindow::changeBlackboxHints(const BlackboxHints *net) { if ((net->flags & AttribShaded) && ((blackbox_attrib.attrib & AttribShaded) != (net->attrib & AttribShaded))) @@ -3429,8 +3724,7 @@ void BlackboxWindow::changeBlackboxHints(BlackboxHints *net) { if (net->flags & AttribDecoration) { switch (net->decoration) { case DecorNone: - // clear all decorations except close - decorations &= Decor_Close; + decorations = 0; break;