From ab2eef49371b2c9e45efea128fc84f3d556d1901 Mon Sep 17 00:00:00 2001 From: Mathias Gumz Date: Thu, 22 Jan 2015 16:28:53 +0100 Subject: Add -no-slit and -no-toolbar flags Sometimes fluxbox is used as a component of a desktop environment ( e.g., the "Lumina Desktop"). It's easier and more stable for this kind of "users" to disable the toolbar or the slit alltogether. Why not configure these features out? Because then they would need 2 installations of fluxbox: One without the slit and the toolbar (and perhaps other components) and one with them. This implements feature request #314, at least partially. This commit also looks bigger than it actually is: I refactored and cleaned up classes Fluxbox and BScreen. --- src/FbTk/Resource.hh | 3 +- src/Screen.cc | 109 +++++++++++++++-------------- src/Screen.hh | 25 +++---- src/cli_options.cc | 4 +- src/fluxbox.cc | 194 ++++++++++++++++++++++++--------------------------- src/fluxbox.hh | 190 +++++++++++++++++++++++++------------------------ 6 files changed, 265 insertions(+), 260 deletions(-) diff --git a/src/FbTk/Resource.hh b/src/FbTk/Resource.hh index 8c9d645..9690851 100644 --- a/src/FbTk/Resource.hh +++ b/src/FbTk/Resource.hh @@ -24,14 +24,13 @@ #include "NotCopyable.hh" #include "Accessor.hh" +#include "XrmDatabaseHelper.hh" #include #include #include - #include #include -#include "XrmDatabaseHelper.hh" namespace FbTk { diff --git a/src/Screen.cc b/src/Screen.cc index 5e6f38e..da4e719 100644 --- a/src/Screen.cc +++ b/src/Screen.cc @@ -189,7 +189,8 @@ void initAtoms(Display* dpy) { BScreen::BScreen(FbTk::ResourceManager &rm, const string &screenname, const string &altscreenname, - int scrn, int num_layers) : + int scrn, int num_layers, + unsigned int opts) : m_layermanager(num_layers), root_colormap_installed(false), m_image_control(0), @@ -214,19 +215,20 @@ BScreen::BScreen(FbTk::ResourceManager &rm, m_altname(altscreenname), m_focus_control(new FocusControl(*this)), m_placement_strategy(new ScreenPlacement(*this)), - m_cycling(false), m_cycle_opts(0), - m_restart(false), - m_shutdown(false) { + m_cycle_opts(0), + m_opts(opts) { + m_state.cycling = false; + m_state.restart = false; + m_state.shutdown = false; + m_state.managed = false; + Fluxbox *fluxbox = Fluxbox::instance(); Display *disp = fluxbox->display(); initAtoms(disp); - - // TODO fluxgen: check if this is the right place (it was not -lis) - // // Create the first one, initXinerama will expand this if needed. m_head_areas.resize(1); m_head_areas[0] = new HeadArea(); @@ -244,8 +246,8 @@ BScreen::BScreen(FbTk::ResourceManager &rm, XSetErrorHandler((XErrorHandler) old); - managed = running; - if (! managed) { + m_state.managed = running; + if (!m_state.managed) { delete m_placement_strategy; m_placement_strategy = 0; delete m_focus_control; m_focus_control = 0; return; @@ -261,14 +263,12 @@ BScreen::BScreen(FbTk::ResourceManager &rm, #endif // HAVE_GETPID // check if we're the first EWMH compliant window manager on this screen - Atom xa_ret_type; - int ret_format; - unsigned long ret_nitems, ret_bytes_after; + union { Atom atom; unsigned long ul; int i; } ignore; unsigned char *ret_prop; if (rootWindow().property(atom_wm_check, 0l, 1l, - False, XA_WINDOW, &xa_ret_type, &ret_format, &ret_nitems, - &ret_bytes_after, &ret_prop) ) { - m_restart = (ret_prop != NULL); + False, XA_WINDOW, &ignore.atom, &ignore.i, &ignore.ul, + &ignore.ul, &ret_prop) ) { + m_state.restart = (ret_prop != NULL); XFree(ret_prop); } @@ -362,7 +362,7 @@ BScreen::BScreen(FbTk::ResourceManager &rm, // check which desktop we should start on int first_desktop = 0; - if (m_restart) { + if (m_state.restart) { bool exists; int ret = (rootWindow().cardinalProperty(atom_net_desktop, &exists)); if (exists) { @@ -373,8 +373,10 @@ BScreen::BScreen(FbTk::ResourceManager &rm, changeWorkspaceID(first_desktop); #ifdef USE_SLIT - m_slit.reset(new Slit(*this, *layerManager().getLayer(ResourceLayer::DESKTOP), - fluxbox->getSlitlistFilename().c_str())); + if (opts & Fluxbox::OPT_SLIT) { + Slit* slit = new Slit(*this, *layerManager().getLayer(ResourceLayer::DESKTOP), fluxbox->getSlitlistFilename().c_str()); + m_slit.reset(slit); + } #endif // USE_SLIT rm.unlock(); @@ -386,7 +388,7 @@ BScreen::BScreen(FbTk::ResourceManager &rm, BScreen::~BScreen() { - if (! managed) + if (!m_state.managed) return; m_toolbar.reset(0); @@ -445,19 +447,23 @@ BScreen::~BScreen() { } bool BScreen::isRestart() { - return Fluxbox::instance()->isStartup() && m_restart; + return Fluxbox::instance()->isStartup() && m_state.restart; } void BScreen::initWindows() { #ifdef USE_TOOLBAR - m_toolbar.reset(new Toolbar(*this, - *layerManager().getLayer(::ResourceLayer::NORMAL))); + if (m_opts & Fluxbox::OPT_TOOLBAR) { + Toolbar* tb = new Toolbar(*this, *layerManager().getLayer(::ResourceLayer::NORMAL)); + m_toolbar.reset(tb); + } #endif // USE_TOOLBAR unsigned int nchild; Window r, p, *children; - Display *disp = FbTk::App::instance()->display(); + Fluxbox* fluxbox = Fluxbox::instance(); + Display* disp = fluxbox->display(); + XQueryTree(disp, rootWindow().window(), &r, &p, &children, &nchild); // preen the window list of all icon windows... for better dockapp support @@ -483,10 +489,8 @@ void BScreen::initWindows() { } XFree(wmhints); } - } - Fluxbox *fluxbox = Fluxbox::instance(); // manage shown windows Window transient_for = 0; @@ -611,8 +615,8 @@ void BScreen::focusedWinFrameThemeReconfigured() { Fluxbox *fluxbox = Fluxbox::instance(); const std::list winlist = focusControl().focusedOrderWinList().clientList(); - std::list::const_iterator it = winlist.begin(), - it_end = winlist.end(); + std::list::const_iterator it = winlist.begin(); + std::list::const_iterator it_end = winlist.end(); for (; it != it_end; ++it) fluxbox->updateFrameExtents(*(*it)->fbwindow()); @@ -661,14 +665,15 @@ void BScreen::keyPressEvent(XKeyEvent &ke) { } void BScreen::keyReleaseEvent(XKeyEvent &ke) { - if (m_cycling) { + if (m_state.cycling) { + unsigned int state = FbTk::KeyUtil::instance().cleanMods(ke.state); state &= ~FbTk::KeyUtil::instance().keycodeToModmask(ke.keycode); if (state) // still cycling return; - m_cycling = false; + m_state.cycling = false; focusControl().stopCyclingFocus(); } if (!Fluxbox::instance()->keys()->inKeychain()) @@ -693,8 +698,8 @@ void BScreen::cycleFocus(int options, const ClientPattern *pat, bool reverse) { else if (ev.type == ButtonPress) mods = FbTk::KeyUtil::instance().cleanMods(ev.xbutton.state); - if (!m_cycling && mods) { - m_cycling = true; + if (!m_state.cycling && mods) { + m_state.cycling = true; FbTk::EventManager::instance()->grabKeyboard(rootWindow().window()); } @@ -849,13 +854,12 @@ void BScreen::removeClient(WinClient &client) { int BScreen::addWorkspace() { bool save_name = getNameOfWorkspace(m_workspaces_list.size()) == ""; - Workspace *wkspc = new Workspace(*this, - getNameOfWorkspace(m_workspaces_list.size()), - m_workspaces_list.size()); - m_workspaces_list.push_back(wkspc); + std::string name = getNameOfWorkspace(m_workspaces_list.size()); + Workspace *ws = new Workspace(*this, name, m_workspaces_list.size()); + m_workspaces_list.push_back(ws); if (save_name) { - addWorkspaceName(wkspc->name().c_str()); + addWorkspaceName(ws->name().c_str()); m_workspacenames_sig.emit(*this); } @@ -1065,7 +1069,9 @@ bool BScreen::addKdeDockapp(Window client) { } FluxboxWindow *BScreen::createWindow(Window client) { - FbTk::App::instance()->sync(false); + + Fluxbox* fluxbox = Fluxbox::instance(); + fluxbox->sync(false); if (isKdeDockapp(client) && addKdeDockapp(client)) { return 0; // dont create a FluxboxWindow for this one @@ -1084,14 +1090,14 @@ FluxboxWindow *BScreen::createWindow(Window client) { } // check if it should be grouped with something else - FluxboxWindow *win; - WinClient *other; - if ((other = findGroupLeft(*winclient)) && (win = other->fbwindow())) { + WinClient* other = findGroupLeft(*winclient); + FluxboxWindow* win = other ? other->fbwindow() : 0; + + if (other && win) { win->attachClient(*winclient); - Fluxbox::instance()->attachSignals(*winclient); + fluxbox->attachSignals(*winclient); } else { - - Fluxbox::instance()->attachSignals(*winclient); + fluxbox->attachSignals(*winclient); if (winclient->fbwindow()) { // may have been set in an atomhandler win = winclient->fbwindow(); Workspace *workspace = getWorkspace(win->workspaceNumber()); @@ -1109,7 +1115,7 @@ FluxboxWindow *BScreen::createWindow(Window client) { // add the window to the focus list // always add to front on startup to keep the focus order the same - if (win->isFocused() || Fluxbox::instance()->isStartup()) + if (win->isFocused() || fluxbox->isStartup()) focusControl().addFocusFront(*winclient); else focusControl().addFocusBack(*winclient); @@ -1123,7 +1129,7 @@ FluxboxWindow *BScreen::createWindow(Window client) { m_clientlist_sig.emit(*this); - FbTk::App::instance()->sync(false); + fluxbox->sync(false); return win; } @@ -1386,7 +1392,7 @@ void BScreen::setupConfigmenu(FbTk::Menu &menu) { void BScreen::shutdown() { rootWindow().setEventMask(NoEventMask); FbTk::App::instance()->sync(false); - m_shutdown = true; + m_state.shutdown = true; m_focus_control->shutdown(); for_each(m_workspaces_list.begin(), m_workspaces_list.end(), @@ -1701,15 +1707,12 @@ int BScreen::getCurrHead() const { if (!hasXinerama()) return 0; int root_x = 0, root_y = 0; #ifdef XINERAMA - int ignore_i; - unsigned int ignore_ui; - - Window ignore_w; + union { int i; unsigned int ui; Window w; } ignore; XQueryPointer(FbTk::App::instance()->display(), - rootWindow().window(), &ignore_w, - &ignore_w, &root_x, &root_y, - &ignore_i, &ignore_i, &ignore_ui); + rootWindow().window(), &ignore.w, + &ignore.w, &root_x, &root_y, + &ignore.i, &ignore.i, &ignore.ui); #endif // XINERAMA return getHead(root_x, root_y); } diff --git a/src/Screen.hh b/src/Screen.hh index c9a6ede..983aa81 100644 --- a/src/Screen.hh +++ b/src/Screen.hh @@ -79,20 +79,19 @@ class FbWindow; class BScreen: public FbTk::EventHandler, private FbTk::NotCopyable { public: typedef std::list Icons; - typedef std::vector Workspaces; typedef std::vector WorkspaceNames; BScreen(FbTk::ResourceManager &rm, const std::string &screenname, const std::string &altscreenname, - int scrn, int number_of_layers); + int scrn, int number_of_layers, unsigned int opts); ~BScreen(); void initWindows(); void initMenus(); bool isRootColormapInstalled() const { return root_colormap_installed; } - bool isScreenManaged() const { return managed; } + bool isScreenManaged() const { return m_state.managed; } bool isWorkspaceWarping() const { return (m_workspaces_list.size() > 1) && *resource.workspace_warping; } bool doAutoRaise() const { return *resource.auto_raise; } bool clickRaises() const { return *resource.click_raises; } @@ -222,7 +221,7 @@ public: */ void cycleFocus(int opts = 0, const ClientPattern *pat = 0, bool reverse = false); - bool isCycling() const { return m_cycling; } + bool isCycling() const { return m_state.cycling; } /** * For extras to add menus. @@ -267,7 +266,7 @@ public: const FbTk::ResourceManager &resourceManager() const { return m_resource_manager; } const std::string &name() const { return m_name; } const std::string &altName() const { return m_altname; } - bool isShuttingdown() const { return m_shutdown; } + bool isShuttingdown() const { return m_state.shutdown; } bool isRestart(); ScreenPlacement &placementStrategy() { return *m_placement_strategy; } @@ -479,8 +478,8 @@ private: Icons m_icon_list; - std::auto_ptr m_slit; - std::auto_ptr m_toolbar; + std::auto_ptr m_slit; + std::auto_ptr m_toolbar; Workspace *m_current_workspace; @@ -516,7 +515,6 @@ private: typedef std::map Groupables; Groupables m_expecting_groups; - bool m_cycling; const ClientPattern *m_cycle_opts; // Xinerama related private data @@ -536,10 +534,13 @@ private: std::vector m_head_areas; - - bool m_restart; - bool m_shutdown; - bool managed; + struct { + bool cycling; + bool restart; + bool shutdown; + bool managed; + } m_state; + unsigned int m_opts; // hold Fluxbox::OPT_SLIT etc }; diff --git a/src/cli_options.cc b/src/cli_options.cc index 3003070..9e30af7 100644 --- a/src/cli_options.cc +++ b/src/cli_options.cc @@ -129,6 +129,8 @@ int FluxboxCli::Options::parse(int argc, char** argv) { "-display \t\tuse display connection.\n" "-screen \trun on specified screens only.\n" "-rc \t\t\tuse alternate resource file.\n" + "-no-slit\t\t\tdo not provide a slit.\n" + "-no-toolbar\t\t\tdo not provide a toolbar.\n" "-version\t\t\tdisplay version and exit.\n" "-info\t\t\t\tdisplay some useful information.\n" "-list-commands\t\t\tlist all valid key commands.\n" @@ -136,7 +138,7 @@ int FluxboxCli::Options::parse(int argc, char** argv) { "-log \t\t\tlog output to file.\n" "-help\t\t\t\tdisplay this help text and exit.\n\n", - "Main usage string. Please lay it out nicely. There is one %s that is given the version").c_str(), + "Main usage string. Please lay it out nicely. One %%s gives the version, ther other gives the year").c_str(), __fluxbox_version, "2001-2015"); return EXIT_SUCCESS; } else if (arg == "-info" || arg == "-i" || arg == "--info") { diff --git a/src/fluxbox.cc b/src/fluxbox.cc index 9b787f7..c5d85a6 100644 --- a/src/fluxbox.cc +++ b/src/fluxbox.cc @@ -81,10 +81,6 @@ // system headers -#include -#include -#include - #ifdef HAVE_UNISTD_H #include #include @@ -111,6 +107,10 @@ #include #include #include +#include +#include +#include + using std::cerr; using std::endl; @@ -230,54 +230,54 @@ int s_randr_event_type = 0; ///< the type number of randr event int s_shape_eventbase = 0; ///< event base for shape events bool s_have_shape = false ; ///< if shape is supported by server -Atom s_kwm1_dockwindow; -Atom s_kwm2_dockwindow; - Fluxbox* s_singleton = 0; } // end anonymous +bool Fluxbox::haveShape() const { return s_have_shape; } +int Fluxbox::shapeEventbase() const { return s_shape_eventbase; } +Fluxbox* Fluxbox::instance() { return s_singleton; } + +Fluxbox::Config::Config(FbTk::ResourceManager& rm, const std::string& path) : + ignore_border(rm, false, "session.ignoreBorder", "Session.IgnoreBorder"), + pseudotrans(rm, false, "session.forcePseudoTransparency", "Session.forcePseudoTransparency"), + colors_per_channel(rm, 4, "session.colorsPerChannel", "Session.ColorsPerChannel"), + double_click_interval(rm, 250, "session.doubleClickInterval", "Session.DoubleClickInterval"), + tabs_padding(rm, 0, "session.tabPadding", "Session.TabPadding"), + style_file(rm, DEFAULTSTYLE, "session.styleFile", "Session.StyleFile"), + overlay_file(rm, path + "/overlay", "session.styleOverlay", "Session.StyleOverlay"), + menu_file(rm, path + "/menu", "session.menuFile", "Session.MenuFile"), + key_file(rm, path + "/keys", "session.keyFile", "Session.KeyFile"), + slit_file(rm, path + "/slitlist", "session.slitlistFile", "Session.SlitlistFile"), + apps_file(rm, path + "/apps", "session.appsFile", "Session.AppsFile"), + tabs_attach_area(rm, ATTACH_AREA_WINDOW, "session.tabsAttachArea", "Session.TabsAttachArea"), + cache_life(rm, 5, "session.cacheLife", "Session.CacheLife"), + cache_max(rm, 200, "session.cacheMax", "Session.CacheMax"), + auto_raise_delay(rm, 250, "session.autoRaiseDelay", "Session.AutoRaiseDelay") { +} + Fluxbox::Fluxbox(int argc, char **argv, const std::string& dpy_name, const std::string& rc_path, const std::string& rc_filename, bool xsync) : FbTk::App(dpy_name.c_str()), m_fbatoms(FbAtoms::instance()), m_resourcemanager(rc_filename.c_str(), true), - // TODO: shouldn't need a separate one for screen - m_screen_rm(m_resourcemanager), - - m_RC_PATH(rc_path), - m_rc_ignoreborder(m_resourcemanager, false, "session.ignoreBorder", "Session.IgnoreBorder"), - m_rc_pseudotrans(m_resourcemanager, false, "session.forcePseudoTransparency", "Session.forcePseudoTransparency"), - m_rc_colors_per_channel(m_resourcemanager, 4, - "session.colorsPerChannel", "Session.ColorsPerChannel"), - m_rc_double_click_interval(m_resourcemanager, 250, "session.doubleClickInterval", "Session.DoubleClickInterval"), - m_rc_tabs_padding(m_resourcemanager, 0, "session.tabPadding", "Session.TabPadding"), - m_rc_stylefile(m_resourcemanager, DEFAULTSTYLE, "session.styleFile", "Session.StyleFile"), - m_rc_styleoverlayfile(m_resourcemanager, m_RC_PATH + "/overlay", "session.styleOverlay", "Session.StyleOverlay"), - m_rc_menufile(m_resourcemanager, m_RC_PATH + "/menu", "session.menuFile", "Session.MenuFile"), - m_rc_keyfile(m_resourcemanager, m_RC_PATH + "/keys", "session.keyFile", "Session.KeyFile"), - m_rc_slitlistfile(m_resourcemanager, m_RC_PATH + "/slitlist", "session.slitlistFile", "Session.SlitlistFile"), - m_rc_appsfile(m_resourcemanager, m_RC_PATH + "/apps", "session.appsFile", "Session.AppsFile"), - m_rc_tabs_attach_area(m_resourcemanager, ATTACH_AREA_WINDOW, "session.tabsAttachArea", "Session.TabsAttachArea"), - m_rc_cache_life(m_resourcemanager, 5, "session.cacheLife", "Session.CacheLife"), - m_rc_cache_max(m_resourcemanager, 200, "session.cacheMax", "Session.CacheMax"), - m_rc_auto_raise_delay(m_resourcemanager, 250, "session.autoRaiseDelay", "Session.AutoRaiseDelay"), - m_masked_window(0), - m_mousescreen(0), - m_keyscreen(0), + m_screen_rm(m_resourcemanager), // TODO: shouldn't need a separate one for screen + m_config(m_resourcemanager, rc_path), m_last_time(0), m_masked(0), - m_rc_file(rc_filename), + m_masked_window(0), m_argv(argv), m_argc(argc), m_showing_dialog(false), - m_starting(true), - m_restarting(false), - m_shutdown(false), m_server_grabs(0) { _FB_USES_NLS; + + m_state.restarting = false; + m_state.shutdown = false; + m_state.starting = true; + if (s_singleton != 0) throw _FB_CONSOLETEXT(Fluxbox, FatalSingleton, "Fatal! There can only one instance of fluxbox class.", "Error displayed on weird error where an instance of the Fluxbox class already exists!"); @@ -287,14 +287,12 @@ Fluxbox::Fluxbox(int argc, char **argv, "Error message when no X display appears to exist"); } + m_config.file = rc_filename; + m_active_screen.mouse = 0; + m_active_screen.key = 0; + Display *disp = FbTk::App::instance()->display(); - // For KDE dock applets - // KDE v1.x - s_kwm1_dockwindow = XInternAtom(disp, - "KWM_DOCKWINDOW", False); - // KDE v2.x - s_kwm2_dockwindow = XInternAtom(disp, - "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR", False); + // setup X error handler XSetErrorHandler(handleXErrors); XSetIOErrorHandler(handleXIOErrors); @@ -362,6 +360,8 @@ Fluxbox::Fluxbox(int argc, char **argv, m_key.reset(new Keys); m_key->reconfigure(); + + unsigned int opts = OPT_SLIT|OPT_TOOLBAR; vector screens; int i; @@ -396,16 +396,21 @@ Fluxbox::Fluxbox(int argc, char **argv, if (!vals.empty()) swap(scrtmp, screens); + } else if (!strcmp(m_argv[i], "-no-slit")) { + opts &= ~OPT_SLIT; + } else if (!strcmp(m_argv[i], "-no-toolbar")) { + opts &= ~OPT_TOOLBAR; } } + // create screens - for (size_t s = 0; s < screens.size(); s++) { - std::string sc_nr = FbTk::StringUtil::number2String(screens[s]); + for (i = 0; i < static_cast(screens.size()); i++) { + std::string sc_nr = FbTk::StringUtil::number2String(screens[i]); BScreen *screen = new BScreen(m_screen_rm.lock(), std::string("session.screen") + sc_nr, std::string("session.Screen") + sc_nr, - screens[s], ::ResourceLayer::NUM_LAYERS); + screens[i], ::ResourceLayer::NUM_LAYERS, opts); // already handled if (! screen->isScreenManaged()) { @@ -414,16 +419,16 @@ Fluxbox::Fluxbox(int argc, char **argv, } // add to our list - m_screen_list.push_back(screen); + m_screens.push_back(screen); } - if (m_screen_list.empty()) { + if (m_screens.empty()) { throw _FB_CONSOLETEXT(Fluxbox, ErrorNoScreens, "Couldn't find screens to manage.\nMake sure you don't have another window manager running.", "Error message when no unmanaged screens found - usually means another window manager is running"); } - m_keyscreen = m_mousescreen = m_screen_list.front(); + m_active_screen.key = m_active_screen.mouse = m_screens.front(); #ifdef USE_EWMH addAtomHandler(new Ewmh()); @@ -437,7 +442,7 @@ Fluxbox::Fluxbox(int argc, char **argv, #endif // REMEMBER // init all "screens" - STLUtil::forAll(m_screen_list, bind1st(mem_fun(&Fluxbox::initScreen), this)); + STLUtil::forAll(m_screens, bind1st(mem_fun(&Fluxbox::initScreen), this)); XAllowEvents(disp, ReplayPointer, CurrentTime); @@ -453,7 +458,7 @@ Fluxbox::Fluxbox(int argc, char **argv, fbdbg<<"--- resource manager lockdepth = "<type == KeyPress || e->type == KeyRelease) { - m_keyscreen = searchScreen(e->xkey.root); + m_active_screen.key = searchScreen(e->xkey.root); } else if (e->type == ButtonPress || e->type == ButtonRelease || e->type == MotionNotify ) { + m_last_time = e->xbutton.time; if (e->type == MotionNotify) m_last_time = e->xmotion.time; - else - m_last_time = e->xbutton.time; - m_mousescreen = searchScreen(e->xbutton.root); + m_active_screen.mouse = searchScreen(e->xbutton.root); } else if (e->type == EnterNotify || e->type == LeaveNotify) { m_last_time = e->xcrossing.time; - m_mousescreen = searchScreen(e->xcrossing.root); + m_active_screen.mouse = searchScreen(e->xcrossing.root); } else if (e->type == PropertyNotify) { m_last_time = e->xproperty.time; // check transparency atoms if it's a root pm @@ -632,7 +636,7 @@ void Fluxbox::handleEvent(XEvent * const e) { xwc.sibling = e->xconfigurerequest.above; xwc.stack_mode = e->xconfigurerequest.detail; - XConfigureWindow(FbTk::App::instance()->display(), + XConfigureWindow(display(), e->xconfigurerequest.window, e->xconfigurerequest.value_mask, &xwc); } @@ -760,14 +764,14 @@ void Fluxbox::handleEvent(XEvent * const e) { if (FbTk::Menu::focused() && FbTk::Menu::focused()->window() == e->xfocus.window) { - m_keyscreen = findScreen(FbTk::Menu::focused()->screenNumber()); + m_active_screen.key = findScreen(FbTk::Menu::focused()->screenNumber()); FocusControl::setFocusedWindow(0); break; } WinClient *winclient = searchWindow(e->xfocus.window); if (winclient) - m_keyscreen = &winclient->screen(); + m_active_screen.key = &winclient->screen(); FocusControl::setFocusedWindow(winclient); } break; @@ -981,8 +985,8 @@ BScreen *Fluxbox::searchScreen(Window window) { return 0; } - ScreenList::iterator it = m_screen_list.begin(); - ScreenList::iterator it_end = m_screen_list.end(); + ScreenList::iterator it = m_screens.begin(); + ScreenList::iterator it_end = m_screens.end(); for (; it != it_end; ++it) { if (*it && (*it)->rootWindow() == window_root) return *it; @@ -1058,9 +1062,9 @@ void Fluxbox::removeGroupSearch(Window window) { /// restarts fluxbox void Fluxbox::restart(const char *prog) { - shutdown(); - m_restarting = true; + shutdown(); + m_state.restarting = true; if (prog && *prog != '\0') { m_restart_argument = prog; @@ -1072,11 +1076,11 @@ void Fluxbox::restart(const char *prog) { // already. trying to cleanup over a shaky xserver connection is pointless and // might lead to hangups. void Fluxbox::shutdown(int x_wants_down) { - if (m_shutdown) + if (m_state.shutdown) return; Display *dpy = FbTk::App::instance()->display(); - m_shutdown = true; + m_state.shutdown = true; #ifdef HAVE_ALARM // give ourself 2 seconds (randomly picked randon number) to shutdown @@ -1088,7 +1092,7 @@ void Fluxbox::shutdown(int x_wants_down) { XSetInputFocus(dpy, PointerRoot, None, CurrentTime); if (x_wants_down == 0) { - STLUtil::forAll(m_screen_list, mem_fun(&BScreen::shutdown)); + STLUtil::forAll(m_screens, mem_fun(&BScreen::shutdown)); sync(false); } } @@ -1107,8 +1111,8 @@ void Fluxbox::save_rc() { cerr<<_FB_CONSOLETEXT(Fluxbox, BadRCFile, "rc filename is invalid!", "Bad settings file")<empty()) - m_rc_menufile.setDefaultValue(); + if (m_config.menu_file->empty()) + m_config.menu_file.setDefaultValue(); - FbTk::Transparent::usePseudoTransparent(*m_rc_pseudotrans); + FbTk::Transparent::usePseudoTransparent(*m_config.pseudotrans); - if (m_rc_slitlistfile->empty()) { + if (m_config.slit_file->empty()) { string filename = getDefaultDataFilename("slitlist"); - m_rc_slitlistfile.setFromString(filename.c_str()); + m_config.slit_file.setFromString(filename.c_str()); } - *m_rc_colors_per_channel = FbTk::Util::clamp(*m_rc_colors_per_channel, 2, 6); + *m_config.colors_per_channel = FbTk::Util::clamp(*m_config.colors_per_channel, 2, 6); - if (m_rc_stylefile->empty()) - *m_rc_stylefile = DEFAULTSTYLE; + if (m_config.style_file->empty()) + *m_config.style_file = DEFAULTSTYLE; } void Fluxbox::load_rc(BScreen &screen) { @@ -1198,7 +1202,6 @@ void Fluxbox::load_rc(BScreen &screen) { if (database==0) database = XrmGetFileDatabase(DEFAULT_INITFILE); - screen.removeWorkspaceNames(); std::string screen_number = FbTk::StringUtil::number2String(screen.screenNumber()); @@ -1252,14 +1255,14 @@ void Fluxbox::reconfigure() { void Fluxbox::real_reconfigure() { - FbTk::Transparent::usePseudoTransparent(*m_rc_pseudotrans); + FbTk::Transparent::usePseudoTransparent(*m_config.pseudotrans); - ScreenList::iterator screen_it = m_screen_list.begin(); - ScreenList::iterator screen_it_end = m_screen_list.end(); + ScreenList::iterator screen_it = m_screens.begin(); + ScreenList::iterator screen_it_end = m_screens.end(); for (; screen_it != screen_it_end; ++screen_it) load_rc(*(*screen_it)); - STLUtil::forAll(m_screen_list, mem_fun(&BScreen::reconfigure)); + STLUtil::forAll(m_screens, mem_fun(&BScreen::reconfigure)); m_key->reconfigure(); STLUtil::forAll(m_atomhandler, mem_fun(&AtomHandler::reconfigure)); } @@ -1267,10 +1270,10 @@ void Fluxbox::real_reconfigure() { BScreen *Fluxbox::findScreen(int id) { BScreen* result = 0; - ScreenList::iterator it = find_if(m_screen_list.begin(), m_screen_list.end(), + ScreenList::iterator it = find_if(m_screens.begin(), m_screens.end(), FbTk::CompareEqual(&BScreen::screenNumber, id)); - if (it != m_screen_list.end()) + if (it != m_screens.end()) result = *it; return result; @@ -1284,8 +1287,8 @@ void Fluxbox::timed_reconfigure() { } void Fluxbox::revertFocus() { - bool revert = m_keyscreen && !m_showing_dialog; + bool revert = m_active_screen.key && !m_showing_dialog; if (revert) { // see if there are any more focus events in the queue XEvent ev; @@ -1301,12 +1304,12 @@ void Fluxbox::revertFocus() { // we only want to revert focus if it's left dangling, as some other // application may have set the focus to an unmanaged window if (win != None && win != PointerRoot && !searchWindow(win) && - win != m_keyscreen->rootWindow().window()) + win != m_active_screen.key->rootWindow().window()) revert = false; } if (revert) - FocusControl::revertFocus(*m_keyscreen); + FocusControl::revertFocus(*m_active_screen.key); else FocusControl::setFocusedWindow(0); } @@ -1360,17 +1363,4 @@ void Fluxbox::workspaceAreaChanged(BScreen &screen) { CallMemFunWithRefArg(&AtomHandler::updateWorkarea, screen)); } -bool Fluxbox::haveShape() const { - return s_have_shape; -} - -int Fluxbox::shapeEventbase() const { - return s_shape_eventbase; -} - -Fluxbox* Fluxbox::instance() { - return s_singleton; -} - - diff --git a/src/fluxbox.hh b/src/fluxbox.hh index d0bc239..df0335a 100644 --- a/src/fluxbox.hh +++ b/src/fluxbox.hh @@ -34,16 +34,6 @@ #include -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif // HAVE_CONFIG_H - -#ifdef HAVE_CSTDIO - #include -#else - #include -#endif - #ifdef TIME_WITH_SYS_TIME #include #include @@ -60,6 +50,7 @@ #include #include #include +#include class AtomHandler; class FluxboxWindow; @@ -75,61 +66,71 @@ class FbAtoms; class Fluxbox : public FbTk::App, private FbTk::SignalTracker { public: + + typedef std::list ScreenList; + + enum { + OPT_TOOLBAR = 1 << 0, + OPT_SLIT = 1 << 1 + }; + + /// obsolete + enum TabsAttachArea{ATTACH_AREA_WINDOW= 0, ATTACH_AREA_TITLEBAR}; + + + static Fluxbox *instance(); + + Fluxbox(int argc, char **argv, const std::string& dpy_name, const std::string& rc_path, const std::string& rc_filename, bool xsync = false); virtual ~Fluxbox(); - static Fluxbox *instance(); /// main event loop void eventLoop(); - bool validateWindow(Window win) const; - bool validateClient(const WinClient *client) const; void grab(); void ungrab(); Keys *keys() { return m_key.get(); } Atom getFluxboxPidAtom() const { return m_fluxbox_pid; } - // Not currently implemented until we decide how it'll be used - //WinClient *searchGroup(Window); - WinClient *searchWindow(Window); void initScreen(BScreen *screen); + + WinClient *searchWindow(Window); BScreen *searchScreen(Window w); + bool validateWindow(Window win) const; + bool validateClient(const WinClient *client) const; + + // Not currently implemented until we decide how it'll be used + //WinClient *searchGroup(Window); - unsigned int getDoubleClickInterval() const { return *m_rc_double_click_interval; } Time getLastTime() const { return m_last_time; } AtomHandler *getAtomHandler(const std::string &name); void addAtomHandler(AtomHandler *atomh); void removeAtomHandler(AtomHandler *atomh); - /// obsolete - enum TabsAttachArea{ATTACH_AREA_WINDOW= 0, ATTACH_AREA_TITLEBAR}; - - - bool getIgnoreBorder() const { return *m_rc_ignoreborder; } - bool &getPseudoTrans() { return *m_rc_pseudotrans; } - - Fluxbox::TabsAttachArea getTabsAttachArea() const { return *m_rc_tabs_attach_area; } - const std::string &getStyleFilename() const { return *m_rc_stylefile; } - const std::string &getStyleOverlayFilename() const { return *m_rc_styleoverlayfile; } - - const std::string &getMenuFilename() const { return *m_rc_menufile; } - const std::string &getSlitlistFilename() const { return *m_rc_slitlistfile; } - const std::string &getAppsFilename() const { return *m_rc_appsfile; } - const std::string &getKeysFilename() const { return *m_rc_keyfile; } - int colorsPerChannel() const { return *m_rc_colors_per_channel; } - int getTabsPadding() const { return *m_rc_tabs_padding; } - - time_t getAutoRaiseDelay() const { return *m_rc_auto_raise_delay; } + std::string getDefaultDataFilename(const char *name) const; - unsigned int getCacheLife() const { return *m_rc_cache_life * 60000; } - unsigned int getCacheMax() const { return *m_rc_cache_max; } + bool &getPseudoTrans() { return *m_config.pseudotrans; } + bool getIgnoreBorder() const { return *m_config.ignore_border; } + Fluxbox::TabsAttachArea getTabsAttachArea() const { return *m_config.tabs_attach_area; } + const std::string &getStyleFilename() const { return *m_config.style_file; } + const std::string &getStyleOverlayFilename() const { return *m_config.overlay_file; } + const std::string &getMenuFilename() const { return *m_config.menu_file; } + const std::string &getSlitlistFilename() const { return *m_config.slit_file; } + const std::string &getAppsFilename() const { return *m_config.apps_file; } + const std::string &getKeysFilename() const { return *m_config.key_file; } + int colorsPerChannel() const { return *m_config.colors_per_channel; } + int getTabsPadding() const { return *m_config.tabs_padding; } + unsigned int getDoubleClickInterval() const { return *m_config.double_click_interval; } + time_t getAutoRaiseDelay() const { return *m_config.auto_raise_delay; } + unsigned int getCacheLife() const { return *m_config.cache_life * 60000; } + unsigned int getCacheMax() const { return *m_config.cache_max; } void maskWindowEvents(Window w, FluxboxWindow *bw) @@ -137,7 +138,7 @@ public: void shutdown(int x_wants_down = 0); void load_rc(BScreen &scr); - void saveStyleFilename(const char *val) { m_rc_stylefile = (val == 0 ? "" : val); } + void saveStyleFilename(const char *val) { m_config.style_file = (val == 0 ? "" : val); } void saveWindowSearch(Window win, WinClient *winclient); // some windows relate to the group, not the client, so we record separately // searchWindow on these windows will give the active client in the group @@ -162,25 +163,23 @@ public: m_showing_dialog = value; if (!value) revertFocus(); } - bool isStartup() const { return m_starting; } - bool isRestarting() const { return m_restarting; } - bool isShuttingDown() const { return m_shutdown; } + bool isStartup() const { return m_state.starting; } + bool isRestarting() const { return m_state.restarting; } + bool isShuttingDown() const { return m_state.shutdown; } const std::string &getRestartArgument() const { return m_restart_argument; } /// get screen from number BScreen *findScreen(int num); - typedef std::list ScreenList; - const ScreenList screenList() const { return m_screen_list; } + const ScreenList screenList() const { return m_screens; } bool haveShape() const; int shapeEventbase() const; - std::string getDefaultDataFilename(const char *name) const; - // screen mouse was in at last key event - BScreen *mouseScreen() { return m_mousescreen; } - // screen of window that last key event (i.e. focused window) went to - BScreen *keyScreen() { return m_keyscreen; } + + + BScreen *mouseScreen() { return m_active_screen.mouse; } + BScreen *keyScreen() { return m_active_screen.key; } const XEvent &lastEvent() const { return m_last_event; } AttentionNoticeHandler &attentionHandler() { return m_attention_handler; } @@ -188,11 +187,8 @@ public: private: std::string getRcFilename(); void load_rc(); - void real_reconfigure(); - void handleEvent(XEvent *xe); - void handleUnmapNotify(XUnmapEvent &ue); void handleClientMessage(XClientMessageEvent &ce); @@ -222,33 +218,53 @@ private: /// Called when a window layer changes void windowLayerChanged(FluxboxWindow &win); - std::auto_ptr m_fbatoms; - FbTk::ResourceManager m_resourcemanager, &m_screen_rm; + typedef std::map WinClientMap; + typedef std::map WindowMap; + typedef std::set AtomHandlerContainer; + typedef AtomHandlerContainer::iterator AtomHandlerContainerIt; - std::string m_RC_PATH; //--- Resources - FbTk::Resource m_rc_ignoreborder; - FbTk::Resource m_rc_pseudotrans; - FbTk::Resource m_rc_colors_per_channel, - m_rc_double_click_interval, - m_rc_tabs_padding; - FbTk::Resource m_rc_stylefile, - m_rc_styleoverlayfile, - m_rc_menufile, m_rc_keyfile, m_rc_slitlistfile, - m_rc_appsfile; + std::auto_ptr m_fbatoms; + FbTk::ResourceManager m_resourcemanager; + FbTk::ResourceManager& m_screen_rm; + struct Config { + Config(FbTk::ResourceManager& rm, const std::string& path); - FbTk::Resource m_rc_tabs_attach_area; - FbTk::Resource m_rc_cache_life, m_rc_cache_max; - FbTk::Resource m_rc_auto_raise_delay; + std::string path; + std::string file; + + FbTk::Resource ignore_border; + FbTk::Resource pseudotrans; + FbTk::Resource colors_per_channel; + FbTk::Resource double_click_interval; + FbTk::Resource tabs_padding; + + FbTk::Resource style_file; + FbTk::Resource overlay_file; + FbTk::Resource menu_file; + FbTk::Resource key_file; + FbTk::Resource slit_file; + FbTk::Resource apps_file; + + FbTk::Resource tabs_attach_area; + FbTk::Resource cache_life; + FbTk::Resource cache_max; + FbTk::Resource auto_raise_delay; + } m_config; + + + std::auto_ptr m_key; + AtomHandlerContainer m_atomhandler; + AttentionNoticeHandler m_attention_handler; + + ScreenList m_screens; + WinClientMap m_window_search; + WindowMap m_window_search_group; - typedef std::map WinClientMap; - WinClientMap m_window_search; - typedef std::map WindowMap; - WindowMap m_window_search_group; // A window is the group leader, which can map to several // WinClients in the group, it is *not* fluxbox's concept of groups // See ICCCM section 4.1.11 @@ -256,43 +272,37 @@ private: // will have it's window being the group index std::multimap m_group_search; - ScreenList m_screen_list; + Time m_last_time; + XEvent m_last_event; + + Window m_masked; FluxboxWindow *m_masked_window; - BScreen *m_mousescreen, *m_keyscreen; + struct { + BScreen* mouse; + BScreen* key; + } m_active_screen; Atom m_fluxbox_pid; bool m_reconfigure_wait; - Time m_last_time; - Window m_masked; - std::string m_rc_file; ///< resource filename char **m_argv; int m_argc; - std::string m_restart_argument; ///< what to restart - XEvent m_last_event; - ///< when we execute reconfig command we must wait until next event round FbTk::Timer m_reconfig_timer; FbTk::Timer m_key_reload_timer; bool m_showing_dialog; - std::auto_ptr m_key; - - typedef std::set AtomHandlerContainer; - typedef AtomHandlerContainer::iterator AtomHandlerContainerIt; - - AtomHandlerContainer m_atomhandler; + struct { + bool starting; + bool restarting; + bool shutdown; + } m_state; - bool m_starting; - bool m_restarting; - bool m_shutdown; int m_server_grabs; - - AttentionNoticeHandler m_attention_handler; }; -- cgit v0.11.2