X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2FWindow.cc;h=e3ecd944cc40e36ddbd5b090a2e88bfcf59ea3fa;hb=22869af55c6eba6df528e21b9edc5f905aad2690;hp=99db605c5c7ff7b3710e3c5b1b8dc34d58a30832;hpb=b2e9af88862bc2c084c542fdf5cbfb5049cca1fd;p=chaz%2Fopenbox diff --git a/src/Window.cc b/src/Window.cc index 99db605c..e3ecd944 100644 --- a/src/Window.cc +++ b/src/Window.cc @@ -38,12 +38,16 @@ 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" #include "Image.hh" @@ -56,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. @@ -84,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"); @@ -108,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 = @@ -133,15 +143,18 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) { frame.fgrip_pixel = 0; frame.utitle = frame.ftitle = frame.uhandle = frame.fhandle = None; frame.ulabel = frame.flabel = frame.ubutton = frame.fbutton = None; - frame.pbutton = frame.ugrip = frame.fgrip = decorations; + frame.pbutton = frame.ugrip = frame.fgrip = None; decorations = Decor_Titlebar | Decor_Border | Decor_Handle | 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 @@ -150,46 +163,32 @@ 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); - screen->addStrut(&client.strut); - updateStrut(); - // determine if this is a transient window getTransientInfo(); @@ -198,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: @@ -235,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) && @@ -244,61 +233,38 @@ 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() || client.normal_hint_flags & (PPosition|USPosition)) { - setGravityOffsets(); + applyGravity(frame.rect); - - if (blackbox->isStartup() || - client.rect.intersects(screen->availableArea())) + if (blackbox->isStartup() || client.rect.intersects(screen->getRect())) place_window = False; } - if (decorations & Decor_Titlebar) - createTitlebar(); - - if (decorations & Decor_Handle) - createHandle(); - + // add the window's strut. note this is done *after* placing the window. + screen->addStrut(&client.strut); + updateStrut(); + #ifdef SHAPE - if (blackbox->hasShapeExtensions() && flags.shaped) { + if (blackbox->hasShapeExtensions() && flags.shaped) configureShape(); - } #endif // SHAPE - - if ((! screen->isSloppyFocus()) || screen->doClickRaise()) { - // grab button 1 for changing focus/raising - blackbox->grabButton(Button1, 0, frame.plate, True, ButtonPressMask, - GrabModeSync, GrabModeSync, None, None); - } - - if (functions & Func_Move) - blackbox->grabButton(Button1, Mod1Mask, frame.window, True, - ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, - GrabModeAsync, frame.window, - blackbox->getMoveCursor()); - blackbox->grabButton(Button2, Mod1Mask, frame.window, True, - ButtonReleaseMask, GrabModeAsync, GrabModeAsync, - None, None); - if (functions & Func_Resize) - blackbox->grabButton(Button3, Mod1Mask, frame.window, True, - ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, - GrabModeAsync, None, - blackbox->getLowerRightAngleCursor()); - - positionWindows(); - decorate(); - - if (decorations & Decor_Titlebar) - XMapSubwindows(blackbox->getXDisplay(), frame.title); - XMapSubwindows(blackbox->getXDisplay(), frame.window); - - 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); @@ -306,39 +272,63 @@ 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; + initial_state = current_state; shade(); - + /* - Because the iconic'ness of shaded windows is lost, we need to set the - state to NormalState so that shaded windows on other workspaces will not - get shown on the first workspace. 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. */ - current_state = NormalState; + if (initial_state != IconicState) + current_state = NormalState; } if (flags.stuck) { @@ -346,21 +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. - */ - - setFocusFlag(False); } @@ -443,7 +420,7 @@ Window BlackboxWindow::createToplevelWindow(void) { ButtonMotionMask | EnterWindowMask; return XCreateWindow(blackbox->getXDisplay(), screen->getRootWindow(), - -1, -1, 1, 1, frame.border_w, screen->getDepth(), + 0, 0, 1, 1, frame.border_w, screen->getDepth(), InputOutput, screen->getVisual(), create_mask, &attrib_create); } @@ -475,24 +452,25 @@ 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()); - XSelectInput(blackbox->getXDisplay(), client.window, NoEventMask); - XReparentWindow(blackbox->getXDisplay(), client.window, frame.plate, 0, 0); + /* + 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, - PropertyChangeMask | FocusChangeMask | StructureNotifyMask); - XUngrabServer(blackbox->getXDisplay()); + event_mask & ~StructureNotifyMask); + XReparentWindow(blackbox->getXDisplay(), client.window, frame.plate, 0, 0); + XSelectInput(blackbox->getXDisplay(), client.window, event_mask); XRaiseWindow(blackbox->getXDisplay(), frame.plate); XMapSubwindows(blackbox->getXDisplay(), frame.plate); - #ifdef SHAPE if (blackbox->hasShapeExtensions()) { XShapeSelectInput(blackbox->getXDisplay(), client.window, @@ -836,19 +814,15 @@ void BlackboxWindow::positionButtons(bool redecorate_label) { void BlackboxWindow::reconfigure(void) { + restoreGravity(client.rect); upsize(); - - client.rect.setPos(frame.rect.left() + frame.margin.left, - frame.rect.top() + frame.margin.top); - + applyGravity(frame.rect); positionWindows(); decorate(); + redrawWindowFrame(); - XClearWindow(blackbox->getXDisplay(), frame.window); - setFocusFlag(flags.focused); - - configure(frame.rect.x(), frame.rect.y(), - frame.rect.width(), frame.rect.height()); + ungrabButtons(); + grabButtons(); if (windowmenu) { windowmenu->move(windowmenu->getX(), frame.rect.y() + frame.title_h); @@ -857,14 +831,36 @@ void BlackboxWindow::reconfigure(void) { } -void BlackboxWindow::updateFocusModel(void) { - if ((! screen->isSloppyFocus()) || screen->doClickRaise()) { +void BlackboxWindow::grabButtons(void) { + if (! screen->isSloppyFocus() || screen->doClickRaise()) // grab button 1 for changing focus/raising blackbox->grabButton(Button1, 0, frame.plate, True, ButtonPressMask, - GrabModeSync, GrabModeSync, None, None); - } else { - blackbox->ungrabButton(Button1, 0, frame.plate); - } + GrabModeSync, GrabModeSync, frame.plate, None, + screen->allowScrollLock()); + + if (functions & Func_Move) + blackbox->grabButton(Button1, ModMask, frame.window, True, + ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, + GrabModeAsync, frame.window, None, + screen->allowScrollLock()); + if (functions & Func_Resize) + blackbox->grabButton(Button3, ModMask, frame.window, True, + ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, + GrabModeAsync, frame.window, None, + screen->allowScrollLock()); + // alt+middle lowers the window + blackbox->grabButton(Button2, ModMask, frame.window, True, + ButtonReleaseMask, GrabModeAsync, GrabModeAsync, + frame.window, None, + screen->allowScrollLock()); +} + + +void BlackboxWindow::ungrabButtons(void) { + blackbox->ungrabButton(Button1, 0, frame.plate); + blackbox->ungrabButton(Button1, ModMask, frame.window); + blackbox->ungrabButton(Button2, ModMask, frame.window); + blackbox->ungrabButton(Button3, ModMask, frame.window); } @@ -872,7 +868,8 @@ void BlackboxWindow::positionWindows(void) { XMoveResizeWindow(blackbox->getXDisplay(), frame.window, frame.rect.x(), frame.rect.y(), frame.inside_w, (flags.shaded) ? frame.title_h : frame.inside_h); - XSetWindowBorderWidth(blackbox->getXDisplay(), frame.window, frame.border_w); + XSetWindowBorderWidth(blackbox->getXDisplay(), frame.window, + frame.border_w); XSetWindowBorderWidth(blackbox->getXDisplay(), frame.plate, frame.mwm_border_w); XMoveResizeWindow(blackbox->getXDisplay(), frame.plate, @@ -881,6 +878,9 @@ void BlackboxWindow::positionWindows(void) { client.rect.width(), client.rect.height()); XMoveResizeWindow(blackbox->getXDisplay(), client.window, 0, 0, client.rect.width(), client.rect.height()); + // ensure client.rect contains the real location + client.rect.setPos(frame.rect.left() + frame.margin.left, + frame.rect.top() + frame.margin.top); if (decorations & Decor_Titlebar) { if (frame.title == None) createTitlebar(); @@ -923,6 +923,7 @@ void BlackboxWindow::positionWindows(void) { } else if (frame.handle) { destroyHandle(); } + XSync(blackbox->getXDisplay(), False); } @@ -1055,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) { @@ -1082,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); } @@ -1110,6 +1112,11 @@ void BlackboxWindow::getWMNormalHints(void) { client.min_width = client.min_height = client.width_inc = client.height_inc = 1; client.base_width = client.base_height = 0; + client.win_gravity = NorthWestGravity; +#if 0 + client.min_aspect_x = client.min_aspect_y = + client.max_aspect_x = client.max_aspect_y = 1; +#endif /* use the full screen, not the strut modified size. otherwise when the @@ -1118,11 +1125,7 @@ void BlackboxWindow::getWMNormalHints(void) { */ const Rect& screen_area = screen->getRect(); client.max_width = screen_area.width(); - client.max_height = screen_area.height(); - client.min_aspect_x = client.min_aspect_y = - client.max_aspect_x = client.max_aspect_y = 1; - client.win_gravity = NorthWestGravity; if (! XGetWMNormalHints(blackbox->getXDisplay(), client.window, &sizehint, &icccm_mask)) @@ -1131,13 +1134,22 @@ void BlackboxWindow::getWMNormalHints(void) { client.normal_hint_flags = sizehint.flags; if (sizehint.flags & PMinSize) { - client.min_width = sizehint.min_width; - client.min_height = sizehint.min_height; + if (sizehint.min_width >= 0) + client.min_width = sizehint.min_width; + if (sizehint.min_height >= 0) + client.min_height = sizehint.min_height; } if (sizehint.flags & PMaxSize) { - client.max_width = sizehint.max_width; - client.max_height = sizehint.max_height; + if (sizehint.max_width > static_cast(client.min_width)) + client.max_width = sizehint.max_width; + else + client.max_width = client.min_width; + + if (sizehint.max_height > static_cast(client.min_height)) + client.max_height = sizehint.max_height; + else + client.max_height = client.min_height; } if (sizehint.flags & PResizeInc) { @@ -1145,12 +1157,14 @@ void BlackboxWindow::getWMNormalHints(void) { client.height_inc = sizehint.height_inc; } +#if 0 // we do not support this at the moment if (sizehint.flags & PAspect) { client.min_aspect_x = sizehint.min_aspect.x; client.min_aspect_y = sizehint.min_aspect.y; client.max_aspect_x = sizehint.max_aspect.x; client.max_aspect_y = sizehint.max_aspect.y; } +#endif if (sizehint.flags & PBaseSize) { client.base_width = sizehint.base_width; @@ -1226,9 +1240,12 @@ void BlackboxWindow::getMWMHints(void) { num = PropMwmHintsElements; if (! xatom->getValue(client.window, XAtom::motif_wm_hints, XAtom::motif_wm_hints, num, - (unsigned long **)&mwm_hint) || - num < PropMwmHintsElements) + (unsigned long **)&mwm_hint)) + return; + if (num < PropMwmHintsElements) { + delete [] mwm_hint; return; + } if (mwm_hint->flags & MwmHintsDecorations) { if (mwm_hint->decorations & MwmDecorAll) { @@ -1269,7 +1286,7 @@ void BlackboxWindow::getMWMHints(void) { functions |= Func_Close; } } - delete mwm_hint; + delete [] mwm_hint; } @@ -1287,9 +1304,12 @@ bool BlackboxWindow::getBlackboxHints(void) { num = PropBlackboxHintsElements; if (! xatom->getValue(client.window, XAtom::blackbox_hints, XAtom::blackbox_hints, num, - (unsigned long **)&blackbox_hint) || - num < PropBlackboxHintsElements) + (unsigned long **)&blackbox_hint)) + return False; + if (num < PropBlackboxHintsElements) { + delete [] blackbox_hint; return False; + } if (blackbox_hint->flags & AttribShaded) flags.shaded = (blackbox_hint->attrib & AttribShaded); @@ -1316,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; @@ -1334,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; @@ -1343,15 +1357,13 @@ 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; } reconfigure(); } - delete blackbox_hint; + delete [] blackbox_hint; return True; } @@ -1360,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); } @@ -1412,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) @@ -1429,11 +1431,18 @@ BlackboxWindow *BlackboxWindow::getTransientFor(void) const { } +/* + * This function is responsible for updating both the client and the frame + * rectangles. + * According to the ICCCM a client message is not sent for a resize, only a + * move. + */ void BlackboxWindow::configure(int dx, int dy, unsigned int dw, unsigned int dh) { - bool send_event = (frame.rect.x() != dx || frame.rect.y() != dy); + bool send_event = ((frame.rect.x() != dx || frame.rect.y() != dy) && + ! flags.moving); - if ((dw != frame.rect.width()) || (dh != frame.rect.height())) { + if (dw != frame.rect.width() || dh != frame.rect.height()) { frame.rect.setRect(dx, dy, dw, dh); frame.inside_w = frame.rect.width() - (frame.border_w * 2); frame.inside_h = frame.rect.height() - (frame.border_w * 2); @@ -1454,18 +1463,22 @@ void BlackboxWindow::configure(int dx, int dy, positionWindows(); decorate(); - setFocusFlag(flags.focused); - redrawAllButtons(); + redrawWindowFrame(); } else { frame.rect.setPos(dx, dy); XMoveWindow(blackbox->getXDisplay(), frame.window, frame.rect.x(), frame.rect.y()); - + /* + we may have been called just after an opaque window move, so even though + the old coords match the new ones no ConfigureNotify has been sent yet. + There are likely other times when this will be relevant as well. + */ if (! flags.moving) send_event = True; } - if (send_event && ! flags.moving) { + if (send_event) { + // if moving, the update and event will occur when the move finishes client.rect.setPos(frame.rect.left() + frame.margin.left, frame.rect.top() + frame.margin.top); @@ -1483,10 +1496,10 @@ void BlackboxWindow::configure(int dx, int dy, event.xconfigure.above = frame.window; event.xconfigure.override_redirect = False; - XSendEvent(blackbox->getXDisplay(), client.window, True, - NoEventMask, &event); - + XSendEvent(blackbox->getXDisplay(), client.window, False, + StructureNotifyMask, &event); screen->updateNetizenConfigNotify(&event); + XFlush(blackbox->getXDisplay()); } } @@ -1527,22 +1540,21 @@ void BlackboxWindow::configureShape(void) { bool BlackboxWindow::setInputFocus(void) { if (flags.focused) return True; - assert(! flags.iconic); - - // 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; - } + assert(flags.stuck || // window must be on the current workspace or sticky + blackbox_attrib.workspace == screen->getCurrentWorkspaceID()); - if (! client.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()); - } + /* + 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 @@ -1556,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 @@ -1580,6 +1590,7 @@ bool BlackboxWindow::setInputFocus(void) { ce.xclient.data.l[4] = 0l; XSendEvent(blackbox->getXDisplay(), client.window, False, NoEventMask, &ce); + XFlush(blackbox->getXDisplay()); } return ret; @@ -1603,11 +1614,13 @@ void BlackboxWindow::iconify(void) { * split second, leaving us with a ghost window... so, we need to do this * while the X server is grabbed */ + unsigned long event_mask = PropertyChangeMask | FocusChangeMask | + StructureNotifyMask; XGrabServer(blackbox->getXDisplay()); - XSelectInput(blackbox->getXDisplay(), client.window, NoEventMask); - XUnmapWindow(blackbox->getXDisplay(), client.window); XSelectInput(blackbox->getXDisplay(), client.window, - PropertyChangeMask | FocusChangeMask | StructureNotifyMask); + event_mask & ~StructureNotifyMask); + XUnmapWindow(blackbox->getXDisplay(), client.window); + XSelectInput(blackbox->getXDisplay(), client.window, event_mask); XUngrabServer(blackbox->getXDisplay()); XUnmapWindow(blackbox->getXDisplay(), frame.window); @@ -1617,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 && @@ -1635,6 +1653,7 @@ void BlackboxWindow::iconify(void) { if (! (*it)->flags.iconic) (*it)->iconify(); } } + screen->updateStackingList(); } @@ -1648,13 +1667,24 @@ void BlackboxWindow::show(void) { XMapWindow(blackbox->getXDisplay(), client.window); XMapSubwindows(blackbox->getXDisplay(), frame.window); XMapWindow(blackbox->getXDisplay(), frame.window); + +#if 0 + int real_x, real_y; + Window child; + XTranslateCoordinates(blackbox->getXDisplay(), client.window, + screen->getRootWindow(), + 0, 0, &real_x, &real_y, &child); + fprintf(stderr, "%s -- assumed: (%d, %d), real: (%d, %d)\n", getTitle(), + client.rect.left(), client.rect.top(), real_x, real_y); + assert(client.rect.left() == real_x && client.rect.top() == real_y); +#endif } void BlackboxWindow::deiconify(bool reassoc, bool raise) { if (flags.iconic || reassoc) screen->reassociateWindow(this, BSENTINEL, False); - else if (blackbox_attrib.workspace != screen->getCurrentWorkspace()->getID()) + else if (blackbox_attrib.workspace != screen->getCurrentWorkspaceID()) return; show(); @@ -1685,6 +1715,7 @@ void BlackboxWindow::close(void) { ce.xclient.data.l[3] = 0l; ce.xclient.data.l[4] = 0l; XSendEvent(blackbox->getXDisplay(), client.window, False, NoEventMask, &ce); + XFlush(blackbox->getXDisplay()); } @@ -1703,10 +1734,12 @@ void BlackboxWindow::withdraw(void) { XGrabServer(blackbox->getXDisplay()); - XSelectInput(blackbox->getXDisplay(), client.window, NoEventMask); - XUnmapWindow(blackbox->getXDisplay(), client.window); + unsigned long event_mask = PropertyChangeMask | FocusChangeMask | + StructureNotifyMask; XSelectInput(blackbox->getXDisplay(), client.window, - PropertyChangeMask | FocusChangeMask | StructureNotifyMask); + event_mask & ~StructureNotifyMask); + XUnmapWindow(blackbox->getXDisplay(), client.window); + XSelectInput(blackbox->getXDisplay(), client.window, event_mask); XUngrabServer(blackbox->getXDisplay()); @@ -1741,7 +1774,7 @@ void BlackboxWindow::maximize(unsigned int button) { blackbox_attrib.premax_x = blackbox_attrib.premax_y = 0; blackbox_attrib.premax_w = blackbox_attrib.premax_h = 0; - redrawAllButtons(); + redrawAllButtons(); // in case it is not called in configure() setState(current_state); return; } @@ -1753,9 +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; - constrain(TopLeft); +#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: @@ -1780,6 +1825,8 @@ void BlackboxWindow::maximize(unsigned int button) { break; } + constrain(TopLeft); + if (flags.shaded) { blackbox_attrib.flags ^= AttribShaded; blackbox_attrib.attrib ^= AttribShaded; @@ -1792,13 +1839,34 @@ void BlackboxWindow::maximize(unsigned int button) { frame.changing.width(), frame.changing.height()); if (flags.focused) screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this); - redrawAllButtons(); + redrawAllButtons(); // in case it is not called in configure() setState(current_state); } // 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, @@ -1820,6 +1888,14 @@ void BlackboxWindow::remaximize(void) { void BlackboxWindow::setWorkspace(unsigned int n) { blackbox_attrib.flags |= AttribWorkspace; blackbox_attrib.workspace = n; + if (n == BSENTINEL) { // iconified window + /* + we set the workspace to 'all workspaces' so that taskbars will show the + window. otherwise, it made uniconifying a window imposible without the + blackbox workspace menu + */ + n = 0xffffffff; + } xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal, n); } @@ -1839,7 +1915,7 @@ void BlackboxWindow::shade(void) { frame.margin.bottom); } else { if (! (decorations & Decor_Titlebar)) - return; + return; // can't shade it without a titlebar! XResizeWindow(blackbox->getXDisplay(), frame.window, frame.inside_w, frame.title_h); @@ -1864,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 { @@ -1884,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); } @@ -1900,13 +1983,7 @@ void BlackboxWindow::stick(void) { } -void BlackboxWindow::setFocusFlag(bool focus) { - // only focus a window if it is visible - if (focus && !flags.visible) - return; - - flags.focused = focus; - +void BlackboxWindow::redrawWindowFrame(void) const { if (decorations & Decor_Titlebar) { if (flags.focused) { if (frame.ftitle) @@ -1982,23 +2059,43 @@ void BlackboxWindow::setFocusFlag(bool focus) { XSetWindowBorder(blackbox->getXDisplay(), frame.plate, frame.uborder_pixel); } - - if (screen->isSloppyFocus() && screen->doAutoRaise()) { - if (isFocused()) timer->start(); - else timer->stop(); - } - - if (isFocused()) - blackbox->setFocusedWindow(this); } -void BlackboxWindow::installColormap(bool install) { - int i = 0, ncmap = 0; +void BlackboxWindow::setFocusFlag(bool focus) { + // only focus a window if it is visible + if (focus && !flags.visible) + return; + + flags.focused = focus; + + redrawWindowFrame(); + + if (screen->isSloppyFocus() && screen->doAutoRaise()) { + if (isFocused()) timer->start(); + else timer->stop(); + } + + 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); + } +} + + +void BlackboxWindow::installColormap(bool install) { + int i = 0, ncmap = 0; Colormap *cmaps = XListInstalledColormaps(blackbox->getXDisplay(), client.window, &ncmap); - XWindowAttributes wattrib; if (cmaps) { + XWindowAttributes wattrib; if (XGetWindowAttributes(blackbox->getXDisplay(), client.window, &wattrib)) { if (install) { @@ -2099,26 +2196,25 @@ void BlackboxWindow::restoreAttributes(void) { (unsigned long **)&net)) return; if (num < PropBlackboxAttributesElements) { - delete net; + delete [] net; return; } if (net->flags & AttribShaded && net->attrib & AttribShaded) { flags.shaded = False; + unsigned long orig_state = current_state; shade(); /* - Because the iconic'ness of shaded windows is lost, we need to set the - state to NormalState so that shaded windows on other workspaces will not - get shown on the first workspace. 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. */ - current_state = NormalState; + if (orig_state != IconicState) + current_state = WithdrawnState; } - if ((net->workspace != screen->getCurrentWorkspaceID()) && - (net->workspace < screen->getWorkspaceCount())) + if (net->workspace != screen->getCurrentWorkspaceID() && + net->workspace < screen->getWorkspaceCount()) screen->reassociateWindow(this, net->workspace, True); if ((blackbox_attrib.workspace != screen->getCurrentWorkspaceID()) && @@ -2131,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 @@ -2162,88 +2258,188 @@ void BlackboxWindow::restoreAttributes(void) { blackbox_attrib.premax_h = h; } - // with the state set it will then be the map events job to read the window's - // state and behave accordingly + 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; - delete net; + 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 + + delete [] net; } /* - * Positions the frame according the the client window position and window - * gravity. + * Positions the Rect r according the the client window position and + * window gravity. */ -void BlackboxWindow::setGravityOffsets(void) { - // x coordinates for each gravity type - const int x_west = client.rect.x(); - const int x_east = client.rect.right() - frame.inside_w + 1; - const int x_center = client.rect.left() + - ((client.rect.width() - frame.rect.width()) / 2); - // y coordinates for each gravity type - const int y_north = client.rect.y(); - const int y_south = client.rect.bottom() - frame.inside_h + 1; - const int y_center = client.rect.top() + - ((client.rect.height() - frame.rect.height()) / 2); +void BlackboxWindow::applyGravity(Rect &r) { + // apply horizontal window gravity + switch (client.win_gravity) { + default: + case NorthWestGravity: + case SouthWestGravity: + case WestGravity: + r.setX(client.rect.x()); + break; + + case NorthGravity: + case SouthGravity: + case CenterGravity: + r.setX(client.rect.x() - (frame.margin.left + frame.margin.right) / 2); + break; + + case NorthEastGravity: + case SouthEastGravity: + case EastGravity: + r.setX(client.rect.x() - frame.margin.left - frame.margin.right + 2); + break; + case ForgetGravity: + case StaticGravity: + r.setX(client.rect.x() - frame.margin.left); + break; + } + + // apply vertical window gravity switch (client.win_gravity) { default: - case NorthWestGravity: frame.rect.setPos(x_west, y_north); break; - case NorthGravity: frame.rect.setPos(x_center, y_north); break; - case NorthEastGravity: frame.rect.setPos(x_east, y_north); break; - case SouthWestGravity: frame.rect.setPos(x_west, y_south); break; - case SouthGravity: frame.rect.setPos(x_center, y_south); break; - case SouthEastGravity: frame.rect.setPos(x_east, y_south); break; - case WestGravity: frame.rect.setPos(x_west, y_center); break; - case CenterGravity: frame.rect.setPos(x_center, y_center); break; - case EastGravity: frame.rect.setPos(x_east, y_center); break; + case NorthWestGravity: + case NorthEastGravity: + case NorthGravity: + r.setY(client.rect.y()); + break; + + case CenterGravity: + case EastGravity: + case WestGravity: + r.setY(client.rect.y() - (frame.margin.top + frame.margin.bottom) / 2); + break; + + case SouthWestGravity: + case SouthEastGravity: + case SouthGravity: + r.setY(client.rect.y() - frame.margin.top - frame.margin.bottom + 2); + break; case ForgetGravity: case StaticGravity: - frame.rect.setPos(client.rect.x() - frame.margin.left, - client.rect.y() - frame.margin.top); + r.setY(client.rect.y() - frame.margin.top); break; } } /* - * The reverse of the setGravityOffsets function. Uses the frame window's - * position to find the window's reference point. + * The reverse of the applyGravity function. + * + * Positions the Rect r according to the frame window position and + * window gravity. */ -void BlackboxWindow::restoreGravity(void) { - // x coordinates for each gravity type - const int x_west = frame.rect.x(); - const int x_east = frame.rect.x() + frame.inside_w - client.rect.width(); - const int x_center = frame.rect.x() - - ((client.rect.width() - frame.rect.width()) / 2); - // y coordinates for each gravity type - const int y_north = frame.rect.y(); - const int y_south = frame.rect.y() + frame.inside_h - client.rect.height(); - const int y_center = frame.rect.y() - - ((client.rect.height() - frame.rect.height()) / 2); - - switch(client.win_gravity) { +void BlackboxWindow::restoreGravity(Rect &r) { + // restore horizontal window gravity + switch (client.win_gravity) { default: - case NorthWestGravity: client.rect.setPos(x_west, y_north); break; - case NorthGravity: client.rect.setPos(x_center, y_north); break; - case NorthEastGravity: client.rect.setPos(x_east, y_north); break; - case SouthWestGravity: client.rect.setPos(x_west, y_south); break; - case SouthGravity: client.rect.setPos(x_center, y_south); break; - case SouthEastGravity: client.rect.setPos(x_east, y_south); break; - case WestGravity: client.rect.setPos(x_west, y_center); break; - case CenterGravity: client.rect.setPos(x_center, y_center); break; - case EastGravity: client.rect.setPos(x_east, y_center); break; + case NorthWestGravity: + case SouthWestGravity: + case WestGravity: + r.setX(frame.rect.x()); + break; + + case NorthGravity: + case SouthGravity: + case CenterGravity: + r.setX(frame.rect.x() + (frame.margin.left + frame.margin.right) / 2); + break; + + case NorthEastGravity: + case SouthEastGravity: + case EastGravity: + r.setX(frame.rect.x() + frame.margin.left + frame.margin.right - 2); + break; case ForgetGravity: case StaticGravity: - client.rect.setPos(frame.rect.left() + frame.margin.left, - frame.rect.top() + frame.margin.top); + r.setX(frame.rect.x() + frame.margin.left); + break; + } + + // restore vertical window gravity + switch (client.win_gravity) { + default: + case NorthWestGravity: + case NorthEastGravity: + case NorthGravity: + r.setY(frame.rect.y()); + break; + + case CenterGravity: + case EastGravity: + case WestGravity: + r.setY(frame.rect.y() + (frame.margin.top + frame.margin.bottom) / 2); + break; + + case SouthWestGravity: + case SouthEastGravity: + case SouthGravity: + r.setY(frame.rect.y() + frame.margin.top + frame.margin.bottom - 2); + break; + + case ForgetGravity: + case StaticGravity: + r.setY(frame.rect.y() + frame.margin.top); break; } } -void BlackboxWindow::redrawLabel(void) { +void BlackboxWindow::redrawLabel(void) const { if (flags.focused) { if (frame.flabel) XSetWindowBackgroundPixmap(blackbox->getXDisplay(), @@ -2263,31 +2459,23 @@ void BlackboxWindow::redrawLabel(void) { WindowStyle *style = screen->getWindowStyle(); - int pos = frame.bevel_w * 2, - dlen = style->doJustify(client.title.c_str(), pos, frame.label_w, - frame.bevel_w * 4, i18n.multibyte()); - - BPen pen((flags.focused) ? style->l_text_focus : style->l_text_unfocus, - style->font); - if (i18n.multibyte()) - XmbDrawString(blackbox->getXDisplay(), frame.label, style->fontset, - pen.gc(), pos, - (1 - style->fontset_extents->max_ink_extent.y), - client.title.c_str(), dlen); - else - XDrawString(blackbox->getXDisplay(), frame.label, pen.gc(), pos, - (style->font->ascent + 1), client.title.c_str(), dlen); + int pos = frame.bevel_w * 2; + style->doJustify(client.title.c_str(), pos, frame.label_w, frame.bevel_w * 4); + style->font->drawString(frame.label, pos, 1, + (flags.focused ? style->l_text_focus : + style->l_text_unfocus), + client.title); } -void BlackboxWindow::redrawAllButtons(void) { +void BlackboxWindow::redrawAllButtons(void) const { if (frame.iconify_button) redrawIconifyButton(False); if (frame.maximize_button) redrawMaximizeButton(flags.maximized); if (frame.close_button) redrawCloseButton(False); } -void BlackboxWindow::redrawIconifyButton(bool pressed) { +void BlackboxWindow::redrawIconifyButton(bool pressed) const { if (! pressed) { if (flags.focused) { if (frame.fbutton) @@ -2321,7 +2509,7 @@ void BlackboxWindow::redrawIconifyButton(bool pressed) { } -void BlackboxWindow::redrawMaximizeButton(bool pressed) { +void BlackboxWindow::redrawMaximizeButton(bool pressed) const { if (! pressed) { if (flags.focused) { if (frame.fbutton) @@ -2357,7 +2545,7 @@ void BlackboxWindow::redrawMaximizeButton(bool pressed) { } -void BlackboxWindow::redrawCloseButton(bool pressed) { +void BlackboxWindow::redrawCloseButton(bool pressed) const { if (! pressed) { if (flags.focused) { if (frame.fbutton) @@ -2393,7 +2581,7 @@ void BlackboxWindow::redrawCloseButton(bool pressed) { } -void BlackboxWindow::mapRequestEvent(XMapRequestEvent *re) { +void BlackboxWindow::mapRequestEvent(const XMapRequestEvent *re) { if (re->window != client.window) return; @@ -2417,16 +2605,29 @@ void BlackboxWindow::mapRequestEvent(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; } } -void BlackboxWindow::unmapNotifyEvent(XUnmapEvent *ue) { +void BlackboxWindow::unmapNotifyEvent(const XUnmapEvent *ue) { if (ue->window != client.window) return; @@ -2439,7 +2640,7 @@ void BlackboxWindow::unmapNotifyEvent(XUnmapEvent *ue) { } -void BlackboxWindow::destroyNotifyEvent(XDestroyWindowEvent *de) { +void BlackboxWindow::destroyNotifyEvent(const XDestroyWindowEvent *de) { if (de->window != client.window) return; @@ -2452,7 +2653,7 @@ void BlackboxWindow::destroyNotifyEvent(XDestroyWindowEvent *de) { } -void BlackboxWindow::reparentNotifyEvent(XReparentEvent *re) { +void BlackboxWindow::reparentNotifyEvent(const XReparentEvent *re) { if (re->window != client.window || re->parent == frame.plate) return; @@ -2468,8 +2669,16 @@ void BlackboxWindow::reparentNotifyEvent(XReparentEvent *re) { } -void BlackboxWindow::propertyNotifyEvent(Atom atom) { - switch(atom) { +void BlackboxWindow::propertyNotifyEvent(const XPropertyEvent *pe) { + if (pe->state == PropertyDelete) + return; + +#ifdef DEBUG + fprintf(stderr, "BlackboxWindow::propertyNotifyEvent(): for 0x%lx\n", + client.window); +#endif + + switch(pe->atom) { case XA_WM_CLASS: case XA_WM_CLIENT_MACHINE: case XA_WM_COMMAND: @@ -2514,14 +2723,21 @@ void BlackboxWindow::propertyNotifyEvent(Atom atom) { if ((client.normal_hint_flags & PMinSize) && (client.normal_hint_flags & PMaxSize)) { + // the window now can/can't resize itself, so the buttons need to be + // regrabbed. + ungrabButtons(); if (client.max_width <= client.min_width && client.max_height <= client.min_height) { decorations &= ~(Decor_Maximize | Decor_Handle); functions &= ~(Func_Resize | Func_Maximize); } else { - decorations |= Decor_Maximize | Decor_Handle; - functions |= Func_Resize | Func_Maximize; + if (! isTransient()) { + decorations |= Decor_Maximize | Decor_Handle; + functions |= Func_Maximize; + } + functions |= Func_Resize; } + grabButtons(); setAllowedActions(); } @@ -2536,7 +2752,7 @@ void BlackboxWindow::propertyNotifyEvent(Atom atom) { } default: - if (atom == xatom->getAtom(XAtom::wm_protocols)) { + if (pe->atom == xatom->getAtom(XAtom::wm_protocols)) { getWMProtocols(); if ((decorations & Decor_Close) && (! frame.close_button)) { @@ -2547,7 +2763,7 @@ void BlackboxWindow::propertyNotifyEvent(Atom atom) { } if (windowmenu) windowmenu->reconfigure(); } - } else if (atom == xatom->getAtom(XAtom::net_wm_strut)) { + } else if (pe->atom == xatom->getAtom(XAtom::net_wm_strut)) { updateStrut(); } @@ -2556,7 +2772,11 @@ void BlackboxWindow::propertyNotifyEvent(Atom atom) { } -void BlackboxWindow::exposeEvent(XExposeEvent *ee) { +void BlackboxWindow::exposeEvent(const XExposeEvent *ee) { +#ifdef DEBUG + fprintf(stderr, "BlackboxWindow::exposeEvent() for 0x%lx\n", client.window); +#endif + if (frame.label == ee->window && (decorations & Decor_Titlebar)) redrawLabel(); else if (frame.close_button == ee->window) @@ -2568,32 +2788,35 @@ void BlackboxWindow::exposeEvent(XExposeEvent *ee) { } -void BlackboxWindow::configureRequestEvent(XConfigureRequestEvent *cr) { +void BlackboxWindow::configureRequestEvent(const XConfigureRequestEvent *cr) { if (cr->window != client.window || flags.iconic) return; - int cx = frame.rect.x(), cy = frame.rect.y(); - unsigned int cw = frame.rect.width(), ch = frame.rect.height(); - if (cr->value_mask & CWBorderWidth) client.old_bw = cr->border_width; - if (cr->value_mask & CWX) - cx = cr->x - frame.margin.left; + if (cr->value_mask & (CWX | CWY | CWWidth | CWHeight)) { + Rect req = frame.rect; - if (cr->value_mask & CWY) - cy = cr->y - frame.margin.top; + if (cr->value_mask & (CWX | CWY)) { + if (cr->value_mask & CWX) + client.rect.setX(cr->x); + if (cr->value_mask & CWY) + client.rect.setY(cr->y); + + applyGravity(req); + } - if (cr->value_mask & CWWidth) - cw = cr->width + frame.margin.left + frame.margin.right; + if (cr->value_mask & CWWidth) + req.setWidth(cr->width + frame.margin.left + frame.margin.right); - if (cr->value_mask & CWHeight) - ch = cr->height + frame.margin.top + frame.margin.bottom; + if (cr->value_mask & CWHeight) + req.setHeight(cr->height + frame.margin.top + frame.margin.bottom); - if (frame.rect != Rect(cx, cy, cw, ch)) - configure(cx, cy, cw, ch); + 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: @@ -2610,10 +2833,15 @@ void BlackboxWindow::configureRequestEvent(XConfigureRequestEvent *cr) { } -void BlackboxWindow::buttonPressEvent(XButtonEvent *be) { - if (frame.maximize_button == be->window) { +void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) { +#ifdef DEBUG + fprintf(stderr, "BlackboxWindow::buttonPressEvent() for 0x%lx\n", + client.window); +#endif + + 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(); @@ -2631,7 +2859,7 @@ void BlackboxWindow::buttonPressEvent(XButtonEvent *be) { if (frame.title == be->window || frame.label == be->window) { if (((be->time - lastButtonPressTime) <= blackbox->getDoubleClickInterval()) || - (be->state & ControlMask)) { + (be->state == ControlMask)) { lastButtonPressTime = 0; shade(); } else { @@ -2649,84 +2877,87 @@ void BlackboxWindow::buttonPressEvent(XButtonEvent *be) { } else if (windowmenu && be->button == 3 && (frame.title == be->window || frame.label == be->window || frame.handle == be->window || frame.window == be->window)) { - int mx = 0, my = 0; - - if (frame.title == be->window || frame.label == be->window) { - mx = be->x_root - (windowmenu->getWidth() / 2); - my = frame.rect.y() + frame.title_h + frame.border_w; - } else if (frame.handle == be->window) { - mx = be->x_root - (windowmenu->getWidth() / 2); - my = frame.rect.bottom() - frame.handle_h - (frame.border_w * 3) - - windowmenu->getHeight(); + if (windowmenu->isVisible()) { + windowmenu->hide(); } else { - mx = be->x_root - (windowmenu->getWidth() / 2); - - if (be->y <= static_cast(frame.bevel_w)) - my = frame.rect.y() + frame.title_h; - else - my = be->y_root - (windowmenu->getHeight() / 2); - } - - // snap the window menu into a corner if necessary - we check the - // position of the menu with the coordinates of the client to - // make the comparisions easier. - // XXX: this needs some work! - if (mx > client.rect.right() - - static_cast(windowmenu->getWidth())) - mx = frame.rect.right() - windowmenu->getWidth() - frame.border_w + 1; - if (mx < client.rect.left()) - mx = frame.rect.x(); - - if (my > client.rect.bottom() - - static_cast(windowmenu->getHeight())) - my = frame.rect.bottom() - windowmenu->getHeight() - frame.border_w + 1; - if (my < client.rect.top()) - my = frame.rect.y() + ((decorations & Decor_Titlebar) ? - frame.title_h : 0); - - if (windowmenu) { - if (! windowmenu->isVisible()) { - windowmenu->move(mx, my); - windowmenu->show(); - XRaiseWindow(blackbox->getXDisplay(), windowmenu->getWindowID()); - XRaiseWindow(blackbox->getXDisplay(), - windowmenu->getSendToMenu()->getWindowID()); - } else { - windowmenu->hide(); - } + int mx = be->x_root - windowmenu->getWidth() / 2, + my = be->y_root - windowmenu->getHeight() / 2; + + // snap the window menu into a corner/side if necessary + int left_edge, right_edge, top_edge, bottom_edge; + + /* + the " + (frame.border_w * 2) - 1" bits are to get the proper width + and height of the menu, as the sizes returned by it do not include + the borders. + */ + left_edge = frame.rect.x(); + right_edge = frame.rect.right() - + (windowmenu->getWidth() + (frame.border_w * 2) - 1); + top_edge = client.rect.top() - (frame.border_w + frame.mwm_border_w); + bottom_edge = client.rect.bottom() - + (windowmenu->getHeight() + (frame.border_w * 2) - 1) + + (frame.border_w + frame.mwm_border_w); + + if (mx < left_edge) + mx = left_edge; + if (mx > right_edge) + mx = right_edge; + if (my < top_edge) + my = top_edge; + if (my > bottom_edge) + my = bottom_edge; + + windowmenu->move(mx, my); + windowmenu->show(); + XRaiseWindow(blackbox->getXDisplay(), windowmenu->getWindowID()); + XRaiseWindow(blackbox->getXDisplay(), + windowmenu->getSendToMenu()->getWindowID()); } // mouse wheel up } else if (be->button == 4) { if ((be->window == frame.label || - be->window == frame.title) && + be->window == frame.title || + be->window == frame.maximize_button || + be->window == frame.iconify_button || + be->window == frame.close_button) && ! flags.shaded) shade(); // mouse wheel down } else if (be->button == 5) { if ((be->window == frame.label || - be->window == frame.title) && + be->window == frame.title || + be->window == frame.maximize_button || + be->window == frame.iconify_button || + be->window == frame.close_button) && flags.shaded) shade(); } } -void BlackboxWindow::buttonReleaseEvent(XButtonEvent *re) { - if (re->window == frame.maximize_button) { +void BlackboxWindow::buttonReleaseEvent(const XButtonEvent *re) { +#ifdef DEBUG + fprintf(stderr, "BlackboxWindow::buttonReleaseEvent() for 0x%lx\n", + client.window); +#endif + + if (re->window == frame.maximize_button && + re->button >= 1 && re->button <= 3) { if ((re->x >= 0 && re->x <= static_cast(frame.button_w)) && (re->y >= 0 && re->y <= static_cast(frame.button_w))) { maximize(re->button); } else { redrawMaximizeButton(flags.maximized); } - } else if (re->window == frame.iconify_button) { + } else if (re->window == frame.iconify_button && re->button == 1) { if ((re->x >= 0 && re->x <= static_cast(frame.button_w)) && (re->y >= 0 && re->y <= static_cast(frame.button_w))) { iconify(); } else { redrawIconifyButton(False); } - } else if (re->window == frame.close_button) { + } else if (re->window == frame.close_button & re->button == 1) { if ((re->x >= 0 && re->x <= static_cast(frame.button_w)) && (re->y >= 0 && re->y <= static_cast(frame.button_w))) close(); @@ -2736,12 +2967,13 @@ void BlackboxWindow::buttonReleaseEvent(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); } } + void BlackboxWindow::beginMove(int x_root, int y_root) { assert(! (flags.resizing || flags.moving)); @@ -2795,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); +} + + +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 (dest > 0) dest--; + else dest = screen->getNumberOfWorkspaces() - 1; + + } else if (x_root >= screen->getRect().right()) { + warp = True; + + if (dest < screen->getNumberOfWorkspaces() - 1) dest++; + else dest = 0; + } + if (! warp) + return false; + + 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(); - if (snap_distance) { - // window corners - const int wleft = dx, - wright = dx + frame.rect.width() - 1, - wtop = dy, - wbottom = dy + frame.rect.height() - 1; + // how far away to snap + const int snap_distance = screen->getSnapThreshold(); - if (screen->getWindowToWindowSnap()) { - Workspace *w = screen->getWorkspace(getWorkspaceNumber()); - assert(w); + // 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; - // 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 + // find the geomeetery where the moving window currently is + const Rect &moving = screen->doOpaqueMove() ? frame.rect : frame.changing; - 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()); + // 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 (wtop >= (signed)(winrect.y() - frame.rect.height() + 1) && - wtop < (signed)(winrect.y() + winrect.height() - 1)) { + 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) { @@ -2834,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 (wleft >= (signed)(winrect.x() - frame.rect.width() + 1) && - wleft < (signed)(winrect.x() + winrect.width() - 1)) { + // 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; + + // 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) { @@ -2865,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 && dright < dleft) - 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 && dbottom < dtop) - 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 && dright < dleft) - 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 && dbottom < dtop) - 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); } @@ -3029,6 +3463,7 @@ void BlackboxWindow::beginResize(int x_root, int y_root, Corner dir) { default: assert(false); // unhandled Corner + return; // unreachable, for the compiler } XGrabServer(blackbox->getXDisplay()); @@ -3067,29 +3502,30 @@ void BlackboxWindow::doResize(int x_root, int y_root) { Corner anchor; switch (resize_dir) { - case BottomLeft: - anchor = TopRight; - frame.changing.setSize(frame.rect.width() - (x_root - frame.grab_x), - frame.rect.height() + (y_root - frame.grab_y)); - break; - case BottomRight: - anchor = TopLeft; - frame.changing.setSize(frame.rect.width() + (x_root - frame.grab_x), - frame.rect.height() + (y_root - frame.grab_y)); - break; - case TopLeft: - anchor = BottomRight; - frame.changing.setSize(frame.rect.width() - (x_root - frame.grab_x), - frame.rect.height() - (y_root - frame.grab_y)); - break; - case TopRight: - anchor = BottomLeft; - frame.changing.setSize(frame.rect.width() + (x_root - frame.grab_x), - frame.rect.height() - (y_root - frame.grab_y)); - break; + case BottomLeft: + anchor = TopRight; + frame.changing.setSize(frame.rect.width() - (x_root - frame.grab_x), + frame.rect.height() + (y_root - frame.grab_y)); + break; + case BottomRight: + anchor = TopLeft; + frame.changing.setSize(frame.rect.width() + (x_root - frame.grab_x), + frame.rect.height() + (y_root - frame.grab_y)); + break; + case TopLeft: + anchor = BottomRight; + frame.changing.setSize(frame.rect.width() - (x_root - frame.grab_x), + frame.rect.height() - (y_root - frame.grab_y)); + break; + case TopRight: + anchor = BottomLeft; + frame.changing.setSize(frame.rect.width() + (x_root - frame.grab_x), + frame.rect.height() - (y_root - frame.grab_y)); + break; - default: - assert(false); // unhandled Corner + default: + assert(false); // unhandled Corner + return; // unreachable, for the compiler } constrain(anchor, &gw, &gh); @@ -3132,25 +3568,47 @@ void BlackboxWindow::endResize(void) { } -void BlackboxWindow::motionNotifyEvent(XMotionEvent *me) { +void BlackboxWindow::motionNotifyEvent(const XMotionEvent *me) { +#ifdef DEBUG + fprintf(stderr, "BlackboxWindow::motionNotifyEvent() for 0x%lx\n", + client.window); +#endif + if (flags.moving) { doMove(me->x_root, me->y_root); } else if (flags.resizing) { doResize(me->x_root, me->y_root); } else { - if (! flags.resizing && (me->state & Button1Mask) && - (functions & Func_Move) && + if (!flags.resizing && me->state & Button1Mask && (functions & Func_Move) && (frame.title == me->window || frame.label == me->window || frame.handle == me->window || frame.window == me->window)) { beginMove(me->x_root, me->y_root); } else if ((functions & Func_Resize) && - (((me->state & Button1Mask) && - (me->window == frame.right_grip || - me->window == frame.left_grip)) || - (me->state & (Mod1Mask | Button3Mask) && - me->window == frame.window))) { - beginResize(me->x_root, me->y_root, - (me->window == frame.left_grip) ? BottomLeft : BottomRight); + (me->state & Button1Mask && (me->window == frame.right_grip || + me->window == frame.left_grip)) || + (me->state & Button3Mask && me->state & ModMask && + me->window == frame.window)) { + unsigned int zones = screen->getResizeZones(); + Corner corner; + + if (me->window == frame.left_grip) { + corner = BottomLeft; + } else if (me->window == frame.right_grip || zones == 1) { + corner = BottomRight; + } else { + bool top; + bool left = (me->x_root - frame.rect.x() <= + static_cast(frame.rect.width() / 2)); + if (zones == 2) + top = False; + else // (zones == 4) + top = (me->y_root - frame.rect.y() <= + static_cast(frame.rect.height() / 2)); + corner = (top ? (left ? TopLeft : TopRight) : + (left ? BottomLeft : BottomRight)); + } + + beginResize(me->x_root, me->y_root, corner); } } } @@ -3187,7 +3645,11 @@ void BlackboxWindow::restore(bool remap) { XSelectInput(blackbox->getXDisplay(), client.window, NoEventMask); XSelectInput(blackbox->getXDisplay(), frame.plate, NoEventMask); - restoreGravity(); + // do not leave a shaded window as an icon unless it was an icon + if (flags.shaded && ! flags.iconic) + setState(NormalState); + + restoreGravity(client.rect); XUnmapWindow(blackbox->getXDisplay(), frame.window); XUnmapWindow(blackbox->getXDisplay(), client.window); @@ -3216,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))) @@ -3262,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; @@ -3308,7 +3769,7 @@ void BlackboxWindow::changeBlackboxHints(BlackboxHints *net) { if (flags.shaded && ! (decorations & Decor_Titlebar)) shade(); - if (frame.window) { + if (flags.visible && frame.window) { XMapSubwindows(blackbox->getXDisplay(), frame.window); XMapWindow(blackbox->getXDisplay(), frame.window); } @@ -3342,12 +3803,7 @@ void BlackboxWindow::upsize(void) { // the height of the titlebar is based upon the height of the font being // used to display the window's title WindowStyle *style = screen->getWindowStyle(); - if (i18n.multibyte()) - frame.title_h = (style->fontset_extents->max_ink_extent.height + - (frame.bevel_w * 2) + 2); - else - frame.title_h = (style->font->ascent + style->font->descent + - (frame.bevel_w * 2) + 2); + frame.title_h = style->font->height() + (frame.bevel_w * 2) + 2; frame.label_h = frame.title_h - (frame.bevel_w * 2); frame.button_w = (frame.label_h - 2); @@ -3437,8 +3893,18 @@ void BlackboxWindow::constrain(Corner anchor, int *pw, int *ph) { dh -= base_height; dh /= client.height_inc; - if (pw) *pw = dw; - if (ph) *ph = dh; + if (pw) { + if (client.width_inc == 1) + *pw = dw + base_width; + else + *pw = dw; + } + if (ph) { + if (client.height_inc == 1) + *ph = dh + base_height; + else + *ph = dh; + } dw *= client.width_inc; dw += base_width; @@ -3480,21 +3946,14 @@ void BlackboxWindow::constrain(Corner anchor, int *pw, int *ph) { } -int WindowStyle::doJustify(const char *text, int &start_pos, - unsigned int max_length, unsigned int modifier, - bool multibyte) const { - size_t text_len = strlen(text); +void WindowStyle::doJustify(const std::string &text, int &start_pos, + unsigned int max_length, + unsigned int modifier) const { + size_t text_len = text.size(); unsigned int length; do { - if (multibyte) { - XRectangle ink, logical; - XmbTextExtents(fontset, text, text_len, &ink, &logical); - length = logical.width; - } else { - length = XTextWidth(font, text, text_len); - } - length += modifier; + length = font->measureString(string(text, 0, text_len)) + modifier; } while (length > max_length && text_len-- > 0); switch (justify) { @@ -3510,8 +3969,6 @@ int WindowStyle::doJustify(const char *text, int &start_pos, default: break; } - - return text_len; } @@ -3524,16 +3981,8 @@ BWindowGroup::BWindowGroup(Blackbox *b, Window _group) return; } - /* - watch for destroy notify on the group window (in addition to - any other events we are looking for) - - since some managed windows can also be window group controllers, - we need to make sure that we don't clobber the event mask for the - managed window - */ XSelectInput(blackbox->getXDisplay(), group, - wattrib.your_event_mask | StructureNotifyMask); + PropertyChangeMask | FocusChangeMask | StructureNotifyMask); blackbox->saveGroupSearch(group, this); }