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.

1 files changed, 100 insertions, 90 deletions

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 <X11/Xresource.h>
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif // HAVE_CONFIG_H
-
-#ifdef HAVE_CSTDIO
-  #include <cstdio>
-#else
-  #include <stdio.h>
-#endif
-
 #ifdef TIME_WITH_SYS_TIME
 #include <sys/time.h>
 #include <time.h>
@@ -60,6 +50,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <cstdio>
 
 class AtomHandler;
 class FluxboxWindow;
@@ -75,61 +66,71 @@ class FbAtoms;
 class Fluxbox : public FbTk::App,
                 private FbTk::SignalTracker {
 public:
+
+    typedef std::list<BScreen *> 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<BScreen *> 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<FbAtoms> m_fbatoms;
 
-    FbTk::ResourceManager m_resourcemanager, &m_screen_rm;
+    typedef std::map<Window, WinClient *> WinClientMap;
+    typedef std::map<Window, FluxboxWindow *> WindowMap;
+    typedef std::set<AtomHandler *> AtomHandlerContainer;
+    typedef AtomHandlerContainer::iterator AtomHandlerContainerIt;
 
-    std::string m_RC_PATH;
 
     //--- Resources
 
-    FbTk::Resource<bool> m_rc_ignoreborder;
-    FbTk::Resource<bool> m_rc_pseudotrans;
-    FbTk::Resource<int> m_rc_colors_per_channel,
-        m_rc_double_click_interval,
-        m_rc_tabs_padding;
-    FbTk::Resource<std::string> m_rc_stylefile,
-        m_rc_styleoverlayfile,
-        m_rc_menufile, m_rc_keyfile, m_rc_slitlistfile,
-        m_rc_appsfile;
+    std::auto_ptr<FbAtoms> m_fbatoms;
+    FbTk::ResourceManager  m_resourcemanager;
+    FbTk::ResourceManager& m_screen_rm;
 
+    struct Config {
+        Config(FbTk::ResourceManager& rm, const std::string& path);
 
-    FbTk::Resource<TabsAttachArea> m_rc_tabs_attach_area;
-    FbTk::Resource<unsigned int> m_rc_cache_life, m_rc_cache_max;
-    FbTk::Resource<time_t> m_rc_auto_raise_delay;
+        std::string path;
+        std::string file;
+
+        FbTk::Resource<bool> ignore_border;
+        FbTk::Resource<bool> pseudotrans;
+        FbTk::Resource<int>  colors_per_channel;
+        FbTk::Resource<int>  double_click_interval;
+        FbTk::Resource<int>  tabs_padding;
+
+        FbTk::Resource<std::string> style_file;
+        FbTk::Resource<std::string> overlay_file;
+        FbTk::Resource<std::string> menu_file;
+        FbTk::Resource<std::string> key_file;
+        FbTk::Resource<std::string> slit_file;
+        FbTk::Resource<std::string> apps_file;
+
+        FbTk::Resource<TabsAttachArea> tabs_attach_area;
+        FbTk::Resource<unsigned int>   cache_life;
+        FbTk::Resource<unsigned int>   cache_max;
+        FbTk::Resource<time_t>         auto_raise_delay;
+    } m_config;
+
+
+    std::auto_ptr<Keys>    m_key;
+    AtomHandlerContainer   m_atomhandler;
+    AttentionNoticeHandler m_attention_handler;
+
+    ScreenList             m_screens;
+    WinClientMap           m_window_search;
+    WindowMap              m_window_search_group;
 
-    typedef std::map<Window, WinClient *> WinClientMap;
-    WinClientMap m_window_search;
-    typedef std::map<Window, FluxboxWindow *> 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<Window, WinClient *> 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<Keys> m_key;
-
-    typedef std::set<AtomHandler *> 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;
 };