// Window.cc for Fluxbox Window Manager // Copyright (c) 2001 - 2002 Henrik Kinnunen (fluxgen@linuxmail.org) // // Window.cc for Blackbox - an X11 Window manager // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net) // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the "Software"), // to deal in the Software without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Software, and to permit persons to whom the // Software is furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. // $Id: Window.cc,v 1.99 2002/11/17 11:29:06 fluxgen Exp $ #include "Window.hh" #include "i18n.hh" #include "fluxbox.hh" #include "Iconmenu.hh" #include "Screen.hh" #include "Toolbar.hh" #include "Windowmenu.hh" #include "StringUtil.hh" #include "Netizen.hh" #ifdef HAVE_CONFIG_H #include "config.h" #endif // HAVE_CONFIG_H #ifdef SLIT #include "Slit.hh" #endif // SLIT //use GNU extensions #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif // _GNU_SOURCE #include #include #include #include #include using namespace std; FluxboxWindow::FluxboxWindow(Window w, BScreen *s): m_hintsig(*this), m_statesig(*this), m_workspacesig(*this), image_ctrl(0), moving(false), resizing(false), shaded(false), maximized(false), visible(false), iconic(false), transient(false), focused(false), stuck(false), modal(false), send_focus_message(false), managed(false), screen(0), timer(this), display(0), lastButtonPressTime(0), m_windowmenu(0), m_layer(LAYER_NORMAL), tab(0) { lastFocusTime.tv_sec = lastFocusTime.tv_usec = 0; #ifdef DEBUG fprintf(stderr, I18n::instance()-> getMessage( FBNLS::WindowSet, FBNLS::WindowCreating, "FluxboxWindow::FluxboxWindow(): creating 0x%lx\n"), w); #endif //DEBUG Fluxbox *fluxbox = Fluxbox::instance(); display = fluxbox->getXDisplay(); blackbox_attrib.workspace = workspace_number = window_number = -1; blackbox_attrib.flags = blackbox_attrib.attrib = blackbox_attrib.stack = 0l; blackbox_attrib.premax_x = blackbox_attrib.premax_y = 0; blackbox_attrib.premax_w = blackbox_attrib.premax_h = 0; //use tab as default decorations.tab = true; client.window = w; frame.window = frame.plate = frame.title = frame.handle = None; frame.right_grip = frame.left_grip = None; frame.utitle = frame.ftitle = frame.uhandle = frame.fhandle = None; frame.ulabel = frame.flabel = frame.ubutton = frame.fbutton = None; frame.pbutton = frame.ugrip = frame.fgrip = None; //get decorations vector dir = fluxbox->getTitlebarLeft(); for (char c=0; c<2; c++) { for (unsigned int i=0; igetTitlebarRight(); } decorations.menu = true; //override menu option decorations.titlebar = decorations.border = decorations.handle = true; functions.resize = functions.move = functions.iconify = functions.maximize = true; functions.close = decorations.close = false; client.wm_hint_flags = client.normal_hint_flags = 0; client.transient_for = 0; client.mwm_hint = (MwmHints *) 0; client.blackbox_hint = 0; fluxbox->grab(); if (! validateClient()) return; // fetch client size and placement XWindowAttributes wattrib; if ((! XGetWindowAttributes(display, client.window, &wattrib)) || (! wattrib.screen) || wattrib.override_redirect) { fluxbox->ungrab(); return; } if (s) screen = s; else screen = fluxbox->searchScreen(RootWindowOfScreen(wattrib.screen)); if (!screen) { fluxbox->ungrab(); return; } image_ctrl = screen->getImageControl(); client.x = wattrib.x; client.y = wattrib.y; client.width = wattrib.width; client.height = wattrib.height; client.old_bw = wattrib.border_width; timer.setTimeout(fluxbox->getAutoRaiseDelay()); timer.fireOnce(true); getBlackboxHints(); if (! client.blackbox_hint) getMWMHints(); // get size, aspect, minimum/maximum size and other hints set by the // client getWMProtocols(); getWMHints(); getWMNormalHints(); #ifdef SLIT if (client.initial_state == WithdrawnState) { screen->getSlit()->addClient(client.window); fluxbox->ungrab(); return; } #endif // SLIT managed = true; //mark for usage fluxbox->saveWindowSearch(client.window, this); // determine if this is a transient window checkTransient(); // adjust the window decorations based on transience and window sizes if (transient) { decorations.maximize = functions.maximize = false; decorations.handle = decorations.border = false; } if ((client.normal_hint_flags & PMinSize) && (client.normal_hint_flags & PMaxSize) && client.max_width != 0 && client.max_width <= client.min_width && client.max_height != 0 && client.max_height <= client.min_height) { decorations.maximize = decorations.handle = functions.resize = functions.maximize = false; decorations.tab = false; //no tab for this window } upsize(); bool place_window = true; if (fluxbox->isStartup() || transient || client.normal_hint_flags & (PPosition|USPosition)) { setGravityOffsets(); if (! fluxbox->isStartup()) { #ifdef XINERAMA unsigned int head = 0; if (screen->hasXinerama()) { head = screen->getHead(frame.x, frame.y); } #endif // XINERAMA int real_x = frame.x; int real_y = frame.y; if (decorations.tab) { if (screen->getTabPlacement() == Tab::PTOP) { real_y -= screen->getTabHeight(); } else if (screen->getTabPlacement() == Tab::PLEFT) { real_x -= (screen->isTabRotateVertical()) ? screen->getTabHeight() : screen->getTabWidth(); } } #ifdef XINERAMA // check is within the current head, so it won't overlap heads if (real_x >= screen->getHeadX(head) && real_y + frame.y_border >= screen->getHeadY(head) && (real_x + frame.width) <= (screen->getHeadX(head) + screen->getHeadWidth(head)) && (real_y + frame.height) <= (screen->getHeadY(head) + screen->getHeadHeight(head)) ) place_window = false; #else // !XINERAMA if (real_x >= 0 && real_y + frame.y_border >= 0 && real_x <= (signed) screen->getWidth() && real_y <= (signed) screen->getHeight()) place_window = false; #endif // XIENRAMA } else place_window = false; } frame.window = createToplevelWindow(frame.x, frame.y, frame.width, frame.height, screen->getBorderWidth()); //create frame window fluxbox->saveWindowSearch(frame.window, this); //save frame window frame.plate = createChildWindow(frame.window); //Create plate window fluxbox->saveWindowSearch(frame.plate, this); //save plate window createTitlebar(); createHandle(); associateClientWindow(); grabButtons(); positionWindows(); // use tab? and don't create a tab on windows that's not // maximizable as default (such as dialogs) if (decorations.tab && fluxbox->useTabs() && isGroupable()) tab = new Tab(this, 0, 0); decorate(); XRaiseWindow(display, frame.plate); XMapSubwindows(display, frame.plate); if (decorations.titlebar) XMapSubwindows(display, frame.title); XMapSubwindows(display, frame.window); if (decorations.menu) { std::auto_ptr tmp(new Windowmenu(*this)); m_windowmenu = tmp; } if (workspace_number < 0 || workspace_number >= screen->getCount()) screen->getCurrentWorkspace()->addWindow(this, place_window); else screen->getWorkspace(workspace_number)->addWindow(this, place_window); configure(frame.x, frame.y, frame.width, frame.height); if (shaded) { shaded = false; shade(); } if (maximized && functions.maximize) { int m = maximized; maximized = false; maximize(m); } if (stuck) { stuck = false; stick(); deiconify(); //omnipresent, so show it } setFocusFlag(false); #ifdef DEBUG fprintf(stderr, "%s(%d): FluxboxWindow(this=%p)\n", __FILE__, __LINE__, this); #endif // DEBUG fluxbox->ungrab(); } FluxboxWindow::~FluxboxWindow() { if (screen == 0) //the window wasn't created return; timer.stop(); Fluxbox *fluxbox = Fluxbox::instance(); if (moving || resizing) { screen->hideGeometry(); XUngrabPointer(display, CurrentTime); } if (!iconic) { Workspace *workspace = screen->getWorkspace(workspace_number); if (workspace) workspace->removeWindow(this); } else //it's iconic screen->removeIcon(this); if (tab != 0) { delete tab; tab = 0; } if (client.mwm_hint != 0) { XFree(client.mwm_hint); client.mwm_hint = 0; } if (client.blackbox_hint != 0) { XFree(client.blackbox_hint); client.blackbox_hint = 0; } if (client.transient_for != 0) { if (client.transient_for == this) { client.transient_for = 0; } fluxbox->setFocusedWindow(client.transient_for); if (client.transient_for) { client.transient_for->client.transients.remove(this); client.transient_for->setInputFocus(); client.transient_for = 0; } } while (!client.transients.empty()) { client.transients.back()->client.transient_for = 0; client.transients.pop_back(); } if (client.window_group) { fluxbox->removeGroupSearch(client.window_group); client.window_group = 0; } destroyTitlebar(); destroyHandle(); if (frame.fbutton) { image_ctrl->removeImage(frame.fbutton); frame.fbutton = 0; } if (frame.ubutton) { image_ctrl->removeImage(frame.ubutton); frame.ubutton = 0; } if (frame.pbutton) { image_ctrl->removeImage(frame.pbutton); frame.pbutton = 0; } if (frame.plate) { fluxbox->removeWindowSearch(frame.plate); XDestroyWindow(display, frame.plate); frame.plate = 0; } if (frame.window) { fluxbox->removeWindowSearch(frame.window); XDestroyWindow(display, frame.window); frame.window = 0; } fluxbox->removeWindowSearch(client.window); #ifdef DEBUG cerr<<__FILE__<<"("<<__LINE__<<"): ~FluxboxWindow("<colormap(); attrib_create.override_redirect = True; attrib_create.event_mask = ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask; return (XCreateWindow(display, screen->getRootWindow(), x, y, width, height, borderwidth, screen->getDepth(), InputOutput, screen->getVisual(), create_mask, &attrib_create)); } Window FluxboxWindow::createChildWindow(Window parent, Cursor cursor) { XSetWindowAttributes attrib_create; unsigned long create_mask = CWBackPixmap | CWBorderPixel | CWEventMask; attrib_create.background_pixmap = None; attrib_create.event_mask = ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | ExposureMask | EnterWindowMask | LeaveWindowMask; if (cursor) { create_mask |= CWCursor; attrib_create.cursor = cursor; } return (XCreateWindow(display, parent, 0, 0, 1, 1, 0, screen->getDepth(), InputOutput, screen->getVisual(), create_mask, &attrib_create)); } void FluxboxWindow::associateClientWindow() { XSetWindowBorderWidth(display, client.window, 0); getWMName(); getWMIconName(); XChangeSaveSet(display, client.window, SetModeInsert); XSetWindowAttributes attrib_set; XSelectInput(display, frame.plate, NoEventMask); XReparentWindow(display, client.window, frame.plate, 0, 0); XSelectInput(display, frame.plate, SubstructureRedirectMask); XFlush(display); attrib_set.event_mask = PropertyChangeMask | StructureNotifyMask | FocusChangeMask; attrib_set.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask | ButtonMotionMask; XChangeWindowAttributes(display, client.window, CWEventMask|CWDontPropagate, &attrib_set); #ifdef SHAPE if (Fluxbox::instance()->hasShapeExtensions()) { XShapeSelectInput(display, client.window, ShapeNotifyMask); int foo; unsigned int ufoo; XShapeQueryExtents(display, client.window, &frame.shaped, &foo, &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo); if (frame.shaped) { XShapeCombineShape(display, frame.window, ShapeBounding, frame.mwm_border_w, frame.y_border + frame.mwm_border_w, client.window, ShapeBounding, ShapeSet); int num = 1; XRectangle xrect[2]; xrect[0].x = xrect[0].y = 0; xrect[0].width = frame.width; xrect[0].height = frame.y_border; if (decorations.handle) { xrect[1].x = 0; xrect[1].y = frame.y_handle; xrect[1].width = frame.width; xrect[1].height = frame.handle_h + screen->getBorderWidth(); num++; } XShapeCombineRectangles(display, frame.window, ShapeBounding, 0, 0, xrect, num, ShapeUnion, Unsorted); } } #endif // SHAPE //create the buttons if (decorations.iconify) createButton(Fluxbox::MINIMIZE, FluxboxWindow::iconifyPressed_cb, FluxboxWindow::iconifyButton_cb, FluxboxWindow::iconifyDraw_cb); if (decorations.maximize) createButton(Fluxbox::MAXIMIZE, FluxboxWindow::maximizePressed_cb, FluxboxWindow::maximizeButton_cb, FluxboxWindow::maximizeDraw_cb); if (decorations.close) createButton(Fluxbox::CLOSE, FluxboxWindow::closePressed_cb, FluxboxWindow::closeButton_cb, FluxboxWindow::closeDraw_cb); if (decorations.sticky) createButton(Fluxbox::STICK, FluxboxWindow::stickyPressed_cb, FluxboxWindow::stickyButton_cb, FluxboxWindow::stickyDraw_cb); if (decorations.menu)//TODO createButton(Fluxbox::MENU, 0, 0, 0); if (decorations.shade) createButton(Fluxbox::SHADE, 0, FluxboxWindow::shadeButton_cb, FluxboxWindow::shadeDraw_cb); if (frame.ubutton) { for (unsigned int i=0; idecorate(); Pixmap tmp = frame.fbutton; FbTk::Texture *texture = &(screen->getWindowStyle()->b_focus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.fbutton = None; frame.fbutton_pixel = texture->color().pixel(); } else frame.fbutton = image_ctrl->renderImage(frame.button_w, frame.button_h, texture); if (tmp) image_ctrl->removeImage(tmp); tmp = frame.ubutton; texture = &(screen->getWindowStyle()->b_unfocus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.ubutton = None; frame.ubutton_pixel = texture->color().pixel(); } else frame.ubutton = image_ctrl->renderImage(frame.button_w, frame.button_h, texture); if (tmp) image_ctrl->removeImage(tmp); tmp = frame.pbutton; texture = &(screen->getWindowStyle()->b_pressed); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.pbutton = None; frame.pbutton_pixel = texture->color().pixel(); } else frame.pbutton = image_ctrl->renderImage(frame.button_w, frame.button_h, texture); if (tmp) image_ctrl->removeImage(tmp); if (decorations.titlebar) { tmp = frame.ftitle; texture = &(screen->getWindowStyle()->t_focus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.ftitle = None; frame.ftitle_pixel = texture->color().pixel(); } else frame.ftitle = image_ctrl->renderImage(frame.width, frame.title_h, texture); if (tmp) image_ctrl->removeImage(tmp); tmp = frame.utitle; texture = &(screen->getWindowStyle()->t_unfocus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.utitle = None; frame.utitle_pixel = texture->color().pixel(); } else frame.utitle = image_ctrl->renderImage(frame.width, frame.title_h, texture); if (tmp) image_ctrl->removeImage(tmp); XSetWindowBorder(display, frame.title, screen->getBorderColor()->pixel()); decorateLabel(); } if (decorations.border) { frame.fborder_pixel = screen->getWindowStyle()->f_focus.pixel(); frame.uborder_pixel = screen->getWindowStyle()->f_unfocus.pixel(); } if (decorations.handle) { tmp = frame.fhandle; texture = &(screen->getWindowStyle()->h_focus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.fhandle = None; frame.fhandle_pixel = texture->color().pixel(); } else frame.fhandle = image_ctrl->renderImage(frame.width, frame.handle_h, texture); if (tmp) image_ctrl->removeImage(tmp); tmp = frame.uhandle; texture = &(screen->getWindowStyle()->h_unfocus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.uhandle = None; frame.uhandle_pixel = texture->color().pixel(); } else frame.uhandle = image_ctrl->renderImage(frame.width, frame.handle_h, texture); if (tmp) image_ctrl->removeImage(tmp); tmp = frame.fgrip; texture = &(screen->getWindowStyle()->g_focus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.fgrip = None; frame.fgrip_pixel = texture->color().pixel(); } else frame.fgrip = image_ctrl->renderImage(frame.grip_w, frame.grip_h, texture); if (tmp) image_ctrl->removeImage(tmp); tmp = frame.ugrip; texture = &(screen->getWindowStyle()->g_unfocus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.ugrip = None; frame.ugrip_pixel = texture->color().pixel(); } else frame.ugrip = image_ctrl->renderImage(frame.grip_w, frame.grip_h, texture); if (tmp) image_ctrl->removeImage(tmp); XSetWindowBorder(display, frame.handle, screen->getBorderColor()->pixel()); XSetWindowBorder(display, frame.left_grip, screen->getBorderColor()->pixel()); XSetWindowBorder(display, frame.right_grip, screen->getBorderColor()->pixel()); } XSetWindowBorder(display, frame.window, screen->getBorderColor()->pixel()); } void FluxboxWindow::decorateLabel() { Pixmap tmp = frame.flabel; FbTk::Texture *texture = &(screen->getWindowStyle()->l_focus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.flabel = None; frame.flabel_pixel = texture->color().pixel(); } else frame.flabel = image_ctrl->renderImage(frame.label_w, frame.label_h, texture); if (tmp) image_ctrl->removeImage(tmp); tmp = frame.ulabel; texture = &(screen->getWindowStyle()->l_unfocus); if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { frame.ulabel = None; frame.ulabel_pixel = texture->color().pixel(); } else frame.ulabel = image_ctrl->renderImage(frame.label_w, frame.label_h, texture); if (tmp) image_ctrl->removeImage(tmp); } void FluxboxWindow::grabButtons() { Fluxbox *fluxbox = Fluxbox::instance(); XGrabButton(display, Button1, AnyModifier, frame.plate, True, ButtonPressMask, GrabModeSync, GrabModeSync, None, None); XUngrabButton(display, Button1, Mod1Mask|Mod2Mask|Mod3Mask, frame.plate); XGrabButton(display, Button1, Mod1Mask, frame.window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, fluxbox->getMoveCursor()); //----grab with "all" modifiers grabButton(display, Button1, frame.window, fluxbox->getMoveCursor()); XGrabButton(display, Button2, Mod1Mask, frame.window, True, ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None); XGrabButton(display, Button3, Mod1Mask, frame.window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, fluxbox->getLowerRightAngleCursor()); //---grab with "all" modifiers grabButton(display, Button3, frame.window, fluxbox->getLowerRightAngleCursor()); } void FluxboxWindow::createButton(int type, ButtonEventProc pressed, ButtonEventProc released, ButtonDrawProc draw) { Button b; b.win = createChildWindow(frame.title); Fluxbox::instance()->saveWindowSearch(b.win, this); b.type = type; b.used = true; b.draw = draw; b.pressed = pressed; b.released = released; buttonlist.push_back(b); } Window FluxboxWindow::findTitleButton(int type) { for (unsigned int i=0; istick(); FluxboxWindow::stickyDraw_cb(t, be->window, false); } void FluxboxWindow::stickyPressed_cb(FluxboxWindow *t, XButtonEvent *be) { FluxboxWindow::stickyDraw_cb(t, be->window, true); } void FluxboxWindow::iconifyButton_cb(FluxboxWindow *t, XButtonEvent *be) { t->iconify(); FluxboxWindow::iconifyDraw_cb(t, be->window, false); } void FluxboxWindow::iconifyPressed_cb(FluxboxWindow *t, XButtonEvent *be) { t->screen->getWorkspace(t->workspace_number)->lowerWindow(t); FluxboxWindow::iconifyDraw_cb(t, be->window, true); } void FluxboxWindow::maximizeButton_cb(FluxboxWindow *t, XButtonEvent *be) { FluxboxWindow::maximizeDraw_cb(t, be->window, false); t->maximize(be->button); } void FluxboxWindow::maximizePressed_cb(FluxboxWindow *t, XButtonEvent *be) { FluxboxWindow::maximizeDraw_cb(t, be->window, true); } void FluxboxWindow::closeButton_cb(FluxboxWindow *t, XButtonEvent *be) { t->close(); FluxboxWindow::closeDraw_cb(t, be->window, false); } void FluxboxWindow::closePressed_cb(FluxboxWindow *t, XButtonEvent *be) { FluxboxWindow::closeDraw_cb(t, be->window, true); } void FluxboxWindow::shadeButton_cb(FluxboxWindow *t, XButtonEvent *be) { FluxboxWindow::shadeDraw_cb(t, be->window, false); t->shade(); if (t->tab) t->tab->shade(); } void FluxboxWindow::stickyDraw_cb(FluxboxWindow *t, Window w, bool pressed) { t->drawButtonBase(w, pressed); if (t->stuck) { XFillRectangle(t->display, w, ((t->focused) ? t->screen->getWindowStyle()->b_pic_focus_gc : t->screen->getWindowStyle()->b_pic_unfocus_gc), t->frame.button_w/2-t->frame.button_w/4, t->frame.button_h/2-t->frame.button_h/4, t->frame.button_w/2, t->frame.button_h/2); } else { XFillRectangle(t->display, w, ((t->focused) ? t->screen->getWindowStyle()->b_pic_focus_gc : t->screen->getWindowStyle()->b_pic_unfocus_gc), t->frame.button_w/2, t->frame.button_h/2, t->frame.button_w/5, t->frame.button_h/5); } } void FluxboxWindow::iconifyDraw_cb(FluxboxWindow *t, Window w, bool pressed) { t->drawButtonBase(w, pressed); XDrawRectangle(t->display, w, ((t->focused) ? t->screen->getWindowStyle()->b_pic_focus_gc : t->screen->getWindowStyle()->b_pic_unfocus_gc), 2, t->frame.button_h - 5, t->frame.button_w - 5, 2); } void FluxboxWindow::maximizeDraw_cb(FluxboxWindow *t, Window w, bool pressed) { t->drawButtonBase(w, pressed); XDrawRectangle(t->display, w, ((t->focused) ? t->screen->getWindowStyle()->b_pic_focus_gc : t->screen->getWindowStyle()->b_pic_unfocus_gc), 2, 2, t->frame.button_w - 5, t->frame.button_h - 5); XDrawLine(t->display, w, ((t->focused) ? t->screen->getWindowStyle()->b_pic_focus_gc : t->screen->getWindowStyle()->b_pic_unfocus_gc), 2, 3, t->frame.button_w - 3, 3); } void FluxboxWindow::closeDraw_cb(FluxboxWindow *t, Window w, bool pressed) { t->drawButtonBase(w, pressed); XDrawLine(t->display, w, ((t->focused) ? t->screen->getWindowStyle()->b_pic_focus_gc : t->screen->getWindowStyle()->b_pic_unfocus_gc), 2, 2, t->frame.button_w - 3, t->frame.button_h - 3); XDrawLine(t->display, w, ((t->focused) ? t->screen->getWindowStyle()->b_pic_focus_gc : t->screen->getWindowStyle()->b_pic_unfocus_gc), 2, t->frame.button_h - 3, t->frame.button_w - 3, 2); } void FluxboxWindow::shadeDraw_cb(FluxboxWindow *t, Window w, bool pressed) { t->drawButtonBase(w, pressed); } void FluxboxWindow::grabButton(Display *display, unsigned int button, Window window, Cursor cursor) { //numlock XGrabButton(display, button, Mod1Mask|Mod2Mask, window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, cursor); //scrolllock XGrabButton(display, button, Mod1Mask|Mod5Mask, window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, cursor); //capslock XGrabButton(display, button, Mod1Mask|LockMask, window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, cursor); //capslock+numlock XGrabButton(display, Button1, Mod1Mask|LockMask|Mod2Mask, window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, cursor); //capslock+scrolllock XGrabButton(display, button, Mod1Mask|LockMask|Mod5Mask, window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, cursor); //capslock+numlock+scrolllock XGrabButton(display, button, Mod1Mask|LockMask|Mod2Mask|Mod5Mask, window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, cursor); //numlock+scrollLock XGrabButton(display, button, Mod1Mask|Mod2Mask|Mod5Mask, window, True, ButtonReleaseMask | ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, cursor); } void FluxboxWindow::drawButtonBase(Window w, bool pressed) { if (! pressed) { if (focused) { if (frame.fbutton) XSetWindowBackgroundPixmap(display, w, frame.fbutton); else XSetWindowBackground(display, w, frame.fbutton_pixel); } else { if (frame.ubutton) XSetWindowBackgroundPixmap(display, w, frame.ubutton); else XSetWindowBackground(display, w, frame.ubutton_pixel); } } else { if (frame.pbutton) XSetWindowBackgroundPixmap(display, w, frame.pbutton); else XSetWindowBackground(display, w, frame.pbutton_pixel); } XClearWindow(display, w); } void FluxboxWindow::positionButtons(bool redecorate_label) { unsigned int bw = frame.button_w + frame.bevel_w + 1, by = frame.bevel_w + 1, lx = by, lw = frame.width - by; Fluxbox *fluxbox = Fluxbox::instance(); vector left = fluxbox->getTitlebarLeft(); vector right = fluxbox->getTitlebarRight(); //left side buttons for (unsigned int i=0; i=0; i--) { Window w = findTitleButton(right[i]); //get window of button if (w) { XMoveResizeWindow(display, w, bx, by, frame.button_w, frame.button_h); XMapWindow(display, w); XClearWindow(display, w); bx -= bw; lw -= bw; } } //Draw the label frame.label_w = lw - by; XMoveResizeWindow(display, frame.label, lx, frame.bevel_w, frame.label_w, frame.label_h); if (redecorate_label) decorateLabel(); if (tab) { tab->setPosition(); tab->draw(false); } redrawLabel(); redrawAllButtons(); } void FluxboxWindow::reconfigure() { upsize(); if (Fluxbox::instance()->useTabs()) { //no tab and we allowed to use tab? then create it if (!tab && isGroupable()) { tab = new Tab(this, 0, 0); if (current_state == IconicState) tab->iconify(); else if (current_state == WithdrawnState) tab->withdraw(); } } else { if (tab != 0) { //got a tab? then destroy it delete tab; tab = 0; } } client.x = frame.x + frame.mwm_border_w + screen->getBorderWidth(); client.y = frame.y + frame.y_border + frame.mwm_border_w + screen->getBorderWidth(); if (getTitle().size() > 0) { client.title_text_w = screen->getWindowStyle()->font.textWidth(getTitle().c_str(), getTitle().size()); client.title_text_w += (frame.bevel_w * 4); } positionWindows(); decorate(); XClearWindow(display, frame.window); setFocusFlag(focused); configure(frame.x, frame.y, frame.width, frame.height); grabButtons(); if (m_windowmenu.get()) { m_windowmenu->move(m_windowmenu->x(), frame.y + frame.title_h); m_windowmenu->reconfigure(); } } void FluxboxWindow::positionWindows() { XResizeWindow(display, frame.window, frame.width, ((shaded) ? frame.title_h : frame.height)); XSetWindowBorderWidth(display, frame.window, screen->getBorderWidth()); XSetWindowBorderWidth(display, frame.plate, screen->getFrameWidth() * decorations.border); XMoveResizeWindow(display, frame.plate, 0, frame.y_border, client.width, client.height); XMoveResizeWindow(display, client.window, 0, 0, client.width, client.height); if (decorations.titlebar) { XSetWindowBorderWidth(display, frame.title, screen->getBorderWidth()); XMoveResizeWindow(display, frame.title, -screen->getBorderWidth(), -screen->getBorderWidth(), frame.width, frame.title_h); positionButtons(); } else if (frame.title) XUnmapWindow(display, frame.title); if (decorations.handle) { XSetWindowBorderWidth(display, frame.handle, screen->getBorderWidth()); XSetWindowBorderWidth(display, frame.left_grip, screen->getBorderWidth()); XSetWindowBorderWidth(display, frame.right_grip, screen->getBorderWidth()); XMoveResizeWindow(display, frame.handle, -screen->getBorderWidth(), frame.y_handle - screen->getBorderWidth(), frame.width, frame.handle_h); XMoveResizeWindow(display, frame.left_grip, -screen->getBorderWidth(), -screen->getBorderWidth(), frame.grip_w, frame.grip_h); XMoveResizeWindow(display, frame.right_grip, frame.width - frame.grip_w - screen->getBorderWidth(), -screen->getBorderWidth(), frame.grip_w, frame.grip_h); XMapSubwindows(display, frame.handle); } else if (frame.handle) XUnmapWindow(display, frame.handle); if (tab) tab->setPosition(); } void FluxboxWindow::getWMName() { XTextProperty text_prop; char **list; int num; I18n *i18n = I18n::instance(); if (XGetWMName(display, client.window, &text_prop)) { if (text_prop.value && text_prop.nitems > 0) { if (text_prop.encoding != XA_STRING) { text_prop.nitems = strlen((char *) text_prop.value); if ((XmbTextPropertyToTextList(display, &text_prop, &list, &num) == Success) && (num > 0) && *list) { client.title = static_cast(*list); XFreeStringList(list); } else client.title = (char *)text_prop.value; } else client.title = (char *)text_prop.value; XFree((char *) text_prop.value); } else client.title = i18n->getMessage( FBNLS::WindowSet, FBNLS::WindowUnnamed, "Unnamed"); } else { client.title = i18n->getMessage( FBNLS::WindowSet, FBNLS::WindowUnnamed, "Unnamed"); } //Note: repeated? client.title_text_w = screen->getWindowStyle()->font.textWidth(getTitle().c_str(), getTitle().size()); client.title_text_w += (frame.bevel_w * 4); } void FluxboxWindow::getWMIconName() { XTextProperty text_prop; char **list; int num; if (XGetWMIconName(display, client.window, &text_prop)) { if (text_prop.value && text_prop.nitems > 0) { if (text_prop.encoding != XA_STRING) { text_prop.nitems = strlen((char *) text_prop.value); if ((XmbTextPropertyToTextList(display, &text_prop, &list, &num) == Success) && (num > 0) && *list) { client.icon_title = (char *)*list; XFreeStringList(list); } else client.icon_title = (char *)text_prop.value; } else client.icon_title = (char *)text_prop.value; XFree((char *) text_prop.value); } else client.icon_title = getTitle(); } else client.icon_title = getTitle(); } void FluxboxWindow::getWMProtocols() { Atom *proto; int num_return = 0; Fluxbox *fluxbox = Fluxbox::instance(); if (XGetWMProtocols(display, client.window, &proto, &num_return)) { for (int i = 0; i < num_return; ++i) { if (proto[i] == fluxbox->getWMDeleteAtom()) functions.close = decorations.close = true; else if (proto[i] == fluxbox->getWMTakeFocusAtom()) send_focus_message = true; else if (proto[i] == fluxbox->getFluxboxStructureMessagesAtom()) screen->addNetizen(new Netizen(screen, client.window)); } XFree(proto); } } void FluxboxWindow::getWMHints() { XWMHints *wmhint = XGetWMHints(display, client.window); if (! wmhint) { visible = true; iconic = false; focus_mode = F_PASSIVE; client.window_group = None; client.initial_state = NormalState; } else { client.wm_hint_flags = wmhint->flags; if (wmhint->flags & InputHint) { if (wmhint->input) { if (send_focus_message) focus_mode = F_LOCALLYACTIVE; else focus_mode = F_PASSIVE; } else { if (send_focus_message) focus_mode = F_GLOBALLYACTIVE; else focus_mode = F_NOINPUT; } } else focus_mode = F_PASSIVE; if (wmhint->flags & StateHint) client.initial_state = wmhint->initial_state; else client.initial_state = NormalState; if (wmhint->flags & WindowGroupHint) { if (! client.window_group) { client.window_group = wmhint->window_group; Fluxbox::instance()->saveGroupSearch(client.window_group, this); } } else client.window_group = None; XFree(wmhint); } } void FluxboxWindow::getWMNormalHints() { long icccm_mask; XSizeHints sizehint; if (! XGetWMNormalHints(display, client.window, &sizehint, &icccm_mask)) { client.min_width = client.min_height = client.base_width = client.base_height = client.width_inc = client.height_inc = 1; client.max_width = 0; // unbounded client.max_height = 0; client.min_aspect_x = client.min_aspect_y = client.max_aspect_x = client.max_aspect_y = 1; client.win_gravity = NorthWestGravity; } else { client.normal_hint_flags = sizehint.flags; if (sizehint.flags & PMinSize) { client.min_width = sizehint.min_width; client.min_height = sizehint.min_height; } else client.min_width = client.min_height = 1; if (sizehint.flags & PMaxSize) { client.max_width = sizehint.max_width; client.max_height = sizehint.max_height; } else { client.max_width = 0; // unbounded client.max_height = 0; } if (sizehint.flags & PResizeInc) { client.width_inc = sizehint.width_inc; client.height_inc = sizehint.height_inc; } else client.width_inc = client.height_inc = 1; 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; } else client.min_aspect_x = client.min_aspect_y = client.max_aspect_x = client.max_aspect_y = 1; if (sizehint.flags & PBaseSize) { client.base_width = sizehint.base_width; client.base_height = sizehint.base_height; } else client.base_width = client.base_height = 0; if (sizehint.flags & PWinGravity) client.win_gravity = sizehint.win_gravity; else client.win_gravity = NorthWestGravity; } } void FluxboxWindow::getMWMHints() { int format; Atom atom_return; unsigned long num, len; Fluxbox *fluxbox = Fluxbox::instance(); if (!XGetWindowProperty(display, client.window, fluxbox->getMotifWMHintsAtom(), 0, PropMwmHintsElements, false, fluxbox->getMotifWMHintsAtom(), &atom_return, &format, &num, &len, (unsigned char **) &client.mwm_hint) == Success && client.mwm_hint) { return; } if (num != PropMwmHintsElements) return; if (client.mwm_hint->flags & MwmHintsDecorations) { if (client.mwm_hint->decorations & MwmDecorAll) { decorations.titlebar = decorations.handle = decorations.border = decorations.iconify = decorations.maximize = decorations.close = decorations.menu = true; } else { decorations.titlebar = decorations.handle = decorations.border = decorations.iconify = decorations.maximize = decorations.close = decorations.tab = false; decorations.menu = true; if (client.mwm_hint->decorations & MwmDecorBorder) decorations.border = true; if (client.mwm_hint->decorations & MwmDecorHandle) decorations.handle = true; if (client.mwm_hint->decorations & MwmDecorTitle) decorations.titlebar = decorations.tab = true; //only tab on windows with titlebar if (client.mwm_hint->decorations & MwmDecorMenu) decorations.menu = true; if (client.mwm_hint->decorations & MwmDecorIconify) decorations.iconify = true; if (client.mwm_hint->decorations & MwmDecorMaximize) decorations.maximize = true; } } if (client.mwm_hint->flags & MwmHintsFunctions) { if (client.mwm_hint->functions & MwmFuncAll) { functions.resize = functions.move = functions.iconify = functions.maximize = functions.close = true; } else { functions.resize = functions.move = functions.iconify = functions.maximize = functions.close = false; if (client.mwm_hint->functions & MwmFuncResize) functions.resize = true; if (client.mwm_hint->functions & MwmFuncMove) functions.move = true; if (client.mwm_hint->functions & MwmFuncIconify) functions.iconify = true; if (client.mwm_hint->functions & MwmFuncMaximize) functions.maximize = true; if (client.mwm_hint->functions & MwmFuncClose) functions.close = true; } } } void FluxboxWindow::getBlackboxHints() { int format; Atom atom_return; unsigned long num, len; Fluxbox *fluxbox = Fluxbox::instance(); if (XGetWindowProperty(display, client.window, fluxbox->getFluxboxHintsAtom(), 0, PropBlackboxHintsElements, False, fluxbox->getFluxboxHintsAtom(), &atom_return, &format, &num, &len, (unsigned char **) &client.blackbox_hint) == Success && client.blackbox_hint) { if (num == PropBlackboxHintsElements) { if (client.blackbox_hint->flags & BaseDisplay::ATTRIB_SHADED) shaded = (client.blackbox_hint->attrib & BaseDisplay::ATTRIB_SHADED); if ((client.blackbox_hint->flags & BaseDisplay::ATTRIB_MAXHORIZ) && (client.blackbox_hint->flags & BaseDisplay::ATTRIB_MAXVERT)) maximized = ((client.blackbox_hint->attrib & (BaseDisplay::ATTRIB_MAXHORIZ | BaseDisplay::ATTRIB_MAXVERT)) ? 1 : 0); else if (client.blackbox_hint->flags & BaseDisplay::ATTRIB_MAXVERT) maximized = ((client.blackbox_hint->attrib & BaseDisplay::ATTRIB_MAXVERT) ? 2 : 0); else if (client.blackbox_hint->flags & BaseDisplay::ATTRIB_MAXHORIZ) maximized = ((client.blackbox_hint->attrib & BaseDisplay::ATTRIB_MAXHORIZ) ? 3 : 0); if (client.blackbox_hint->flags & BaseDisplay::ATTRIB_OMNIPRESENT) stuck = (client.blackbox_hint->attrib & BaseDisplay::ATTRIB_OMNIPRESENT); if (client.blackbox_hint->flags & BaseDisplay::ATTRIB_WORKSPACE) workspace_number = client.blackbox_hint->workspace; if (client.blackbox_hint->flags & BaseDisplay::ATTRIB_DECORATION) { old_decoration = static_cast(client.blackbox_hint->decoration); setDecoration(old_decoration); } } } } void FluxboxWindow::configure(int dx, int dy, unsigned int dw, unsigned int dh) { //we don't want negative size if (dw < 0 || dh < 0) return; bool send_event = (frame.x != dx || frame.y != dy); if ((dw != frame.width) || (dh != frame.height)) { if ((((signed) frame.width) + dx) < 0) dx = 0; if ((((signed) frame.height) + dy) < 0) dy = 0; frame.x = dx; frame.y = dy; frame.width = dw; frame.height = dh; downsize(); #ifdef SHAPE if (Fluxbox::instance()->hasShapeExtensions() && frame.shaped) { XShapeCombineShape(display, frame.window, ShapeBounding, frame.mwm_border_w, frame.y_border + frame.mwm_border_w, client.window, ShapeBounding, ShapeSet); int num = 1; XRectangle xrect[2]; xrect[0].x = xrect[0].y = 0; xrect[0].width = frame.width; xrect[0].height = frame.y_border; if (decorations.handle) { xrect[1].x = 0; xrect[1].y = frame.y_handle; xrect[1].width = frame.width; xrect[1].height = frame.handle_h + screen->getBorderWidth(); num++; } XShapeCombineRectangles(display, frame.window, ShapeBounding, 0, 0, xrect, num, ShapeUnion, Unsorted); } #endif // SHAPE XMoveResizeWindow(display, frame.window, frame.x, frame.y, frame.width, frame.height); positionWindows(); decorate(); setFocusFlag(focused); redrawAllButtons(); shaded = false; } else { frame.x = dx; frame.y = dy; XMoveWindow(display, frame.window, frame.x, frame.y); //move the tab and the chain if (tab) tab->setPosition(); if (! moving) send_event = true; } if (send_event && ! moving) { client.x = dx + frame.mwm_border_w + screen->getBorderWidth(); client.y = dy + frame.y_border + frame.mwm_border_w + screen->getBorderWidth(); XEvent event; event.type = ConfigureNotify; event.xconfigure.display = display; event.xconfigure.event = client.window; event.xconfigure.window = client.window; event.xconfigure.x = client.x; event.xconfigure.y = client.y; event.xconfigure.width = client.width; event.xconfigure.height = client.height; event.xconfigure.border_width = client.old_bw; event.xconfigure.above = frame.window; event.xconfigure.override_redirect = false; XSendEvent(display, client.window, False, StructureNotifyMask, &event); screen->updateNetizenConfigNotify(&event); } } bool FluxboxWindow::setInputFocus() { //TODO hint skip focus if (((signed) (frame.x + frame.width)) < 0) { if (((signed) (frame.y + frame.y_border)) < 0) configure(screen->getBorderWidth(), screen->getBorderWidth(), frame.width, frame.height); else if (frame.y > (signed) screen->getHeight()) configure(screen->getBorderWidth(), screen->getHeight() - frame.height, frame.width, frame.height); else configure(screen->getBorderWidth(), frame.y + screen->getBorderWidth(), frame.width, frame.height); } else if (frame.x > (signed) screen->getWidth()) { if (((signed) (frame.y + frame.y_border)) < 0) configure(screen->getWidth() - frame.width, screen->getBorderWidth(), frame.width, frame.height); else if (frame.y > (signed) screen->getHeight()) configure(screen->getWidth() - frame.width, screen->getHeight() - frame.height, frame.width, frame.height); else configure(screen->getWidth() - frame.width, frame.y + screen->getBorderWidth(), frame.width, frame.height); } if (! validateClient()) return false; bool ret = false; if (client.transients.size() && modal) { std::list::iterator it = client.transients.begin(); std::list::iterator it_end = client.transients.end(); for (; it != it_end; ++it) { if ((*it)->modal) return (*it)->setInputFocus(); } } else { if (focus_mode == F_LOCALLYACTIVE || focus_mode == F_PASSIVE) { XSetInputFocus(display, client.window, RevertToPointerRoot, CurrentTime); } else { return false; } Fluxbox *fb = Fluxbox::instance(); fb->setFocusedWindow(this); if (send_focus_message) { XEvent ce; ce.xclient.type = ClientMessage; ce.xclient.message_type = fb->getWMProtocolsAtom(); ce.xclient.display = display; ce.xclient.window = client.window; ce.xclient.format = 32; ce.xclient.data.l[0] = fb->getWMTakeFocusAtom(); ce.xclient.data.l[1] = fb->getLastTime(); ce.xclient.data.l[2] = 0l; ce.xclient.data.l[3] = 0l; ce.xclient.data.l[4] = 0l; XSendEvent(display, client.window, false, NoEventMask, &ce); } if ((screen->isSloppyFocus() || screen->isSemiSloppyFocus()) && screen->doAutoRaise()) timer.start(); ret = true; } return ret; } //------------ setTab -------------- // Enables or disables the tab on the window //---------------------------------- void FluxboxWindow::setTab(bool flag) { if (flag) { if (!tab && isGroupable()) tab = new Tab(this, 0, 0); tab->focus(); // draws the tab with correct texture tab->setPosition(); // set tab windows position } else if (tab) { delete tab; tab = 0; } decorations.tab = flag; } //------------- iconify ---------------- // Unmaps the window and removes it from workspace list //-------------------------------------- void FluxboxWindow::iconify() { if (iconic) return; if (m_windowmenu.get()) m_windowmenu->hide(); setState(IconicState); XSelectInput(display, client.window, NoEventMask); XUnmapWindow(display, client.window); XSelectInput(display, client.window, PropertyChangeMask | StructureNotifyMask | FocusChangeMask); XUnmapWindow(display, frame.window); visible = false; iconic = true; screen->getWorkspace(workspace_number)->removeWindow(this); if (client.transient_for) { if (! client.transient_for->iconic) client.transient_for->iconify(); } screen->addIcon(this); if (tab) //if this window got a tab then iconify it too tab->iconify(); if (client.transients.size()) { std::list::iterator it = client.transients.begin(); std::list::iterator it_end = client.transients.end(); for (; it != it_end; ++it) { if (! (*it)->iconic) (*it)->iconify(); } } } void FluxboxWindow::deiconify(bool reassoc, bool raise) { if (iconic || reassoc) { screen->reassociateWindow(this, screen->getCurrentWorkspace()->workspaceID(), false); } else if (workspace_number != screen->getCurrentWorkspace()->workspaceID()) return; setState(NormalState); XSelectInput(display, client.window, NoEventMask); XMapWindow(display, client.window); XSelectInput(display, client.window, PropertyChangeMask | StructureNotifyMask | FocusChangeMask); XMapSubwindows(display, frame.window); XMapWindow(display, frame.window); if (iconic && screen->doFocusNew()) setInputFocus(); visible = true; iconic = false; if (reassoc && client.transients.size()) { // deiconify all transients std::list::iterator it = client.transients.begin(); std::list::iterator it_end = client.transients.end(); for (; it != it_end; ++it) { (*it)->deiconify(true, false); } } if (tab) tab->deiconify(); if (raise) { screen->getWorkspace(workspace_number)->raiseWindow(this); if (tab) tab->raise(); } } void FluxboxWindow::close() { Fluxbox *fluxbox = Fluxbox::instance(); XEvent ce; ce.xclient.type = ClientMessage; ce.xclient.message_type = fluxbox->getWMProtocolsAtom(); ce.xclient.display = display; ce.xclient.window = client.window; ce.xclient.format = 32; ce.xclient.data.l[0] = fluxbox->getWMDeleteAtom(); ce.xclient.data.l[1] = CurrentTime; ce.xclient.data.l[2] = 0l; ce.xclient.data.l[3] = 0l; ce.xclient.data.l[4] = 0l; XSendEvent(display, client.window, false, NoEventMask, &ce); } void FluxboxWindow::withdraw() { visible = false; iconic = false; if (isMoving()) stopMoving(); if (isResizing()) stopResizing(); XUnmapWindow(display, frame.window); XSelectInput(display, client.window, NoEventMask); XUnmapWindow(display, client.window); XSelectInput(display, client.window, PropertyChangeMask | StructureNotifyMask | FocusChangeMask); if (m_windowmenu.get()) m_windowmenu->hide(); if (tab) tab->withdraw(); } void FluxboxWindow::maximize(unsigned int button) { // deiconify if we're iconic if (isIconic()) deiconify(); if (! maximized) { int dx, dy; unsigned int dw, dh, slitModL = 0, slitModR = 0, slitModT = 0, slitModB = 0; #ifdef XINERAMA // get the head the window is on, taking the middle of the window to // make it feel right, maybe someone will like client.x, client.y better // tough? unsigned int head = (screen->hasXinerama()) ? screen->getHead(client.x + (client.width / 2), client.y + (client.height / 2)) : 0; #endif // XINERAMA #ifdef SLIT #ifdef XINERAMA // take the slit in account if it's on the same head // (always true if we don't have xinerama if (!screen->hasXinerama() || screen->getSlitOnHead() == head) { #endif // XINERAMA Slit* mSlt = screen->getSlit(); if(!screen->doMaxOverSlit() && !screen->doFullMax() && (mSlt->width() > 1)) { switch(screen->getSlitDirection()) { case Slit::VERTICAL: switch(screen->getSlitPlacement()) { case Slit::TOPRIGHT: case Slit::CENTERRIGHT: case Slit::BOTTOMRIGHT: slitModR = mSlt->width() + screen->getBevelWidth(); break; default: slitModL = mSlt->width() + screen->getBevelWidth(); break; } break; case Slit::HORIZONTAL: switch(screen->getSlitPlacement()) { case Slit::TOPLEFT: case Slit::TOPCENTER: case Slit::TOPRIGHT: slitModT = mSlt->height() + screen->getBevelWidth(); switch (screen->getToolbarPlacement()) { case Toolbar::TOPLEFT: case Toolbar::TOPCENTER: case Toolbar::TOPRIGHT: slitModT -= screen->getToolbar()->getExposedHeight() + screen->getBorderWidth(); break; default: break; } break; default: slitModB = mSlt->height() + screen->getBevelWidth(); switch (screen->getToolbarPlacement()) { case Toolbar::BOTTOMLEFT: case Toolbar::BOTTOMCENTER: case Toolbar::BOTTOMRIGHT: slitModB -= screen->getToolbar()->getExposedHeight() + screen->getBorderWidth(); break; default: break; } break; } break; } } #ifdef XINERAMA } #endif // XINERAMA #endif // SLIT blackbox_attrib.premax_x = frame.x; blackbox_attrib.premax_y = frame.y; blackbox_attrib.premax_w = frame.width; blackbox_attrib.premax_h = frame.height; #ifdef XINERAMA dw = screen->getHeadWidth(head) - slitModL - slitModR; #else // !XINERAMA dw = screen->getWidth() - slitModL - slitModR; #endif // XINERAMA dw -= screen->getBorderWidth2x(); dw -= frame.mwm_border_w * 2; dw -= client.base_width; #ifdef XINERAMA dh = screen->getHeadHeight(head) - slitModT - slitModB; #else // !XINERAMA dh = screen->getHeight() - slitModT - slitModB; #endif // XINERAMA dh -= screen->getBorderWidth2x(); dh -= frame.mwm_border_w * 2; dh -= ((frame.handle_h + screen->getBorderWidth()) * decorations.handle); dh -= client.base_height; dh -= frame.y_border; if (! screen->doFullMax()) { #ifdef XINERAMA if (screen->hasXinerama()) { // is the toolbar on this head? if ((screen->getToolbarOnHead() == (signed) head) || (screen->getToolbarOnHead() < 0)) { dh -= screen->getToolbar()->getExposedHeight() + screen->getBorderWidth2x(); } } else { dh -= screen->getToolbar()->getExposedHeight() + screen->getBorderWidth2x(); } #else // !XINERAMA dh -= screen->getToolbar()->getExposedHeight() + screen->getBorderWidth2x(); #endif // XINERAMA } if (dw < client.min_width) dw = client.min_width; if (dh < client.min_height) dh = client.min_height; if (client.max_width != 0 && dw > client.max_width) dw = client.max_width; if (client.max_height != 0 && dh > client.max_height) dh = client.max_height; dw -= (dw % client.width_inc); dw += client.base_width; dh -= (dh % client.height_inc); dh += client.base_height; dw += frame.mwm_border_w * 2; dh += frame.y_border; dh += (frame.handle_h + screen->getBorderWidth()); dh += frame.mwm_border_w * 2; #ifdef XINERAMA dx = screen->getHeadX(head) + ((screen->getHeadWidth(head) + slitModL - slitModR - dw) / 2) - screen->getBorderWidth(); #else // !XINERAMA dx = ((screen->getWidth()+ slitModL - slitModR - dw) / 2) - screen->getBorderWidth(); #endif // XINERAMA if (screen->doFullMax()) { #ifdef XINERAMA dy = screen->getHeadY(head) + ((screen->getHeadHeight(head) - dh) / 2) - screen->getBorderWidth(); #else // !XINERAMA dy = ((screen->getHeight() - dh) / 2) - screen->getBorderWidth(); #endif // XINERAMA } else { #ifdef XINERAMA if (screen->hasXinerama()) { // xinerama dy = screen->getHeadY(head); // is the toolbar on this head? if ((screen->getToolbarOnHead() == (signed) head) || (screen->getToolbarOnHead() < 0)) { dy += (((screen->getHeadHeight(head) + slitModT - slitModB - (screen->getToolbar()->getExposedHeight())) - dh) / 2) - screen->getBorderWidth2x(); } else { dy += ((screen->getHeadHeight(head) + slitModT - slitModB - dh) / 2) - screen->getBorderWidth(); } } else { // no xinerama dy = (((screen->getHeight() + slitModT - slitModB - (screen->getToolbar()->getExposedHeight())) - dh) / 2) - screen->getBorderWidth2x(); } #else // !XINERAMA dy = (((screen->getHeight() + slitModT - slitModB - (screen->getToolbar()->getExposedHeight())) - dh) / 2) - screen->getBorderWidth2x(); #endif // XINERAMA switch (screen->getToolbarPlacement()) { case Toolbar::TOPLEFT: case Toolbar::TOPCENTER: case Toolbar::TOPRIGHT: #ifdef XINERAMA // if < 0 than it's over ALL heads, with no xinerama it's there too if (!screen->hasXinerama() || (screen->getToolbarOnHead() == (signed) head) || (screen->getToolbarOnHead() < 0)) { dy += screen->getToolbar()->getExposedHeight() + screen->getBorderWidth2x(); } #else // !XINERAMA dy += screen->getToolbar()->getExposedHeight() + screen->getBorderWidth2x(); #endif // XINERAMA break; default: break; } } if (hasTab()) { switch(screen->getTabPlacement()) { case Tab::PTOP: dy += screen->getTabHeight(); dh -= screen->getTabHeight(); break; case Tab::PLEFT: if (screen->isTabRotateVertical()) { dx += screen->getTabHeight(); dw -= screen->getTabHeight(); } else { dx += screen->getTabWidth(); dw -= screen->getTabWidth(); } break; case Tab::PRIGHT: if (screen->isTabRotateVertical()) dw -= screen->getTabHeight(); else dw -= screen->getTabWidth(); break; case Tab::PBOTTOM: dh -= screen->getTabHeight(); break; default: dy += screen->getTabHeight(); dh -= screen->getTabHeight(); break; } } if (button == 2) { //expand max width dw = frame.width; dx = frame.x; } else if (button == 3) { //expand max height dh = frame.height; dy = frame.y; } switch(button) { case 1: blackbox_attrib.flags |= BaseDisplay::ATTRIB_MAXHORIZ | BaseDisplay::ATTRIB_MAXVERT; blackbox_attrib.attrib |= BaseDisplay::ATTRIB_MAXHORIZ | BaseDisplay::ATTRIB_MAXVERT; break; case 2: blackbox_attrib.flags |= BaseDisplay::ATTRIB_MAXVERT; blackbox_attrib.attrib |= BaseDisplay::ATTRIB_MAXVERT; break; case 3: blackbox_attrib.flags |= BaseDisplay::ATTRIB_MAXHORIZ; blackbox_attrib.attrib |= BaseDisplay::ATTRIB_MAXHORIZ; break; } if (shaded) { blackbox_attrib.flags ^= BaseDisplay::ATTRIB_SHADED; blackbox_attrib.attrib ^= BaseDisplay::ATTRIB_SHADED; shaded = false; if (hasTab()) getTab()->shade(); } maximized = true; configure(dx, dy, dw, dh); if (tab) tab->raise(); screen->getWorkspace(workspace_number)->raiseWindow(this); setState(current_state); } else { maximized = false; if (isShaded()) { shade(); if (hasTab()) getTab()->shade(); } blackbox_attrib.flags &= ! (BaseDisplay::ATTRIB_MAXHORIZ | BaseDisplay::ATTRIB_MAXVERT); blackbox_attrib.attrib &= ! (BaseDisplay::ATTRIB_MAXHORIZ | BaseDisplay::ATTRIB_MAXVERT); configure(blackbox_attrib.premax_x, blackbox_attrib.premax_y, blackbox_attrib.premax_w, blackbox_attrib.premax_h); blackbox_attrib.premax_x = blackbox_attrib.premax_y = 0; blackbox_attrib.premax_w = blackbox_attrib.premax_h = 0; redrawAllButtons(); setState(current_state); } if (tab) //resize all the windows in the tab group tab->resize(); } void FluxboxWindow::setWorkspace(int n) { workspace_number = n; blackbox_attrib.flags |= BaseDisplay::ATTRIB_WORKSPACE; blackbox_attrib.workspace = workspace_number; // notify workspace change #ifdef DEBUG cerr<stick(); //this window will stick too. else if (stuck) { blackbox_attrib.flags ^= BaseDisplay::ATTRIB_OMNIPRESENT; blackbox_attrib.attrib ^= BaseDisplay::ATTRIB_OMNIPRESENT; stuck = false; } else { stuck = true; if (screen->getCurrentWorkspaceID() != workspace_number) { screen->reassociateWindow(this,screen->getCurrentWorkspaceID(), true); } blackbox_attrib.flags |= BaseDisplay::ATTRIB_OMNIPRESENT; blackbox_attrib.attrib |= BaseDisplay::ATTRIB_OMNIPRESENT; } //find a STICK button in window redrawAllButtons(); setState(current_state); } void FluxboxWindow::setFocusFlag(bool focus) { focused = focus; // Record focus timestamp for window cycling enhancements, such as skipping lower tabs if (focused) gettimeofday(&lastFocusTime, 0); if (decorations.titlebar) { if (focused) { if (frame.ftitle) XSetWindowBackgroundPixmap(display, frame.title, frame.ftitle); else XSetWindowBackground(display, frame.title, frame.ftitle_pixel); } else { if (frame.utitle) XSetWindowBackgroundPixmap(display, frame.title, frame.utitle); else XSetWindowBackground(display, frame.title, frame.utitle_pixel); } XClearWindow(display, frame.title); redrawLabel(); redrawAllButtons(); } if (decorations.handle) { if (focused) { if (frame.fhandle) XSetWindowBackgroundPixmap(display, frame.handle, frame.fhandle); else XSetWindowBackground(display, frame.handle, frame.fhandle_pixel); if (frame.fgrip) { XSetWindowBackgroundPixmap(display, frame.right_grip, frame.fgrip); XSetWindowBackgroundPixmap(display, frame.left_grip, frame.fgrip); } else { XSetWindowBackground(display, frame.right_grip, frame.fgrip_pixel); XSetWindowBackground(display, frame.left_grip, frame.fgrip_pixel); } } else { if (frame.uhandle) XSetWindowBackgroundPixmap(display, frame.handle, frame.uhandle); else XSetWindowBackground(display, frame.handle, frame.uhandle_pixel); if (frame.ugrip) { XSetWindowBackgroundPixmap(display, frame.right_grip, frame.ugrip); XSetWindowBackgroundPixmap(display, frame.left_grip, frame.ugrip); } else { XSetWindowBackground(display, frame.right_grip, frame.ugrip_pixel); XSetWindowBackground(display, frame.left_grip, frame.ugrip_pixel); } } XClearWindow(display, frame.handle); XClearWindow(display, frame.right_grip); XClearWindow(display, frame.left_grip); } if (tab) tab->focus(); if (decorations.border) { if (focused) XSetWindowBorder(display, frame.plate, frame.fborder_pixel); else XSetWindowBorder(display, frame.plate, frame.uborder_pixel); } if ((screen->isSloppyFocus() || screen->isSemiSloppyFocus()) && screen->doAutoRaise()) timer.stop(); } void FluxboxWindow::installColormap(bool install) { Fluxbox *fluxbox = Fluxbox::instance(); fluxbox->grab(); if (! validateClient()) return; int i = 0, ncmap = 0; Colormap *cmaps = XListInstalledColormaps(display, client.window, &ncmap); XWindowAttributes wattrib; if (cmaps) { if (XGetWindowAttributes(display, client.window, &wattrib)) { if (install) { // install the window's colormap for (i = 0; i < ncmap; i++) { if (*(cmaps + i) == wattrib.colormap) { // this window is using an installed color map... do not install install = false; break; //end for-loop (we dont need to check more) } } // otherwise, install the window's colormap if (install) XInstallColormap(display, wattrib.colormap); } else { for (i = 0; i < ncmap; i++) // uninstall the window's colormap if (*(cmaps + i) == wattrib.colormap) XUninstallColormap(display, wattrib.colormap); // we found the colormap to uninstall } } XFree(cmaps); } fluxbox->ungrab(); } void FluxboxWindow::setState(unsigned long new_state) { current_state = new_state; Fluxbox *fluxbox = Fluxbox::instance(); unsigned long state[2]; state[0] = (unsigned long) current_state; state[1] = (unsigned long) None; XChangeProperty(display, client.window, fluxbox->getWMStateAtom(), fluxbox->getWMStateAtom(), 32, PropModeReplace, (unsigned char *) state, 2); XChangeProperty(display, client.window, fluxbox->getFluxboxAttributesAtom(), fluxbox->getFluxboxAttributesAtom(), 32, PropModeReplace, (unsigned char *) &blackbox_attrib, PropBlackboxAttributesElements); //notify state changed m_statesig.notify(); } //TODO: why ungrab in if-statement? bool FluxboxWindow::getState() { current_state = 0; Atom atom_return; bool ret = false; int foo; unsigned long *state, ulfoo, nitems; Fluxbox *fluxbox = Fluxbox::instance(); if ((XGetWindowProperty(display, client.window, fluxbox->getWMStateAtom(), 0l, 2l, false, fluxbox->getWMStateAtom(), &atom_return, &foo, &nitems, &ulfoo, (unsigned char **) &state) != Success) || (! state)) { fluxbox->ungrab(); return false; } if (nitems >= 1) { current_state = static_cast(state[0]); ret = true; } XFree(static_cast(state)); return ret; } void FluxboxWindow::setGravityOffsets() { // translate x coordinate switch (client.win_gravity) { // handle Westward gravity case NorthWestGravity: case WestGravity: case SouthWestGravity: default: frame.x = client.x; break; // handle Eastward gravity case NorthEastGravity: case EastGravity: case SouthEastGravity: frame.x = (client.x + client.width) - frame.width; break; // no x translation desired - default case StaticGravity: case ForgetGravity: case CenterGravity: frame.x = client.x - frame.mwm_border_w + screen->getBorderWidth(); } // translate y coordinate switch (client.win_gravity) { // handle Northbound gravity case NorthWestGravity: case NorthGravity: case NorthEastGravity: default: frame.y = client.y; break; // handle Southbound gravity case SouthWestGravity: case SouthGravity: case SouthEastGravity: frame.y = (client.y + client.height) - frame.height; break; // no y translation desired - default case StaticGravity: case ForgetGravity: case CenterGravity: frame.y = client.y - frame.y_border - frame.mwm_border_w - screen->getBorderWidth(); break; } } void FluxboxWindow::restoreAttributes() { if (!getState()) current_state = NormalState; Atom atom_return; int foo; unsigned long ulfoo, nitems; Fluxbox *fluxbox = Fluxbox::instance(); BaseDisplay::BlackboxAttributes *net; if (XGetWindowProperty(display, client.window, fluxbox->getFluxboxAttributesAtom(), 0l, PropBlackboxAttributesElements, false, fluxbox->getFluxboxAttributesAtom(), &atom_return, &foo, &nitems, &ulfoo, (unsigned char **) &net) == Success && net && nitems == PropBlackboxAttributesElements) { blackbox_attrib.flags = net->flags; blackbox_attrib.attrib = net->attrib; blackbox_attrib.workspace = net->workspace; blackbox_attrib.stack = net->stack; blackbox_attrib.premax_x = net->premax_x; blackbox_attrib.premax_y = net->premax_y; blackbox_attrib.premax_w = net->premax_w; blackbox_attrib.premax_h = net->premax_h; XFree(static_cast(net)); } else return; if (blackbox_attrib.flags & BaseDisplay::ATTRIB_SHADED && blackbox_attrib.attrib & BaseDisplay::ATTRIB_SHADED) { int save_state = ((current_state == IconicState) ? NormalState : current_state); shaded = false; shade(); if (tab) tab->shade(); current_state = save_state; } if (( blackbox_attrib.workspace != screen->getCurrentWorkspaceID()) && ( blackbox_attrib.workspace < screen->getCount())) { screen->reassociateWindow(this, blackbox_attrib.workspace, true); if (current_state == NormalState) current_state = WithdrawnState; } else if (current_state == WithdrawnState) current_state = NormalState; if (blackbox_attrib.flags & BaseDisplay::ATTRIB_OMNIPRESENT && blackbox_attrib.attrib & BaseDisplay::ATTRIB_OMNIPRESENT) { stuck = false; stick(); current_state = NormalState; } if ((blackbox_attrib.flags & BaseDisplay::ATTRIB_MAXHORIZ) || (blackbox_attrib.flags & BaseDisplay::ATTRIB_MAXVERT)) { int x = blackbox_attrib.premax_x, y = blackbox_attrib.premax_y; unsigned int w = blackbox_attrib.premax_w, h = blackbox_attrib.premax_h; maximized = false; int m; if ((blackbox_attrib.flags & BaseDisplay::ATTRIB_MAXHORIZ) && (blackbox_attrib.flags & BaseDisplay::ATTRIB_MAXVERT)) m = ((blackbox_attrib.attrib & (BaseDisplay::ATTRIB_MAXHORIZ | BaseDisplay::ATTRIB_MAXVERT)) ? 1 : 0); else if (blackbox_attrib.flags & BaseDisplay::ATTRIB_MAXVERT) m = ((blackbox_attrib.attrib & BaseDisplay::ATTRIB_MAXVERT) ? 2 : 0); else if (blackbox_attrib.flags & BaseDisplay::ATTRIB_MAXHORIZ) m = ((blackbox_attrib.attrib & BaseDisplay::ATTRIB_MAXHORIZ) ? 3 : 0); else m = 0; if (m) maximize(m); blackbox_attrib.premax_x = x; blackbox_attrib.premax_y = y; blackbox_attrib.premax_w = w; blackbox_attrib.premax_h = h; } setState(current_state); } void FluxboxWindow::showMenu(int mx, int my) { if (m_windowmenu.get() == 0) return; m_windowmenu->move(mx, my); m_windowmenu->show(); m_windowmenu->raise(); m_windowmenu->getSendToMenu().raise(); m_windowmenu->getSendGroupToMenu().raise(); } void FluxboxWindow::restoreGravity() { // restore x coordinate switch (client.win_gravity) { // handle Westward gravity case NorthWestGravity: case WestGravity: case SouthWestGravity: default: client.x = frame.x; break; // handle Eastward gravity case NorthEastGravity: case EastGravity: case SouthEastGravity: client.x = (frame.x + frame.width) - client.width; break; } // restore y coordinate switch (client.win_gravity) { // handle Northbound gravity case NorthWestGravity: case NorthGravity: case NorthEastGravity: default: client.y = frame.y; break; // handle Southbound gravity case SouthWestGravity: case SouthGravity: case SouthEastGravity: client.y = (frame.y + frame.height) - client.height; break; } } bool FluxboxWindow::isLowerTab() const { Tab* chkTab = (tab ? tab->first() : 0); while (chkTab) { const FluxboxWindow* chkWin = chkTab->getWindow(); if (chkWin && chkWin != this && timercmp(&chkWin->lastFocusTime, &lastFocusTime, >)) return true; chkTab = chkTab->next(); } return false; } void FluxboxWindow::redrawLabel() { if (focused) { if (frame.flabel) XSetWindowBackgroundPixmap(display, frame.label, frame.flabel); else XSetWindowBackground(display, frame.label, frame.flabel_pixel); } else { if (frame.ulabel) XSetWindowBackgroundPixmap(display, frame.label, frame.ulabel); else XSetWindowBackground(display, frame.label, frame.ulabel_pixel); } XClearWindow(display, frame.label); //no need to draw the title if we don't have any if (getTitle().size() != 0) { GC gc = ((focused) ? screen->getWindowStyle()->l_text_focus_gc : screen->getWindowStyle()->l_text_unfocus_gc); unsigned int l = client.title_text_w; int dlen = getTitle().size(); int dx = frame.bevel_w; FbTk::Font &font = screen->getWindowStyle()->font; if (l > frame.label_w) { for (; dlen >= 0; dlen--) { l = font.textWidth(getTitle().c_str(), dlen) + frame.bevel_w*4; if (l < frame.label_w) break; } } switch (screen->getWindowStyle()->justify) { case DrawUtil::Font::RIGHT: dx += frame.label_w - l; break; case DrawUtil::Font::CENTER: dx += (frame.label_w - l)/2; break; } font.drawText( frame.label, screen->getScreenNumber(), gc, getTitle().c_str(), getTitle().size(), dx, screen->getWindowStyle()->font.ascent() + 1); } } void FluxboxWindow::redrawAllButtons() { for (unsigned int i=0; igetMessage( FBNLS::WindowSet, FBNLS::WindowMapRequest, "FluxboxWindow::mapRequestEvent() for 0x%lx\n"), client.window); #endif // DEBUG if (re->window != client.window) return; Fluxbox *fluxbox = Fluxbox::instance(); fluxbox->grab(); if (! validateClient()) return; bool get_state_ret = getState(); if (! (get_state_ret && fluxbox->isStartup())) { if ((client.wm_hint_flags & StateHint) && (! (current_state == NormalState || current_state == IconicState))) { current_state = client.initial_state; } else current_state = NormalState; } else if (iconic) current_state = NormalState; switch (current_state) { case IconicState: iconify(); break; case WithdrawnState: withdraw(); break; case NormalState: //check WM_CLASS only when we changed state to NormalState from // WithdrawnState (ICCC 4.1.2.5) XClassHint ch; if (XGetClassHint(display, getClientWindow(), &ch) == 0) { cerr<<"Failed to read class hint!"<(ch.res_name); XFree(ch.res_name); } else m_instance_name = ""; if (ch.res_class != 0) { m_class_name = const_cast(ch.res_class); XFree(ch.res_class); } else m_class_name = ""; Workspace *wsp = screen->getWorkspace(workspace_number); // we must be resizable AND maximizable to be autogrouped // TODO: there should be an isGroupable() function if (wsp != 0 && isResizable() && isMaximizable()) { wsp->checkGrouping(*this); } } deiconify(false); break; case InactiveState: case ZoomState: default: deiconify(false); break; } fluxbox->ungrab(); } void FluxboxWindow::mapNotifyEvent(XMapEvent *ne) { if ((ne->window == client.window) && (! ne->override_redirect) && (visible)) { Fluxbox *fluxbox = Fluxbox::instance(); fluxbox->grab(); if (! validateClient()) return; if (decorations.titlebar) positionButtons(); setState(NormalState); redrawAllButtons(); if (transient || screen->doFocusNew()) setInputFocus(); else setFocusFlag(false); visible = true; iconic = false; // Auto-group from tab? if (!transient) { // Grab and clear the auto-group window FluxboxWindow* autoGroupWindow = screen->useAutoGroupWindow(); if (autoGroupWindow) { Tab *groupTab = autoGroupWindow->getTab(); if (groupTab) groupTab->addWindowToGroup(this); } } fluxbox->ungrab(); } } //------------------- unmapNotify ------------------ // Unmaps frame window and client window if // event.window == client.window // Returns true if *this should die // else false //------------------------------------------------- bool FluxboxWindow::unmapNotifyEvent(XUnmapEvent *ue) { if (ue->window != client.window) return false; #ifdef DEBUG fprintf(stderr, I18n::instance()->getMessage( FBNLS::WindowSet, FBNLS::WindowUnmapNotify, "FluxboxWindow::unmapNotifyEvent() for 0x%lx\n"), client.window); #endif // DEBUG restore(false); return true; // make sure this one deletes } //----------- destroyNotifyEvent ------------- // Checks if event is for client.window. // Unmaps frame.window and returns true for destroy // of this FluxboxWindow else returns false. //-------------------------------------------- bool FluxboxWindow::destroyNotifyEvent(XDestroyWindowEvent *de) { if (de->window == client.window) { #ifdef DEBUG cerr<<__FILE__<<"("<<__LINE__<<"): DestroyNotifyEvent this="<iconUpdate(); updateIcon(); break; case XA_WM_NAME: getWMName(); if (decorations.titlebar) redrawLabel(); if (hasTab()) // update tab getTab()->draw(false); if (! iconic) screen->getWorkspace(workspace_number)->update(); else updateIcon(); break; case XA_WM_NORMAL_HINTS: { getWMNormalHints(); if ((client.normal_hint_flags & PMinSize) && (client.normal_hint_flags & PMaxSize)) { if (client.max_width != 0 && client.max_width <= client.min_width && client.max_height != 0 && client.max_height <= client.min_height) { decorations.maximize = false; decorations.handle = false; functions.resize=false; functions.maximize=false; } else { if (! isTransient()) { decorations.maximize = true; decorations.handle = true; functions.maximize = true; } functions.resize = true; } } int x = frame.x, y = frame.y; unsigned int w = frame.width, h = frame.height; upsize(); if ((x != frame.x) || (y != frame.y) || (w != frame.width) || (h != frame.height)) reconfigure(); break; } default: if (atom == fluxbox->getWMProtocolsAtom()) { getWMProtocols(); if (decorations.close && !findTitleButton(Fluxbox::CLOSE)) { createButton(Fluxbox::CLOSE, FluxboxWindow::closePressed_cb, FluxboxWindow::closeButton_cb, FluxboxWindow::closeDraw_cb); if (decorations.titlebar) positionButtons(true); if (m_windowmenu.get()) m_windowmenu->reconfigure(); } } break; } } void FluxboxWindow::exposeEvent(XExposeEvent *ee) { if (frame.label == ee->window && decorations.titlebar) redrawLabel(); else redrawAllButtons(); } void FluxboxWindow::configureRequestEvent(XConfigureRequestEvent *cr) { if (cr->window == client.window) { Fluxbox *fluxbox = Fluxbox::instance(); fluxbox->grab(); if (! validateClient()) return; int cx = frame.x, cy = frame.y; unsigned int cw = frame.width, ch = frame.height; if (cr->value_mask & CWBorderWidth) client.old_bw = cr->border_width; if (cr->value_mask & CWX) cx = cr->x - frame.mwm_border_w - screen->getBorderWidth(); if (cr->value_mask & CWY) cy = cr->y - frame.y_border - frame.mwm_border_w - screen->getBorderWidth(); if (cr->value_mask & CWWidth) cw = cr->width + (frame.mwm_border_w * 2); if (cr->value_mask & CWHeight) { ch = cr->height + (frame.y_border + (frame.mwm_border_w * 2) + screen->getBorderWidth()) * decorations.border + frame.handle_h*decorations.handle; } if (frame.x != cx || frame.y != cy || frame.width != cw || frame.height != ch) { configure(cx, cy, cw, ch); if (tab) tab->resize(); } if (cr->value_mask & CWStackMode) { switch (cr->detail) { case Above: case TopIf: default: if (iconic) deiconify(); //!!TODO check this and the line below.. // if (tab) // tab->raise(); screen->getWorkspace(workspace_number)->raiseWindow(this); break; case Below: case BottomIf: if (iconic) deiconify(); // if (tab) // tab->raise(); screen->getWorkspace(workspace_number)->lowerWindow(this); break; } } fluxbox->ungrab(); } } void FluxboxWindow::buttonPressEvent(XButtonEvent *be) { Fluxbox *fluxbox = Fluxbox::instance(); fluxbox->grab(); if (! validateClient()) return; if (be->button == 1 || (be->button == 3 && be->state == Mod1Mask)) { if ((! focused) && (! screen->isSloppyFocus())) //check focus setInputFocus(); //Redraw buttons for (unsigned int i=0; iwindow == buttonlist[i].win && buttonlist[i].draw) buttonlist[i].draw(this, be->window, true); } if (frame.plate == be->window) { if (m_windowmenu.get() && m_windowmenu->isVisible()) //hide menu if its visible m_windowmenu->hide(); //raise tab first, if there is any, so the focus on windows get //right and dont "hide" the tab behind other windows if (tab) tab->raise(); screen->getWorkspace(workspace_number)->raiseWindow(this); XAllowEvents(display, ReplayPointer, be->time); } else { if (frame.title == be->window || frame.label == be->window) { if (((be->time - lastButtonPressTime) <= fluxbox->getDoubleClickInterval()) || (be->state & ControlMask)) { lastButtonPressTime = 0; shade(); if (tab) //shade windows in the tablist too tab->shade(); } else lastButtonPressTime = be->time; } frame.grab_x = be->x_root - frame.x - screen->getBorderWidth(); frame.grab_y = be->y_root - frame.y - screen->getBorderWidth(); if (m_windowmenu.get() && m_windowmenu->isVisible()) m_windowmenu->hide(); //raise tab first if there is any if (hasTab()) tab->raise(); screen->getWorkspace(workspace_number)->raiseWindow(this); } } else if (be->button == 2 && be->window == frame.label) { screen->getWorkspace(workspace_number)->lowerWindow(this); if (hasTab()) getTab()->lower(); //lower the tab AND it's windows } else if (m_windowmenu.get() && be->button == 3 && (frame.title == be->window || frame.label == be->window || frame.handle == be->window)) { int mx = 0, my = 0; if (frame.title == be->window || frame.label == be->window) { mx = be->x_root - (m_windowmenu->width() / 2); my = frame.y + frame.title_h; } else if (frame.handle == be->window) { mx = be->x_root - (m_windowmenu->width() / 2); my = frame.y + frame.y_handle - m_windowmenu->height(); } else { bool buttonproc=false; if (buttonproc) mx = be->x_root - (m_windowmenu->width() / 2); if (be->y <= (signed) frame.bevel_w) my = frame.y + frame.y_border; else my = be->y_root - (m_windowmenu->height() / 2); } if (mx > (signed) (frame.x + frame.width - m_windowmenu->width())) mx = frame.x + frame.width - m_windowmenu->width(); if (mx < frame.x) mx = frame.x; if (my > (signed) (frame.y + frame.y_handle - m_windowmenu->height())) my = frame.y + frame.y_handle - m_windowmenu->height(); if (my < (signed) (frame.y + ((decorations.titlebar) ? frame.title_h : frame.y_border))) my = frame.y + ((decorations.titlebar) ? frame.title_h : frame.y_border); if (m_windowmenu.get()) { if (! m_windowmenu->isVisible()) { // if not window menu is visible then show it showMenu(mx, my); } else //else hide menu m_windowmenu->hide(); } } else if (be->button == 4) { //scroll to tab right if (tab && tab->next()) { tab->next()->getWindow()->setInputFocus(); screen->getWorkspace(workspace_number)->raiseWindow(tab->next()->getWindow()); } } else if (be->button == 5) { //scroll to tab left if (tab && tab->prev()) { tab->prev()->getWindow()->setInputFocus(); screen->getWorkspace(workspace_number)->raiseWindow(tab->prev()->getWindow()); } } fluxbox->ungrab(); } void FluxboxWindow::buttonReleaseEvent(XButtonEvent *re) { Fluxbox *fluxbox = Fluxbox::instance(); fluxbox->grab(); if (! validateClient()) return; if (isMoving()) stopMoving(); else if (isResizing()) stopResizing(); else if (re->window == frame.window) { if (re->button == 2 && re->state == Mod1Mask) XUngrabPointer(display, CurrentTime); } else { if ((re->x >= 0) && ((unsigned) re->x <= frame.button_w) && (re->y >= 0) && ((unsigned) re->y <= frame.button_h)) { for (unsigned int i=0; iwindow == buttonlist[i].win && buttonlist[i].released) { buttonlist[i].released(this, re); break; } } } redrawAllButtons(); } fluxbox->ungrab(); } void FluxboxWindow::motionNotifyEvent(XMotionEvent *me) { if ((me->state & Button1Mask) && functions.move && (frame.title == me->window || frame.label == me->window || frame.handle == me->window || frame.window == me->window) && !isResizing()) { if (! isMoving()) { startMoving(me->window); } else { int dx = me->x_root - frame.grab_x, dy = me->y_root - frame.grab_y; dx -= screen->getBorderWidth(); dy -= screen->getBorderWidth(); if (screen->getEdgeSnapThreshold()) { int drx = screen->getWidth() - (dx + frame.snap_w); if (dx > 0 && dx < drx && dx < screen->getEdgeSnapThreshold()) dx = 0; else if (drx > 0 && drx < screen->getEdgeSnapThreshold()) dx = screen->getWidth() - frame.snap_w; int dtty, dbby, dty, dby; switch (screen->getToolbarPlacement()) { case Toolbar::TOPLEFT: case Toolbar::TOPCENTER: case Toolbar::TOPRIGHT: dtty = screen->getToolbar()->getExposedHeight() + screen->getBorderWidth(); dbby = screen->getHeight(); break; default: dtty = 0; dbby = screen->getToolbar()->y(); break; } dty = dy - dtty; dby = dbby - (dy + frame.snap_h); if (dy > 0 && dty < screen->getEdgeSnapThreshold()) dy = dtty; else if (dby > 0 && dby < screen->getEdgeSnapThreshold()) dy = dbby - frame.snap_h; } // Warp to next or previous workspace?, must have moved sideways some int moved_x=me->x_root - frame.resize_x; // save last event point frame.resize_x = me->x_root; frame.resize_y = me->y_root; if (moved_x && screen->isWorkspaceWarping()) { int cur_id = screen->getCurrentWorkspaceID(); int new_id = cur_id; const int warpPad = screen->getEdgeSnapThreshold(); if (me->x_root >= int(screen->getWidth()) - warpPad - 1 && frame.x < int(me->x_root - frame.grab_x - screen->getBorderWidth())) { //warp right new_id = (cur_id + 1) % screen->getCount(); dx = -me->x_root; } else if (me->x_root <= warpPad && frame.x > int(me->x_root - frame.grab_x - screen->getBorderWidth())) { //warp left new_id = (cur_id - 1 + screen->getCount()) % screen->getCount(); dx = screen->getWidth() - me->x_root-1; } if (new_id != cur_id) { XWarpPointer(display, None, None, 0, 0, 0, 0, dx, 0); screen->changeWorkspaceID(new_id); frame.resize_x = me->x_root+dx; if (!screen->doOpaqueMove()) { dx += frame.move_x; // for rectangle in correct position } else { dx += frame.x; // for window in correct position } } } if (! screen->doOpaqueMove()) { XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.move_x, frame.move_y, frame.resize_w, frame.resize_h); frame.move_x = dx; frame.move_y = dy; XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.move_x, frame.move_y, frame.resize_w, frame.resize_h); } else { configure(dx, dy, frame.width, frame.height); } if (screen->doShowWindowPos()) screen->showPosition(dx, dy); } // end if moving } else if (functions.resize && (((me->state & Button1Mask) && (me->window == frame.right_grip || me->window == frame.left_grip)) || me->window == frame.window)) { bool left = (me->window == frame.left_grip); if (! resizing) { startResizing(me, left); } else if (resizing) { XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.resize_x, frame.resize_y, frame.resize_w-1, frame.resize_h-1); int gx, gy; frame.resize_h = frame.height + (me->y - frame.grab_y); if (frame.resize_h < 1) frame.resize_h = 1; if (left) { frame.resize_x = me->x_root - frame.grab_x; if (frame.resize_x > (signed) (frame.x + frame.width)) frame.resize_x = frame.resize_x + frame.width - 1; left_fixsize(&gx, &gy); } else { frame.resize_w = frame.width + (me->x - frame.grab_x); if (frame.resize_w < 1) frame.resize_w = 1; right_fixsize(&gx, &gy); } XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.resize_x, frame.resize_y, frame.resize_w-1, frame.resize_h-1); if (screen->doShowWindowPos()) screen->showGeometry(gx, gy); } } } #ifdef SHAPE void FluxboxWindow::shapeEvent(XShapeEvent *) { Fluxbox *fluxbox = Fluxbox::instance(); if (fluxbox->hasShapeExtensions()) { if (frame.shaped) { fluxbox->grab(); if (! validateClient()) return; XShapeCombineShape(display, frame.window, ShapeBounding, frame.mwm_border_w, frame.y_border + frame.mwm_border_w, client.window, ShapeBounding, ShapeSet); int num = 1; XRectangle xrect[2]; xrect[0].x = xrect[0].y = 0; xrect[0].width = frame.width; xrect[0].height = frame.y_border; if (decorations.handle) { xrect[1].x = 0; xrect[1].y = frame.y_handle; xrect[1].width = frame.width; xrect[1].height = frame.handle_h + screen->getBorderWidth(); num++; } XShapeCombineRectangles(display, frame.window, ShapeBounding, 0, 0, xrect, num, ShapeUnion, Unsorted); fluxbox->ungrab(); } } } #endif // SHAPE void FluxboxWindow::setDecoration(Decoration decoration) { switch (decoration) { case DECOR_NONE: decorations.titlebar = decorations.border = decorations.handle = decorations.iconify = decorations.maximize = decorations.tab = false; //tab is also a decor decorations.menu = true; // menu is present functions.iconify = functions.maximize = false; functions.move = true; // We need to move even without decor functions.resize = true; // We need to resize even without decor break; default: case DECOR_NORMAL: decorations.titlebar = decorations.border = decorations.handle = decorations.iconify = decorations.maximize = decorations.menu = true; functions.resize = functions.move = functions.iconify = functions.maximize = true; XMapSubwindows(display, frame.window); XMapWindow(display, frame.window); break; case DECOR_TINY: decorations.titlebar = decorations.iconify = decorations.menu = functions.move = functions.iconify = true; decorations.border = decorations.handle = decorations.maximize = functions.resize = functions.maximize = false; XMapSubwindows(display, frame.window); XMapWindow(display, frame.window); break; case DECOR_TOOL: decorations.titlebar = decorations.menu = functions.move = true; decorations.iconify = decorations.border = decorations.handle = decorations.maximize = functions.resize = functions.maximize = functions.iconify = false; decorate(); break; } reconfigure(); } void FluxboxWindow::toggleDecoration() { static bool decor = false; //don't toggle decor if the window is shaded if (isShaded()) return; if (!decor) { //remove decorations setDecoration(DECOR_NONE); decor = true; } else { //revert back to old decoration setDecoration(old_decoration); decor = false; } } bool FluxboxWindow::validateClient() { XSync(display, false); XEvent e; if (XCheckTypedWindowEvent(display, client.window, DestroyNotify, &e) || XCheckTypedWindowEvent(display, client.window, UnmapNotify, &e)) { XPutBackEvent(display, &e); Fluxbox::instance()->ungrab(); return false; } return true; } void FluxboxWindow::startMoving(Window win) { moving = true; Fluxbox *fluxbox = Fluxbox::instance(); XGrabPointer(display, win, False, Button1MotionMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, fluxbox->getMoveCursor(), CurrentTime); if (m_windowmenu.get() && m_windowmenu->isVisible()) m_windowmenu->hide(); fluxbox->maskWindowEvents(client.window, this); if (! screen->doOpaqueMove()) { fluxbox->grab(); frame.move_x = frame.x; frame.move_y = frame.y; frame.move_ws = screen->getCurrentWorkspaceID(); frame.resize_w = frame.width + screen->getBorderWidth2x(); frame.resize_h = ((shaded) ? frame.title_h : frame.height) + screen->getBorderWidth2x(); if (screen->doShowWindowPos()) screen->showPosition(frame.x, frame.y); XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.move_x, frame.move_y, frame.resize_w, frame.resize_h); } } void FluxboxWindow::stopMoving() { moving = false; Fluxbox *fluxbox = Fluxbox::instance(); fluxbox->maskWindowEvents(0, (FluxboxWindow *) 0); if (! screen->doOpaqueMove()) { XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.move_x, frame.move_y, frame.resize_w, frame.resize_h); configure(frame.move_x, frame.move_y, frame.width, frame.height); fluxbox->ungrab(); } else configure(frame.x, frame.y, frame.width, frame.height); screen->hideGeometry(); XUngrabPointer(display, CurrentTime); XSync(display, False); //make sure the redraw is made before we continue } void FluxboxWindow::pauseMoving() { screen->hideGeometry(); // otherwise our window gets raised above it if (screen->doOpaqueMove()) { return; } // remove old rectangle XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.move_x, frame.move_y, frame.resize_w, frame.resize_h); Fluxbox::instance()->ungrab(); if (workspace_number != frame.move_ws) { // get it out of view frame.save_x = frame.x; frame.save_y = frame.y; frame.x = screen->getWidth()/2; frame.y = screen->getHeight()+screen->getTabHeight()+10; // +10 to be safe configure(frame.x, frame.y, frame.width, frame.height); } } void FluxboxWindow::resumeMoving() { if (screen->doOpaqueMove()) { setInputFocus(); screen->raiseFocus(); if (screen->doShowWindowPos()) screen->showPosition(frame.x, frame.y); return; } if (workspace_number != frame.move_ws) { frame.x = frame.save_x; frame.y = frame.save_y; } else { // back on home workspace, display window configure(frame.x, frame.y, frame.width, frame.height); } Fluxbox::instance()->grab(); setInputFocus(); screen->raiseFocus(); if (screen->doShowWindowPos()) screen->showPosition(frame.move_x, frame.move_y); XSync(display, false); XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.move_x, frame.move_y, frame.resize_w, frame.resize_h); } void FluxboxWindow::startResizing(XMotionEvent *me, bool left) { resizing = true; Fluxbox *fluxbox = Fluxbox::instance(); XGrabPointer(display, me->window, false, ButtonMotionMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, ((left) ? fluxbox->getLowerLeftAngleCursor() : fluxbox->getLowerRightAngleCursor()), CurrentTime); int gx, gy; frame.grab_x = me->x - screen->getBorderWidth(); frame.grab_y = me->y - screen->getBorderWidth2x(); frame.resize_x = frame.x; frame.resize_y = frame.y; frame.resize_w = frame.width + screen->getBorderWidth2x(); frame.resize_h = frame.height + screen->getBorderWidth2x(); if (left) left_fixsize(&gx, &gy); else right_fixsize(&gx, &gy); if (screen->doShowWindowPos()) screen->showGeometry(gx, gy); XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.resize_x, frame.resize_y, frame.resize_w-1, frame.resize_h-1); } void FluxboxWindow::stopResizing(Window win) { resizing = false; XDrawRectangle(display, screen->getRootWindow(), screen->getOpGC(), frame.resize_x, frame.resize_y, frame.resize_w-1, frame.resize_h-1); screen->hideGeometry(); if (win && win == frame.left_grip) left_fixsize(); else right_fixsize(); configure(frame.resize_x, frame.resize_y, frame.resize_w - screen->getBorderWidth2x(), frame.resize_h - screen->getBorderWidth2x()); if (tab) tab->resize(); Fluxbox::instance()->ungrab(); XUngrabPointer(display, CurrentTime); } //finds and redraw the icon label void FluxboxWindow::updateIcon() { if (Fluxbox::instance()->useIconBar()) { const IconBar *iconbar = 0; const IconBarObj *icon = 0; if ((iconbar = screen->getToolbar()->iconBar()) != 0) { if ((icon = iconbar->findIcon(this)) != 0) iconbar->draw(icon, icon->width()); } } } void FluxboxWindow::createTitlebar() { frame.title = createChildWindow(frame.window); //create titlebar win if (decorations.titlebar) { //have titlebar decorations? Fluxbox *fb = Fluxbox::instance(); fb->saveWindowSearch(frame.title, this); //save titlebar win frame.label = createChildWindow(frame.title); //create label win in titlebar fb->saveWindowSearch(frame.label, this); //save label win } } void FluxboxWindow::destroyTitlebar() { Fluxbox *fb = Fluxbox::instance(); while ( !buttonlist.empty()) { //destroy all buttons on titlebar fb->removeWindowSearch(buttonlist.back().win); XDestroyWindow(display, buttonlist.back().win); buttonlist.pop_back(); } if (frame.title) { if (frame.ftitle) { image_ctrl->removeImage(frame.ftitle); frame.ftitle = 0; } if (frame.utitle) { image_ctrl->removeImage(frame.utitle); frame.utitle = 0; } if (frame.flabel) { image_ctrl->removeImage(frame.flabel); frame.flabel = 0; } if( frame.ulabel) { image_ctrl->removeImage(frame.ulabel); frame.ulabel = 0; } fb->removeWindowSearch(frame.label); fb->removeWindowSearch(frame.title); XDestroyWindow(display, frame.label); frame.label = 0; XDestroyWindow(display, frame.title); frame.title = 0; } } void FluxboxWindow::createHandle() { if (!decorations.handle) return; Fluxbox *fluxbox = Fluxbox::instance(); frame.handle = createChildWindow(frame.window); //create handle win fluxbox->saveWindowSearch(frame.handle, this); //save handle win frame.left_grip = // create left handle createChildWindow(frame.handle, fluxbox->getLowerLeftAngleCursor()); fluxbox->saveWindowSearch(frame.left_grip, this); //save left handle frame.right_grip = // create right handle createChildWindow(frame.handle, fluxbox->getLowerRightAngleCursor()); fluxbox->saveWindowSearch(frame.right_grip, this); //save right handle } void FluxboxWindow::destroyHandle() { if (frame.fhandle) { image_ctrl->removeImage(frame.fhandle); frame.fhandle = 0; } if (frame.uhandle) { image_ctrl->removeImage(frame.uhandle); frame.uhandle = 0; } if (frame.fgrip) { image_ctrl->removeImage(frame.fgrip); frame.fgrip = 0; } if (frame.ugrip) { image_ctrl->removeImage(frame.ugrip); frame.ugrip = 0; } Fluxbox *fluxbox = Fluxbox::instance(); if (frame.right_grip != 0) { fluxbox->removeWindowSearch(frame.right_grip); XDestroyWindow(display, frame.right_grip); frame.right_grip = 0; } if (frame.left_grip != 0) { fluxbox->removeWindowSearch(frame.left_grip); XDestroyWindow(display, frame.left_grip); frame.left_grip = 0; } if (frame.handle != 0) { fluxbox->removeWindowSearch(frame.handle); XDestroyWindow(display, frame.handle); frame.handle = 0; } } void FluxboxWindow::checkTransient() { // remove us from parent if (client.transient_for != 0) { client.transient_for->client.transients.remove(this); } client.transient_for = 0; // determine if this is a transient window Window win; if (!XGetTransientForHint(display, client.window, &win)) return; if (win == client.window) return; if (win == screen->getRootWindow() && win != 0) { modal = true; return; } client.transient_for = Fluxbox::instance()->searchWindow(win); if (client.transient_for != 0 && client.window_group != None && win == client.window_group) { client.transient_for = Fluxbox::instance()->searchGroup(win, this); } // make sure we don't have deadlock loop in transient chain for (FluxboxWindow *w = this; w != 0; w = w->client.transient_for) { if (w == w->client.transient_for) { w->client.transient_for = 0; #ifdef DEBUG cerr<<"w = client.transient_for"; #endif // DEBUG break; } } if (client.transient_for != 0) { client.transient_for->client.transients.push_back(this); // make sure we only have on instance of this client.transient_for->client.transients.unique(); stuck = client.transient_for->stuck; } } void FluxboxWindow::restore(bool remap) { XChangeSaveSet(display, client.window, SetModeDelete); XSelectInput(display, client.window, NoEventMask); restoreGravity(); XUnmapWindow(display, frame.window); XUnmapWindow(display, client.window); XSetWindowBorderWidth(display, client.window, client.old_bw); XEvent dummy; if (! XCheckTypedWindowEvent(display, client.window, ReparentNotify, &dummy)) { #ifdef DEBUG fprintf(stderr, I18n::instance()->getMessage( FBNLS::WindowSet, FBNLS::WindowUnmapNotifyReparent, "FluxboxWindow::restore: reparent 0x%lx to " "root.\n"), client.window); #endif // DEBUG XReparentWindow(display, client.window, screen->getRootWindow(), client.x, client.y); } if (remap) XMapWindow(display, client.window); } void FluxboxWindow::timeout() { if (tab) tab->raise(); screen->getWorkspace(workspace_number)->raiseWindow(this); } void FluxboxWindow::changeBlackboxHints(BaseDisplay::BlackboxHints *net) { if ((net->flags & BaseDisplay::ATTRIB_SHADED) && ((blackbox_attrib.attrib & BaseDisplay::ATTRIB_SHADED) != (net->attrib & BaseDisplay::ATTRIB_SHADED))) shade(); if ((net->flags & (BaseDisplay::ATTRIB_MAXVERT | BaseDisplay::ATTRIB_MAXHORIZ)) && ((blackbox_attrib.attrib & (BaseDisplay::ATTRIB_MAXVERT | BaseDisplay::ATTRIB_MAXHORIZ)) != (net->attrib & (BaseDisplay::ATTRIB_MAXVERT | BaseDisplay::ATTRIB_MAXHORIZ)))) { if (maximized) { maximize(0); } else { int m = 0; if ((net->flags & BaseDisplay::ATTRIB_MAXHORIZ) && (net->flags & BaseDisplay::ATTRIB_MAXVERT)) m = ((net->attrib & (BaseDisplay::ATTRIB_MAXHORIZ | BaseDisplay::ATTRIB_MAXVERT)) ? 1 : 0); else if (net->flags & BaseDisplay::ATTRIB_MAXVERT) m = ((net->attrib & BaseDisplay::ATTRIB_MAXVERT) ? 2 : 0); else if (net->flags & BaseDisplay::ATTRIB_MAXHORIZ) m = ((net->attrib & BaseDisplay::ATTRIB_MAXHORIZ) ? 3 : 0); maximize(m); } } if ((net->flags & BaseDisplay::ATTRIB_OMNIPRESENT) && ((blackbox_attrib.attrib & BaseDisplay::ATTRIB_OMNIPRESENT) != (net->attrib & BaseDisplay::ATTRIB_OMNIPRESENT))) stick(); if ((net->flags & BaseDisplay::ATTRIB_WORKSPACE) && (workspace_number != net->workspace)) { if (getTab()) // disconnect from tab chain before sending it to another workspace getTab()->disconnect(); screen->reassociateWindow(this, net->workspace, true); if (screen->getCurrentWorkspaceID() != net->workspace) withdraw(); else deiconify(); } if (net->flags & BaseDisplay::ATTRIB_DECORATION) { old_decoration = static_cast(net->decoration); setDecoration(old_decoration); } } void FluxboxWindow::upsize() { // convert client.width/height into frame sizes frame.bevel_w = screen->getBevelWidth(); frame.mwm_border_w = screen->getFrameWidth() * decorations.border; frame.title_h = screen->getWindowStyle()->font.height() + (frame.bevel_w*2 + 2)*decorations.titlebar; frame.label_h = (frame.title_h - (frame.bevel_w * 2)) * decorations.titlebar; frame.button_w = frame.button_h = frame.label_h - 2; frame.y_border = (frame.title_h + screen->getBorderWidth()) * decorations.titlebar; frame.border_h = client.height + (frame.mwm_border_w * 2); frame.y_handle = frame.y_border + frame.border_h + (screen->getBorderWidth() * decorations.handle); frame.handle_h = decorations.handle * screen->getHandleWidth(); frame.grip_w = (frame.button_h * 2) * decorations.handle; frame.grip_h = screen->getHandleWidth() * decorations.handle; frame.width = client.width + (frame.mwm_border_w * 2); frame.height = frame.y_handle + frame.handle_h; frame.snap_w = frame.width + screen->getBorderWidth2x(); frame.snap_h = frame.height + screen->getBorderWidth2x(); } void FluxboxWindow::downsize() { // convert frame.width/height into client sizes frame.y_handle = frame.height - frame.handle_h; frame.border_h = frame.y_handle - frame.y_border - (screen->getBorderWidth() * decorations.handle); client.x = frame.x + frame.mwm_border_w + screen->getBorderWidth(); client.y = frame.y + frame.y_border + frame.mwm_border_w + screen->getBorderWidth(); client.width = frame.width - (frame.mwm_border_w * 2); client.height = frame.height - frame.y_border - (frame.mwm_border_w * 2) - frame.handle_h - (screen->getBorderWidth() * decorations.handle); frame.y_handle = frame.border_h + frame.y_border + screen->getBorderWidth(); frame.snap_w = frame.width + screen->getBorderWidth2x(); frame.snap_h = frame.height + screen->getBorderWidth2x(); } void FluxboxWindow::right_fixsize(int *gx, int *gy) { // calculate the size of the client window and conform it to the // size specified by the size hints of the client window... int dx = frame.resize_w - client.base_width - (frame.mwm_border_w * 2) - screen->getBorderWidth2x(); int dy = frame.resize_h - frame.y_border - client.base_height - frame.handle_h - (screen->getBorderWidth() * (2+decorations.border)) - (frame.mwm_border_w * 2); if (dx < (signed) client.min_width) dx = client.min_width; if (dy < (signed) client.min_height) dy = client.min_height; if (client.max_width > 0 && (unsigned) dx > client.max_width) dx = client.max_width; if (client.max_height > 0 && (unsigned) dy > client.max_height) dy = client.max_height; dx /= client.width_inc; dy /= client.height_inc; if (gx) *gx = dx; if (gy) *gy = dy; dx = (dx * client.width_inc) + client.base_width; dy = (dy * client.height_inc) + client.base_height; frame.resize_w = dx + (frame.mwm_border_w * 2) + screen->getBorderWidth2x(); frame.resize_h = dy + frame.y_border + frame.handle_h + (frame.mwm_border_w * 2) + (screen->getBorderWidth() * (2+decorations.border)); } void FluxboxWindow::left_fixsize(int *gx, int *gy) { // calculate the size of the client window and conform it to the // size specified by the size hints of the client window... int dx = frame.x + frame.width - frame.resize_x - client.base_width - (frame.mwm_border_w * 2); int dy = frame.resize_h - frame.y_border - client.base_height - frame.handle_h - (screen->getBorderWidth() * (2+decorations.border)) - (frame.mwm_border_w * 2); if (dx < (signed) client.min_width) dx = client.min_width; if (dy < (signed) client.min_height) dy = client.min_height; if (client.max_width > 0 && (unsigned) dx > client.max_width) dx = client.max_width; if (client.max_height > 0 && (unsigned) dy > client.max_height) dy = client.max_height; dx /= client.width_inc; dy /= client.height_inc; if (gx) *gx = dx; if (gy) *gy = dy; dx = (dx * client.width_inc) + client.base_width; dy = (dy * client.height_inc) + client.base_height; frame.resize_w = dx + (frame.mwm_border_w * 2) + screen->getBorderWidth2x(); frame.resize_x = frame.x + frame.width - frame.resize_w + screen->getBorderWidth2x(); frame.resize_h = dy + frame.y_border + frame.handle_h + (frame.mwm_border_w * 2) + (screen->getBorderWidth() * (2+decorations.border)); }