1 files changed, 146 insertions, 165 deletions

diff --git a/src/fluxbox.hh b/src/fluxbox.hh
index 95be304..e877805 100644
--- a/src/fluxbox.hh
+++ b/src/fluxbox.hh
@@ -1,6 +1,6 @@
-// fluxbox.hh for fluxbox 
-// Copyright (c) 2001 Henrik Kinnunen (fluxgen@linuxmail.org)
-
+// fluxbox.hh for Fluxbox Window Manager
+// Copyright (c) 2001 - 2002 Henrik Kinnunen (fluxgen@linuxmail.org)
+//
 // blackbox.hh for Blackbox - an X11 Window manager
 // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net)
 //
@@ -22,88 +22,71 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
+// $Id: fluxbox.hh,v 1.27 2002/08/17 22:13:00 fluxgen Exp $
 
+#ifndef  FLUXBOX_HH
+#define  FLUXBOX_HH
 
-#ifndef  _FLUXBOX_HH_
-#define  _FLUXBOX_HH_
-
-#include <X11/Xlib.h>
-#include <X11/Xresource.h>
-
-#ifdef          HAVE_STDIO_H
-# include <stdio.h>
-#endif // HAVE_STDIO_H
-
-#ifdef          TIME_WITH_SYS_TIME
-#       include <sys/time.h>
-#       include <time.h>
-#else // !TIME_WITH_SYS_TIME
-#       ifdef           HAVE_SYS_TIME_H
-#               include <sys/time.h>
-#       else // !HAVE_SYS_TIME_H
-#               include <time.h>
-#       endif // HAVE_SYS_TIME_H
-#endif // TIME_WITH_SYS_TIME
-
-//forward declaration
-class Fluxbox;
-
-#ifndef _BASEDISPLAY_HH_
+#include "Resource.hh"
+#include "Keys.hh"
 #include "BaseDisplay.hh"
-#endif
-
-#ifndef _IMAGE_HH_
 #include "Image.hh"
-#endif
-
-#ifndef _LINKEDLIST_HH_
-#include "LinkedList.hh"
-#endif
-
-#ifndef _TIMER_HH_
 #include "Timer.hh"
-#endif 
-
-#ifndef _WINDOW_HH_
 #include "Window.hh"
-#endif 
-
-#ifndef _TAB_HH_
 #include "Tab.hh"
-#endif
-
-#ifndef _TOOLBAR_HH_
 #include "Toolbar.hh"
-#endif
 
-#ifndef _KEYS_HH_
-#include "Keys.hh"
-#endif
-
-#ifdef          SLIT
-#       include "Slit.hh"
+#ifdef  SLIT
+#include "Slit.hh"
 #endif // SLIT
 
+#include "SignalHandler.hh"
+#include "FbAtoms.hh"
+
+#include <X11/Xlib.h>
+#include <X11/Xresource.h>
+
+#include <cstdio>
+
+#ifdef TIME_WITH_SYS_TIME
+#include <sys/time.h>
+#include <time.h>
+#else // !TIME_WITH_SYS_TIME
+#ifdef  HAVE_SYS_TIME_H
+#include <sys/time.h>
+#else // !HAVE_SYS_TIME_H
+#include <time.h>
+#endif // HAVE_SYS_TIME_H
+#endif // TIME_WITH_SYS_TIME
+
 #include <string>
 #include <vector>
-
-class Fluxbox : public BaseDisplay, public TimeoutHandler {     
+#include <map>
+#include <list>
+
+/**
+        main class for the window manager.
+        singleton type
+*/
+class Fluxbox : public BaseDisplay, public TimeoutHandler, 
+        public FbTk::EventHandler<FbTk::SignalEvent>,
+        public FbAtoms {
 public:
+        Fluxbox(int argc, char **argv, const char * dpy_name= 0, const char *rc = 0);   
+        virtual ~Fluxbox();
         
+        static Fluxbox *instance() { return singleton; }
         
-        static Fluxbox *instance(int m_argc=0, char **m_argv=0, char *dpy_name=0, char *rc=0);
-        
-        inline bool useTabs() const { return resource.tabs; }
-//      inline TabType &getTabType() { return resource.tabtype; }
-        inline bool useIconBar() const { return resource.iconbar; }
-        inline void saveTabs(bool value) { resource.tabs = value; }
-        inline void saveIconBar(bool value) { resource.iconbar = value; }
-#ifdef          HAVE_GETPID
-        inline const Atom &getFluxboxPidAtom(void) const { return fluxbox_pid; }
+        inline bool useTabs() { return *m_rc_tabs; }
+        inline bool useIconBar() { return *m_rc_iconbar; }
+        inline void saveTabs(bool value) { *m_rc_tabs = value; }
+        inline void saveIconBar(bool value) { m_rc_iconbar = value; }
+#ifdef HAVE_GETPID
+        inline Atom getFluxboxPidAtom() const { return fluxbox_pid; }
         #ifdef KDE
         //For KDE dock applets
-        inline const Atom &getKWM1DockwindowAtom(void) const { return kwm1_dockwindow; } //KDE v1.x
-        inline const Atom &getKWM2DockwindowAtom(void) const { return kwm2_dockwindow; } //KDE v2.x
+        inline Atom getKWM1DockwindowAtom() const { return kwm1_dockwindow; } //KDE v1.x
+        inline Atom getKWM2DockwindowAtom() const { return kwm2_dockwindow; } //KDE v2.x
         #endif
 #endif // HAVE_GETPID
 
@@ -111,75 +94,75 @@ public:
 
         FluxboxWindow *searchGroup(Window, FluxboxWindow *);
         FluxboxWindow *searchWindow(Window);
-        inline FluxboxWindow *getFocusedWindow(void) { return focused_window; }
+        inline FluxboxWindow *getFocusedWindow() { return focused_window; }
 
                 
-        BScreen *searchScreen(Window);
+        BScreen *searchScreen(Window w);
 
-        inline const Time &getDoubleClickInterval(void) const
-                { return resource.double_click_interval; }
-        inline const Time &getLastTime(void) const { return last_time; }
+        inline const Time &getDoubleClickInterval() const { return resource.double_click_interval; }
+        inline const Time &getLastTime() const { return last_time; }
 
-        Toolbar *searchToolbar(Window);
+        Toolbar *searchToolbar(Window w);
         Tab *searchTab(Window);
         
-        enum Titlebar{Shade=0, Minimize, Maximize, Close, Stick, Menu, Empty};          
+        /// obsolete
+        enum Titlebar{SHADE=0, MINIMIZE, MAXIMIZE, CLOSE, STICK, MENU, EMPTY};          
         
-        inline const std::vector<Fluxbox::Titlebar>& getTitlebarRight() { return titlebar.right; }
-        inline const std::vector<Fluxbox::Titlebar>& getTitlebarLeft() { return titlebar.left; }
-        inline const char *getStyleFilename(void) const
-                { return resource.style_file; }
-        inline const char *getRootCommand() const 
-                { return resource.root_cmd; }
-        inline const char *getMenuFilename(void) const
-                { return resource.menu_file; }
-
-        inline const int &getColorsPerChannel(void) const
-                { return resource.colors_per_channel; }
+        inline const std::vector<Fluxbox::Titlebar>& getTitlebarRight() { return *m_rc_titlebar_right; }
+        inline const std::vector<Fluxbox::Titlebar>& getTitlebarLeft() { return *m_rc_titlebar_left; }
+        inline const char *getStyleFilename() const { return m_rc_stylefile->c_str(); }
 
-        inline const timeval &getAutoRaiseDelay(void) const
-                { return resource.auto_raise_delay; }
+        inline const char *getMenuFilename() const { return m_rc_menufile->c_str(); }
+        inline const std::string &getSlitlistFilename() const { return *m_rc_slitlistfile; }
+        inline int colorsPerChannel() const { return *m_rc_colors_per_channel; }
 
-        inline const unsigned long &getCacheLife(void) const
-                { return resource.cache_life; }
-        inline const unsigned long &getCacheMax(void) const
-                { return resource.cache_max; }
-        inline const unsigned int &getTabWidth(void) const { return resource.tabwidth; }
-        inline const unsigned int &getTabHeight(void) const { return resource.tabheight; }
+        inline const timeval &getAutoRaiseDelay() const { return resource.auto_raise_delay; }
 
+        inline unsigned int getCacheLife() const { return *m_rc_cache_life * 60000; }
+        inline unsigned int getCacheMax() const { return *m_rc_cache_max; }
 
         inline void maskWindowEvents(Window w, FluxboxWindow *bw)
                 { masked = w; masked_window = bw; }
         inline void setNoFocus(Bool f) { no_focus = f; }
 
         void setFocusedWindow(FluxboxWindow *w);
-        void shutdown(void);
+        void shutdown();
         void load_rc(BScreen *);
+        void loadRootCommand(BScreen *);
         void loadTitlebar();
-        void saveStyleFilename(const char *);
+        void saveStyleFilename(const char *val) { m_rc_stylefile = (val == 0 ? "" : val); }
         void saveMenuFilename(const char *);
         void saveTitlebarFilename(const char *);
+        void saveSlitlistFilename(const char *val) { m_rc_slitlistfile = (val == 0 ? "" : val); }
         void saveMenuSearch(Window, Basemenu *);
         void saveWindowSearch(Window, FluxboxWindow *);
         void saveToolbarSearch(Window, Toolbar *);
         void saveTabSearch(Window, Tab *);
         void saveGroupSearch(Window, FluxboxWindow *);  
+        void save_rc();
         void removeMenuSearch(Window);
         void removeWindowSearch(Window);
         void removeToolbarSearch(Window);
         void removeTabSearch(Window);
         void removeGroupSearch(Window);
         void restart(const char * = 0);
-        void reconfigure(void);
-        void reconfigureTabs(void);
-        void rereadMenu(void);
-        void checkMenu(void);
+        void reconfigure();
+        void reconfigureTabs();
+        void rereadMenu();
+        void checkMenu();
+        
+        /// handle any system signal sent to the application
+        void handleEvent(FbTk::SignalEvent * const signum);
 
-        virtual Bool handleSignal(int);
+        virtual void timeout();
+        
+        inline const Cursor &getSessionCursor() const { return cursor.session; }
+        inline const Cursor &getMoveCursor() const { return cursor.move; }
+        inline const Cursor &getLowerLeftAngleCursor() const { return cursor.ll_angle; }
+        inline const Cursor &getLowerRightAngleCursor() const { return cursor.lr_angle; }
 
-        virtual void timeout(void);
 
-#ifdef          SLIT
+#ifdef  SLIT
         Slit *searchSlit(Window);
 
         void saveSlitSearch(Window, Slit *);
@@ -188,102 +171,100 @@ public:
 
 #ifndef  HAVE_STRFTIME
 
-        enum { B_AmericanDate = 1, B_EuropeanDate };
+        enum { B_AMERICANDATE = 1, B_EUROPEANDATE };
 #endif // HAVE_STRFTIME
         
-        template <class Z>
-        class DataSearch {
-        private:
-                Window window;
-                Z *data;
-
-
-        public:
-                DataSearch(Window w, Z *d) { window = w; data = d; }
-
-                inline const Window &getWindow(void) const { return window; }
-                inline Z *getData(void) { return data; }
-        };
-        
+        typedef std::vector<Fluxbox::Titlebar> TitlebarList;
                 
 private:
+        struct cursor {
+                Cursor session, move, ll_angle, lr_angle;
+        } cursor;
+
+        void setupConfigFiles();
+        void handleButtonEvent(XButtonEvent &be);
+        void handleUnmapNotify(XUnmapEvent &ue);
+        void handleClientMessage(XClientMessageEvent &ce);
+        void handleKeyEvent(XKeyEvent &ke);     
+        void doWindowAction(Keys::KeyAction action, const int param);
+        #ifdef GNOME
+        bool checkGnomeAtoms(XClientMessageEvent &ce);
+        #endif
+        #ifdef NEWWMSPEC
+        bool checkNETWMAtoms(XClientMessageEvent &ce);
+        #endif
         typedef struct MenuTimestamp {
                 char *filename;
                 time_t timestamp;
         } MenuTimestamp;
 
         struct resource {
-                Time double_click_interval;
-
-                char *menu_file, *style_file, *titlebar_file, *keys_file, *root_cmd;
-                int colors_per_channel;
+                Time double_click_interval;             
                 timeval auto_raise_delay;
-                unsigned long cache_life, cache_max;
-                bool tabs, iconbar;
-                //TabType tabtype;
-                unsigned int tabwidth, tabheight;
         } resource;
+                
+        ResourceManager m_resourcemanager, m_screen_rm;
         
-        struct titlebar_t {
-                std::vector<Fluxbox::Titlebar> left;
-                std::vector<Fluxbox::Titlebar> right;
-        };
+        //--- Resources
+        Resource<bool> m_rc_tabs, m_rc_iconbar;
+        Resource<int> m_rc_colors_per_channel;
+        Resource<std::string> m_rc_stylefile, 
+                m_rc_menufile, m_rc_keyfile, m_rc_slitlistfile,
+                m_rc_groupfile;
         
-        titlebar_t titlebar;
-        std::vector<std::string> parseTitleArgs(const char *arg);
+        Resource<TitlebarList> m_rc_titlebar_left, m_rc_titlebar_right;
+        Resource<unsigned int> m_rc_cache_life, m_rc_cache_max;
+
         void setTitlebar(std::vector<Fluxbox::Titlebar>& dir, const char *arg);
         
-        typedef DataSearch<FluxboxWindow> WindowSearch;
-        LinkedList<WindowSearch> *windowSearchList, *groupSearchList;
-        typedef DataSearch<Basemenu> MenuSearch;
-        LinkedList<MenuSearch> *menuSearchList;
-        typedef DataSearch<Toolbar> ToolbarSearch;
-        LinkedList<ToolbarSearch> *toolbarSearchList;
-        typedef DataSearch<Tab> TabSearch;
-        LinkedList<TabSearch> *tabSearchList;
+        std::map<Window, FluxboxWindow *> windowSearch;
+        std::map<Window, FluxboxWindow *> groupSearch;
+        std::map<Window, Basemenu *> menuSearch;
+        std::map<Window, Toolbar *> toolbarSearch;
+        typedef std::map<Window, Tab *> TabList;
+        TabList tabSearch;
         
-#ifdef          SLIT
-        typedef DataSearch<Slit> SlitSearch;
-        LinkedList<SlitSearch> *slitSearchList;
-  #ifdef KDE
+#ifdef SLIT
+        std::map<Window, Slit *> slitSearch;
+#ifdef KDE
         //For KDE dock applets
         Atom kwm1_dockwindow; //KDE v1.x
         Atom kwm2_dockwindow; //KDE v2.x
-        #endif//KDE
+#endif//KDE
 #endif // SLIT
 
-        LinkedList<MenuTimestamp> *menuTimestamps;
-        LinkedList<BScreen> *screenList;
+        std::list<MenuTimestamp *> menuTimestamps;
+        typedef std::list<BScreen *> ScreenList;
+        ScreenList screenList;
 
         FluxboxWindow *focused_window, *masked_window;
-        BTimer *timer;
+        BTimer timer;
 
 #ifdef          HAVE_GETPID
         Atom fluxbox_pid;
 #endif // HAVE_GETPID
 
-        Bool no_focus, reconfigure_wait, reread_menu_wait;
+        bool no_focus, reconfigure_wait, reread_menu_wait;
         Time last_time;
         Window masked;
-        char *rc_file, **argv;
+        std::string rc_file; ///< resource filename
+        char **argv;
         int argc;
         Keys *key;
-        char *expandFilename(char *filename);
-        void doWindowAction(Keys::KeyAction action);
-protected:
-        Fluxbox(int, char **, char * = 0, char * = 0);
-        char *getRcFilename();
-        void load_rc(void);
-        void save_rc(void);
-        void reload_rc(void);
-        void real_rereadMenu(void);
-        void real_reconfigure(void);
-
-        virtual void process_event(XEvent *);
-        //only main should be able to creat new blackbox object
-        friend int main(int,char **);
-        static Fluxbox *singleton;      //singleton object ( can only be destroyed by main )
-        virtual ~Fluxbox(void);
+        std::string slitlist_path;
+        //default arguments for titlebar left and right
+        static Fluxbox::Titlebar m_titlebar_left[], m_titlebar_right[];
+
+        std::string getRcFilename();
+        void getDefaultDataFilename(char *, std::string &);
+        void load_rc();
+        
+        void reload_rc();
+        void real_rereadMenu();
+        void real_reconfigure();
+
+        void handleEvent(XEvent *xe);
+        static Fluxbox *singleton;
 
 };