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;
 };