@@ -41,10 +41,10 @@ 
     bool fallback(FbTk::ThemeItem_base &item);
     void reconfigTheme();
 
-    inline const FbTk::Texture &pressed() const { return *m_pressed_texture; }
-    inline GC gc() const { return m_gc.gc(); }
-    inline int scale() const { return *m_scale; } // scale factor for inside objects
-    inline const std::string &name() { return m_name; }
+    const FbTk::Texture &pressed() const { return *m_pressed_texture; }
+    GC gc() const { return m_gc.gc(); }
+    int scale() const { return *m_scale; } // scale factor for inside objects
+    const std::string &name() { return m_name; }
 
 private:
     FbTk::ThemeItem<FbTk::Color> m_pic_color;

@@ -42,7 +42,7 @@ class ClientPattern:private FbTk::NotCopyable {
 public:
     ClientPattern();
     /**
-     * Create the pattern from the given string as it would appear in the 
+     * Create the pattern from the given string as it would appear in the
      * apps file. the bool value returns the character at which
      * there was a parse problem, or -1.
      */
@@ -76,7 +76,7 @@ * @return false if the regexp wasn't valid
      */
     bool addTerm(const std::string &str, WinProperty prop, bool negate = false);
 
-    inline void addMatch() { ++m_nummatches; }
+    void addMatch() { ++m_nummatches; }
 
     // whether this pattern has identical matching criteria
     bool operator ==(const ClientPattern &pat) const;
@@ -85,7 +85,7 @@ /**
      * If there are no terms, then there is assumed to be an error
      * the column of the error is stored in m_matchlimit
      */
-    inline int error() const { return m_terms.empty() ? 1 : 0; }
+    int error() const { return m_terms.empty() ? 1 : 0; }
 
     static std::string getProperty(WinProperty prop, const Focusable &client);
 
@@ -95,7 +95,7 @@ * This is the type of the actual pattern we want to match against
      * We have a "term" in the whole expression which is the full pattern
      * we also need to keep track of the uncompiled regular expression
      * for final output
-     */    
+     */
     struct Term {
         Term(const std::string &regstr, bool full_match) :regexp(regstr, full_match){};
         std::string orig;

@@ -62,7 +62,7 @@ // accessors
     unsigned int width() const;
     unsigned int height() const;
     unsigned int borderWidth() const;
-    inline const std::string &timeFormat() const { return *m_timeformat; }
+    const std::string &timeFormat() const { return *m_timeformat; }
 
     void setOrientation(FbTk::Orientation orient);
 

@@ -34,17 +34,17 @@ ~FbAtoms();
 
     static FbAtoms *instance();
 
-    inline Atom getWMChangeStateAtom() const { return xa_wm_change_state; }
-    inline Atom getWMStateAtom() const { return xa_wm_state; }
-    inline Atom getWMDeleteAtom() const { return xa_wm_delete_window; }
-    inline Atom getWMProtocolsAtom() const { return xa_wm_protocols; }
-    inline Atom getWMTakeFocusAtom() const { return xa_wm_take_focus; }
+    Atom getWMChangeStateAtom() const { return xa_wm_change_state; }
+    Atom getWMStateAtom() const { return xa_wm_state; }
+    Atom getWMDeleteAtom() const { return xa_wm_delete_window; }
+    Atom getWMProtocolsAtom() const { return xa_wm_protocols; }
+    Atom getWMTakeFocusAtom() const { return xa_wm_take_focus; }
 
-    inline Atom getMWMHintsAtom() const { return motif_wm_hints; }
+    Atom getMWMHintsAtom() const { return motif_wm_hints; }
 
     // these atoms are for normal app->WM interaction beyond the scope of the
     // ICCCM...
-    inline Atom getFluxboxAttributesAtom() const { return blackbox_attributes; }
+    Atom getFluxboxAttributesAtom() const { return blackbox_attributes; }
 
 private:
     void initAtoms();
@@ -54,7 +54,7 @@ Atom motif_wm_hints;
 
     Atom xa_wm_protocols, xa_wm_state,
         xa_wm_delete_window, xa_wm_take_focus, xa_wm_change_state;
-       
+
     bool m_init;
     static FbAtoms *s_singleton;
 };

@@ -38,8 +38,8 @@ void hide() { }
     // we should not assign a new window to this
     FbTk::FbWindow &operator = (Window win) { return *this; }
     void updateGeometry();
-    inline Visual *visual() const { return m_visual; }
-    inline Colormap colormap() const { return m_colormap; } 
+    Visual *visual() const { return m_visual; }
+    Colormap colormap() const { return m_colormap; } 
 
 private:
     Visual *m_visual;

@@ -37,8 +37,8 @@ template <typename T>
 class SimpleAccessor: public Accessor<T> {
 public:
     SimpleAccessor(T &val): m_val(val) { }
-    inline Accessor<T> &operator =(const T &val) { m_val = val; return *this; }
-    inline operator T() const { return m_val; }
+    Accessor<T> &operator =(const T &val) { m_val = val; return *this; }
+    operator T() const { return m_val; }
 
 private:
     T &m_val;
@@ -53,8 +53,8 @@ typedef void (Receiver:: *Setter)(T &);
     ObjectAccessor(Receiver &r, Getter g, Setter s):
         m_receiver(r), m_getter(g), m_setter(s) { }
 
-    inline operator T() const { return (m_receiver.*m_getter)(); }
-    inline Accessor<T> &operator =(const T &val) {
+    operator T() const { return (m_receiver.*m_getter)(); }
+    Accessor<T> &operator =(const T &val) {
         (m_receiver.*m_setter)(val); return *this;
     }
 
@@ -72,8 +72,8 @@ typedef T (Receiver:: *Getter)() const;
     ConstObjectAccessor(const Receiver &r, Getter g):
         m_receiver(r), m_getter(g) { }
 
-    inline operator T() const { return (m_receiver.*m_getter)(); }
-    inline Accessor<T> &operator =(const T &val) { return *this; }
+    operator T() const { return (m_receiver.*m_getter)(); }
+    Accessor<T> &operator =(const T &val) { return *this; }
 
 private:
     const Receiver &m_receiver;

@@ -46,7 +46,7 @@ /// creates a display connection
     explicit App(const char *displayname=0);
     virtual ~App();
     /// display connection
-    inline Display *display() const { return m_display; }
+    Display *display() const { return m_display; }
     void sync(bool discard);
     /// starts event loop
     virtual void eventLoop();

@@ -1,4 +1,4 @@ 
-// Color.hh for Fluxbox Window Manager 
+// Color.hh for Fluxbox Window Manager
 // Copyright (c) 2002 - 2006 Henrik Kinnunen (fluxgen at fluxbox dot org)
 //
 // from Image.hh for Blackbox - an X11 Window manager
@@ -48,12 +48,12 @@ /// TODO don't like this
     void setPixel(unsigned long pixel) { m_pixel = pixel; }
 
     Color &operator = (const Color &col_copy);
-	
-    inline bool isAllocated() const { return m_allocated; }
-    inline unsigned short red() const { return m_red; }
-    inline unsigned short green() const { return m_green; }
-    inline unsigned short blue() const { return m_blue; }
-    inline unsigned long pixel() const { return m_pixel; }
+
+    bool isAllocated() const { return m_allocated; }
+    unsigned short red() const { return m_red; }
+    unsigned short green() const { return m_green; }
+    unsigned short blue() const { return m_blue; }
+    unsigned long pixel() const { return m_pixel; }
 
     /// @return true if the color name in color_string is resolved, else false
     static bool validColorString(const char *color_string, int screen);
@@ -61,9 +61,9 @@ 
 private:
     void free();
     void copy(const Color &col);
-    void allocate(unsigned short red, unsigned short green, 
+    void allocate(unsigned short red, unsigned short green,
                   unsigned short blue, int screen);
-    inline void setAllocated(bool a) { m_allocated = a; }
+    void setAllocated(bool a) { m_allocated = a; }
     void setRGB(unsigned short red, unsigned short green, unsigned short blue);
 
 

@@ -71,9 +71,9 @@ 
     Item back() { return m_item_list.back(); }
 
     /// force update
-    inline void update() { repositionItems(); }
+    void update() { repositionItems(); }
     /// so we can add items without having an graphic update for each item
-    inline void setUpdateLock(bool value) { m_update_lock = value; }
+    void setUpdateLock(bool value) { m_update_lock = value; }
 
     /// event handler
     void exposeEvent(XExposeEvent &event);
@@ -86,12 +86,12 @@ void parentMoved();
     void invalidateBackground();
 
     /// accessors
-    inline Alignment alignment() const { return m_align; }
-    inline Orientation orientation() const { return m_orientation; }
-    inline int size() const { return m_item_list.size(); }
-    inline bool empty() const { return m_item_list.empty(); }
+    Alignment alignment() const { return m_align; }
+    Orientation orientation() const { return m_orientation; }
+    int size() const { return m_item_list.size(); }
+    bool empty() const { return m_item_list.empty(); }
     unsigned int maxWidthPerClient() const;
-    inline bool updateLock() const { return m_update_lock; }
+    bool updateLock() const { return m_update_lock; }
 
     void for_each(std::mem_fun_t<void, FbWindow> function);
     void setAlpha(unsigned char alpha); // set alpha on all windows

@@ -36,14 +36,14 @@ public:
     DefaultValue(const Def def):
         m_default(def), m_actual(def), m_use_default(true) { }
 
-    inline void restoreDefault() { m_use_default = true; }
-    inline bool isDefault() const { return m_use_default; }
+    void restoreDefault() { m_use_default = true; }
+    bool isDefault() const { return m_use_default; }
 
-    inline DefaultValue<Ret, Def> &operator =(const Ret &val) {
+    DefaultValue<Ret, Def> &operator =(const Ret &val) {
         m_use_default = false; m_actual = val; return *this;
     }
 
-    inline operator Ret() const { return m_use_default ? m_default : m_actual; }
+    operator Ret() const { return m_use_default ? m_default : m_actual; }
 
 private:
     const Def m_default;

@@ -64,10 +64,10 @@ FbPixmap &operator = (const FbPixmap &copy);
     /// sets new pixmap
     FbPixmap &operator = (Pixmap pm);
 
-    inline Drawable drawable() const { return m_pm; }
-    inline unsigned int width() const { return m_width; }
-    inline unsigned int height() const { return m_height; }
-    inline unsigned int depth() const { return m_depth; }
+    Drawable drawable() const { return m_pm; }
+    unsigned int width() const { return m_width; }
+    unsigned int height() const { return m_height; }
+    unsigned int depth() const { return m_depth; }
 
     static Pixmap getRootPixmap(int screen_num, bool force_update=false);
     static bool setRootPixmap(int screen_num, Pixmap pm);

@@ -55,19 +55,19 @@ 
     FbWindow(const FbWindow &win_copy);
 
     FbWindow(int screen_num,
-             int x, int y, unsigned int width, unsigned int height, long eventmask, 
+             int x, int y, unsigned int width, unsigned int height, long eventmask,
              bool overrride_redirect = false,
              bool save_unders = false,
-             unsigned int depth = CopyFromParent, 
+             unsigned int depth = CopyFromParent,
              int class_type = InputOutput);
 
     FbWindow(const FbWindow &parent,
-             int x, int y, 
-             unsigned int width, unsigned int height, 
-             long eventmask, 
+             int x, int y,
+             unsigned int width, unsigned int height,
+             long eventmask,
              bool overrride_redirect = false,
              bool save_unders = false,
-             unsigned int depth = CopyFromParent, 
+             unsigned int depth = CopyFromParent,
              int class_type = InputOutput);
 
     virtual ~FbWindow();
@@ -83,10 +83,10 @@ void setEventMask(long mask);
     /// clear window with background pixmap or color
     virtual void clear();
     /// @param exposures wheter Expose event should be generated
-    virtual void clearArea(int x, int y, 
-                           unsigned int width, unsigned int height, 
+    virtual void clearArea(int x, int y,
+                           unsigned int width, unsigned int height,
                            bool exposures = false);
-    void updateTransparent(int x = -1, int y = -1, unsigned int width = 0, 
+    void updateTransparent(int x = -1, int y = -1, unsigned int width = 0,
                            unsigned int height = 0, Pixmap dest_override = None,
                            bool override_is_offset = false);
 
@@ -94,18 +94,18 @@ void setAlpha(unsigned char alpha);
 
     virtual FbWindow &operator = (const FbWindow &win);
     /// assign a new X window to this
-    virtual FbWindow &operator = (Window win);    
+    virtual FbWindow &operator = (Window win);
     virtual void hide();
     virtual void show();
     virtual void showSubwindows();
 
     /// Notify that the parent window was moved,
     /// thus the absolute position of this one moved
-    virtual inline void parentMoved() {
+    virtual void parentMoved() {
         updateBackground(true);
     }
 
-    virtual inline void move(int x, int y) {
+    virtual void move(int x, int y) {
         if (x == m_x && y == m_y)
             return;
         XMoveWindow(s_display, m_window, x, y);
@@ -114,7 +114,7 @@ m_y = y;
         updateBackground(true);
     }
 
-    virtual inline void resize(unsigned int width, unsigned int height) {
+    virtual void resize(unsigned int width, unsigned int height) {
         if (width == m_width && height == m_height)
             return;
         XResizeWindow(s_display, m_window, width, height);
@@ -123,7 +123,7 @@ m_height = height;
         updateBackground(false);
     }
 
-    virtual inline void moveResize(int x, int y, unsigned int width, unsigned int height) {
+    virtual void moveResize(int x, int y, unsigned int width, unsigned int height) {
         if (x == m_x && y == m_y && width == m_width && height == m_height)
             return;
         XMoveResizeWindow(s_display, m_window, x, y, width, height);
@@ -171,26 +171,26 @@ 
     /// @return parent FbWindow
     const FbWindow *parent() const { return m_parent; }
     /// @return real X window
-    inline Window window() const { return m_window; }
+    Window window() const { return m_window; }
     /// @return drawable (the X window)
-    inline Drawable drawable() const { return window(); }
-    inline int x() const { return m_x; }
-    inline int y() const { return m_y; }
-    inline unsigned int width() const { return m_width; }
-    inline unsigned int height() const { return m_height; }
-    inline unsigned int borderWidth() const { return m_border_width; }
-    inline unsigned int depth() const { return m_depth; }
+    Drawable drawable() const { return window(); }
+    int x() const { return m_x; }
+    int y() const { return m_y; }
+    unsigned int width() const { return m_width; }
+    unsigned int height() const { return m_height; }
+    unsigned int borderWidth() const { return m_border_width; }
+    unsigned int depth() const { return m_depth; }
     unsigned char alpha() const;
     int screenNumber() const;
     long eventMask() const;
     Display *display() const { return s_display; }
 
     /// compare X window
-    inline bool operator == (Window win) const { return m_window == win; }	
-    inline bool operator != (Window win) const { return m_window != win; }
+    bool operator == (Window win) const { return m_window == win; }
+    bool operator != (Window win) const { return m_window != win; }
     /// compare two windows
-    inline bool operator == (const FbWindow &win) const { return m_window == win.m_window; }
-    inline bool operator != (const FbWindow &win) const { return m_window != win.m_window; }
+    bool operator == (const FbWindow &win) const { return m_window == win.m_window; }
+    bool operator != (const FbWindow &win) const { return m_window != win.m_window; }
 
     // used for composite
     void setOpaque(unsigned char alpha);
@@ -215,10 +215,10 @@ /// sets new X window and destroys old
     void setNew(Window win);
     /// creates a new X window
     void create(Window parent, int x, int y, unsigned int width, unsigned int height,
-                long eventmask, 
-                bool override_redirect, 
+                long eventmask,
+                bool override_redirect,
                 bool save_unders,
-                unsigned int depth, 
+                unsigned int depth,
                 int class_type);
 
     const FbWindow *m_parent; ///< parent FbWindow
@@ -250,11 +250,11 @@ class ChangeProperty {
 public:
     ChangeProperty(Display *disp, Atom prop, int mode,
                    unsigned char *state, int num):m_disp(disp),
-                                                  m_prop(prop), 
-                                                  m_state(state), 
-                                                  m_num(num), 
+                                                  m_prop(prop),
+                                                  m_state(state),
+                                                  m_num(num),
                                                   m_mode(mode){
-        
+
     }
     void operator () (FbTk::FbWindow *win) {
         XChangeProperty(m_disp, win->window(), m_prop, m_prop, 32, m_mode,

@@ -53,7 +53,7 @@ CAPBUTT= CapButt,
                    CAPROUND= CapRound,
                    CAPPROJECTING= CapProjecting
     } CapStyle;
-  
+
     /// for FbTk drawable
     explicit GContext(const FbTk::FbDrawable &drawable);
     /// for X drawable
@@ -61,81 +61,81 @@ explicit GContext(Drawable drawable);
     GContext(Drawable d, const FbTk::GContext &gc);
     virtual ~GContext();
 
-    inline void setForeground(const FbTk::Color &color) {
+    void setForeground(const FbTk::Color &color) {
         setForeground(color.pixel());
     }
 
-    inline void setForeground(long pixel_value) {
+    void setForeground(long pixel_value) {
         XSetForeground(m_display, m_gc,
                        pixel_value);
     }
 
-    inline void setBackground(const FbTk::Color &color) {
+    void setBackground(const FbTk::Color &color) {
         setBackground(color.pixel());
     }
 
-    inline void setBackground(long pixel_value) {
+    void setBackground(long pixel_value) {
         XSetBackground(m_display, m_gc, pixel_value);
     }
 
-    inline void setTile(Drawable draw) {
+    void setTile(Drawable draw) {
         XSetTile(m_display, m_gc, draw);
     }
 
-    inline void setTile(const FbTk::FbPixmap &draw) {
+    void setTile(const FbTk::FbPixmap &draw) {
         setTile(draw.drawable());
     }
 
     /// not implemented
-    inline void setFont(const FbTk::Font &) {}
+    void setFont(const FbTk::Font &) {}
 
     /// set font id
-    inline void setFont(int fid) {
+    void setFont(int fid) {
         XSetFont(m_display, m_gc, fid);
     }
 #ifdef NOT_USED
-    inline void setClipMask(const FbTk::FbPixmap &mask) {
+    void setClipMask(const FbTk::FbPixmap &mask) {
         XSetClipMask(m_display, m_gc, mask.drawable());
     }
 
-    inline void setClipOrigin(int x, int y) {
+    void setClipOrigin(int x, int y) {
         XSetClipOrigin(m_display, m_gc, x, y);
     }
 #endif
-    inline void setGraphicsExposure(bool value) {
+    void setGraphicsExposure(bool value) {
         XSetGraphicsExposures(m_display, m_gc, value);
     }
 
-    inline void setFunction(int func) {
+    void setFunction(int func) {
         XSetFunction(m_display, m_gc, func);
     }
 
-    inline void setSubwindowMode(int mode) {
+    void setSubwindowMode(int mode) {
         XSetSubwindowMode(m_display, m_gc, mode);
     }
-    inline void setFillStyle(int style) {
+    void setFillStyle(int style) {
         XSetFillStyle(m_display, m_gc, style);
     }
 #ifdef NOT_USED
-    inline void setFillRule(int rule) {
+    void setFillRule(int rule) {
         XSetFillRule(m_display, m_gc, rule);
     }
 #endif
-    inline void setLineAttributes(unsigned int width, 
-                                  int line_style, 
-                                  int cap_style, 
+    void setLineAttributes(unsigned int width,
+                                  int line_style,
+                                  int cap_style,
                                   int join_style) {
 
         XSetLineAttributes(m_display, m_gc, width, line_style, cap_style, join_style);
     }
-      
+
 
     void copy(GC gc);
     void copy(const GContext &gc);
 
-    inline GContext &operator = (const GContext &copy_gc) { copy(copy_gc); return *this; }
-    inline GContext &operator = (GC copy_gc) { copy(copy_gc); return *this; }
-    inline GC gc() const { return m_gc; }
+    GContext &operator = (const GContext &copy_gc) { copy(copy_gc); return *this; }
+    GContext &operator = (GC copy_gc) { copy(copy_gc); return *this; }
+    GC gc() const { return m_gc; }
 
 private:
     GContext(const GContext &cont);

@@ -24,8 +24,8 @@ // DEALINGS IN THE SOFTWARE.
 
 // $Id$
 
-#ifndef	 I18N_HH
-#define	 I18N_HH
+#ifndef I18N_HH
+#define I18N_HH
 
 // TODO: FIXME
 #include "../../nls/fluxbox-nls.hh"
@@ -105,9 +105,9 @@ 
 class I18n {
 public:
     static I18n *instance();
-    inline const char *getLocale() const { return m_locale.c_str(); }
-    inline bool multibyte() const { return m_multibyte; }
-    inline const nl_catd &getCatalogFd() const { return m_catalog_fd; }
+    const char *getLocale() const { return m_locale.c_str(); }
+    bool multibyte() const { return m_multibyte; }
+    const nl_catd &getCatalogFd() const { return m_catalog_fd; }
 
     FbString getMessage(int set_number, int message_number, 
                            const char *default_messsage = 0, bool translate_fb = false) const;

@@ -24,8 +24,8 @@ // DEALINGS IN THE SOFTWARE.
 
 // $Id$
 
-#ifndef	 FBTK_IMAGECONTROL_HH
-#define	 FBTK_IMAGECONTROL_HH
+#ifndef FBTK_IMAGECONTROL_HH
+#define FBTK_IMAGECONTROL_HH
 
 // actually, Text is rather tool like, that's where orientation comes from
 #include "Text.hh" 
@@ -47,14 +47,14 @@ ImageControl(int screen_num, bool dither = false, int colors_per_channel = 4,
                   unsigned long cache_timeout = 300000l, unsigned long cache_max = 200l);
     virtual ~ImageControl();
 
-    inline bool doDither() const { return m_dither; }
+    bool doDither() const { return m_dither; }
 #ifdef NOT_USED
-    inline int bitsPerPixel() const { return bits_per_pixel; }
+    int bitsPerPixel() const { return bits_per_pixel; }
 #endif
-    inline int depth() const { return m_screen_depth; }
-    inline int colorsPerChannel() const	{ return m_colors_per_channel; }
-    inline int screenNumber() const { return m_screen_num; }
-    inline Visual *visual() const { return m_visual; }
+    int depth() const { return m_screen_depth; }
+    int colorsPerChannel() const	{ return m_colors_per_channel; }
+    int screenNumber() const { return m_screen_num; }
+    Visual *visual() const { return m_visual; }
     unsigned long getSqrt(unsigned int val) const;
 
     /**

@@ -35,7 +35,7 @@ public:
     IntMenuItem(const FbTk::FbString &label, Accessor<int> &res,
                    int min_val, int max_val, FbTk::Menu &host_menu) :
         FbTk::MenuItem(label, host_menu), m_org_label(FbTk::MenuItem::label()),
-        m_max(max_val), m_min(min_val), m_res(res) { 
+        m_max(max_val), m_min(min_val), m_res(res) {
         updateLabel();
         setCloseOnClick(false);
     }
@@ -77,7 +77,7 @@ // update label
         updateLabel();
         // call other commands
         FbTk::MenuItem::click(button, time, mods);
-        
+
         // show new value, which for us means forcing a full menu update
         // since the text is drawn onto the background!
         if (menu()) {

@@ -54,12 +54,12 @@ public FbTk::Observer {
 public:
     enum Alignment{ ALIGNDONTCARE = 1, ALIGNTOP, ALIGNBOTTOM };
     enum { RIGHT = 1, LEFT };
-	
+
     /**
        Bullet type
     */
     enum { EMPTY = 0, SQUARE, TRIANGLE, DIAMOND };
-	
+
     Menu(MenuTheme &tm, ImageControl &imgctrl);
     virtual ~Menu();
 
@@ -79,11 +79,11 @@ /// remove an item
     int remove(unsigned int item);
     /// remove all items
     void removeAll();
-    inline void setInternalMenu(bool val = true) { m_internal_menu = val; }
-    inline void setAlignment(Alignment a) { m_alignment = a; }
+    void setInternalMenu(bool val = true) { m_internal_menu = val; }
+    void setAlignment(Alignment a) { m_alignment = a; }
 #ifdef NOT_USED
-    inline void setTorn() { m_torn = true; }
-    inline void removeParent() { if (m_internal_menu) m_parent = 0; }
+    void setTorn() { m_torn = true; }
+    void removeParent() { if (m_internal_menu) m_parent = 0; }
 #endif
     /// raise this window
     virtual void raise();
@@ -119,7 +119,7 @@ virtual void move(int x, int y);
     virtual void updateMenu(int active_index = -1);
     void setItemSelected(unsigned int index, bool val);
     void setItemEnabled(unsigned int index, bool val);
-    inline void setMinimumSublevels(int m) { menu.minsub = m; }
+    void setMinimumSublevels(int m) { menu.minsub = m; }
     virtual void drawSubmenu(unsigned int index);
     /// show menu
     virtual void show();
@@ -129,54 +129,54 @@ virtual void clearWindow();
 #ifdef NOT_USED
     void setActiveIndex(int index) { m_active_index = index; }
     /*@}*/
-	
+
     /**
        @name accessors
     */
     //@{
-    inline int activeIndex() const { return m_active_index; }
+    int activeIndex() const { return m_active_index; }
 #endif
-    inline bool isTorn() const { return m_torn; }
-    inline bool isVisible() const { return m_visible; }
-    inline bool isMoving() const { return m_moving; }
-    inline int screenNumber() const { return menu.window.screenNumber(); }
-    inline Window window() const { return menu.window.window(); }
-    inline FbWindow &fbwindow() { return menu.window; }
-    inline const FbWindow &fbwindow() const { return menu.window; }
-    inline FbWindow &titleWindow() { return menu.title; }
-    inline FbWindow &frameWindow() { return menu.frame; }
-    inline const std::string &label() const { return menu.label; }  
-    inline int x() const { return menu.window.x(); }
-    inline int y() const { return menu.window.y(); }
-    inline unsigned int width() const { return menu.window.width(); }
-    inline unsigned int height() const { return menu.window.height(); }
-    inline size_t numberOfItems() const { return menuitems.size(); }
-    inline int currentSubmenu() const { return m_which_sub; } 
+    bool isTorn() const { return m_torn; }
+    bool isVisible() const { return m_visible; }
+    bool isMoving() const { return m_moving; }
+    int screenNumber() const { return menu.window.screenNumber(); }
+    Window window() const { return menu.window.window(); }
+    FbWindow &fbwindow() { return menu.window; }
+    const FbWindow &fbwindow() const { return menu.window; }
+    FbWindow &titleWindow() { return menu.title; }
+    FbWindow &frameWindow() { return menu.frame; }
+    const std::string &label() const { return menu.label; }
+    int x() const { return menu.window.x(); }
+    int y() const { return menu.window.y(); }
+    unsigned int width() const { return menu.window.width(); }
+    unsigned int height() const { return menu.window.height(); }
+    size_t numberOfItems() const { return menuitems.size(); }
+    int currentSubmenu() const { return m_which_sub; }
 
     bool isItemSelected(unsigned int index) const;
     bool isItemEnabled(unsigned int index) const;
     bool isItemSelectable(unsigned int index) const;
-    inline const MenuTheme &theme() const { return m_theme; }
-    inline unsigned char alpha() const { return theme().alpha(); }
-    inline static Menu *shownMenu() { return shown; }
-    inline static Menu *focused() { return s_focused; }
+    const MenuTheme &theme() const { return m_theme; }
+    unsigned char alpha() const { return theme().alpha(); }
+    static Menu *shownMenu() { return shown; }
+    static Menu *focused() { return s_focused; }
     static void hideShownMenu();
     /// @return menuitem at index
-    inline const MenuItem *find(unsigned int index) const { return menuitems[index]; }
-    inline MenuItem *find(unsigned int index) { return menuitems[index]; }
+    const MenuItem *find(unsigned int index) const { return menuitems[index]; }
+    MenuItem *find(unsigned int index) { return menuitems[index]; }
     //@}
     /// @return true if index is valid
-    inline bool validIndex(int index) const { return (index < static_cast<int>(numberOfItems()) && index >= 0); }
+    bool validIndex(int index) const { return (index < static_cast<int>(numberOfItems()) && index >= 0); }
 
-    inline Menu *parent() { return m_parent; }
-    inline const Menu *parent() const { return m_parent; }
+    Menu *parent() { return m_parent; }
+    const Menu *parent() const { return m_parent; }
 
     void renderForeground(FbWindow &win, FbDrawable &drawable);
 
 protected:
 
-    inline void setTitleVisibility(bool b) { 
-        m_title_vis = b; m_need_update = true; 
+    void setTitleVisibility(bool b) {
+        m_title_vis = b; m_need_update = true;
         if (!b)
             titleWindow().lower();
         else
@@ -196,7 +196,7 @@ virtual void internal_hide(bool first = true);
 
     virtual void update(FbTk::Subject *);
 
-private: 
+private:
 
     void openSubmenu();
     void closeMenu();
@@ -225,7 +225,7 @@ bool m_visible; ///< menu visibility
     bool m_torn; ///< torn from parent
     bool m_internal_menu; ///< whether we should destroy this menu or if it's managed somewhere else
     bool m_title_vis; ///< title visibility
-	
+
     int m_which_sub;
     Alignment m_alignment;
 

@@ -92,7 +92,7 @@ m_toggle_item(false)
     { }
     virtual ~MenuItem() { }
 
-    inline void setCommand(RefCount<Command> &cmd) { m_command = cmd; }
+    void setCommand(RefCount<Command> &cmd) { m_command = cmd; }
     virtual void setSelected(bool selected) { m_selected = selected; }
     virtual void setEnabled(bool enabled) { m_enabled = enabled; }
     virtual void setLabel(const FbString &label) { m_label = label; }
@@ -100,7 +100,7 @@ virtual void setToggleItem(bool val) { m_toggle_item = val; }
     void setCloseOnClick(bool val) { m_close_on_click = val; }
     void setIcon(const std::string &filename, int screen_num);
     virtual Menu *submenu() { return m_submenu; }
-    /** 
+    /**
         @name accessors
     */
     //@{
@@ -108,15 +108,15 @@ virtual const std::string &label() const { return m_label; }
     virtual const PixmapWithMask *icon() const {
         return m_icon.get() ? m_icon->pixmap.get() : 0;
     }
-    virtual const Menu *submenu() const { return m_submenu; } 
+    virtual const Menu *submenu() const { return m_submenu; }
     virtual bool isEnabled() const { return m_enabled; }
     virtual bool isSelected() const { return m_selected; }
     virtual bool isToggleItem() const { return m_toggle_item; }
-    
+
     // iType functions
-    virtual inline void setIndex(int index) { m_index = index; }
-    virtual inline int getIndex() { return m_index; }
-    inline const std::string &iTypeString() const { return m_label; }
+    virtual void setIndex(int index) { m_index = index; }
+    virtual int getIndex() { return m_index; }
+    const std::string &iTypeString() const { return m_label; }
     virtual void drawLine(FbDrawable &draw,
                       const MenuTheme &theme,
                       size_t size,
@@ -125,7 +125,7 @@ unsigned int width) const;
 
     virtual unsigned int width(const MenuTheme &theme) const;
     virtual unsigned int height(const MenuTheme &theme) const;
-    virtual void draw(FbDrawable &drawable, 
+    virtual void draw(FbDrawable &drawable,
                       const MenuTheme &theme,
                       bool highlight,
                       // "foreground" is the transient bits - more likely to change
@@ -136,7 +136,7 @@ virtual void updateTheme(const MenuTheme &theme);
     /**
        Called when the item was clicked with a specific button
        @param button the button number
-       @param time the time stamp 
+       @param time the time stamp
     */
     virtual void click(int button, int time, unsigned int mods);
     /// must use this to show submenu to ensure consistency for object like window menu in ClientMenu (see Workspace.cc)
@@ -147,7 +147,7 @@ //@}
 
     void setMenu(Menu &menu) { m_menu = &menu; }
     Menu *menu() { return m_menu; }
-	
+
 private:
     FbString m_label; ///< label of this item
     Menu *m_menu; ///< the menu we live in

@@ -1,6 +1,6 @@ 
 // MenuTheme.hh for FbTk
 // Copyright (c) 2002 - 2006 Henrik Kinnunen (fluxgen at fluxbox dot org)
-// 
+//
 // 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
@@ -55,90 +55,90 @@ /**
        @name text colors
     */
     ///@{
-    inline const Color &titleTextColor() const { return *t_text; }
-    inline const Color &frameTextColor() const { return *f_text; }
-    inline const Color &frameUnderlineColor() const { return *u_text; }
-    inline const Color &highlightTextColor() const { return *h_text; }
-    inline const Color &disableTextColor() const { return *d_text; }
+    const Color &titleTextColor() const { return *t_text; }
+    const Color &frameTextColor() const { return *f_text; }
+    const Color &frameUnderlineColor() const { return *u_text; }
+    const Color &highlightTextColor() const { return *h_text; }
+    const Color &disableTextColor() const { return *d_text; }
     ///@}
     /**
        @name textures
     */
     ///@{
-    inline const Texture &titleTexture() const { return *title; }
-    inline const Texture &frameTexture() const { return *frame; }
-    inline const Texture &hiliteTexture() const { return *hilite; }
+    const Texture &titleTexture() const { return *title; }
+    const Texture &frameTexture() const { return *frame; }
+    const Texture &hiliteTexture() const { return *hilite; }
     ///@}
 
-    inline const PixmapWithMask &bulletPixmap() const { return *m_bullet_pixmap; }
-    inline const PixmapWithMask &selectedPixmap() const { return *m_selected_pixmap; }
-    inline const PixmapWithMask &unselectedPixmap() const { return *m_unselected_pixmap; }
+    const PixmapWithMask &bulletPixmap() const { return *m_bullet_pixmap; }
+    const PixmapWithMask &selectedPixmap() const { return *m_selected_pixmap; }
+    const PixmapWithMask &unselectedPixmap() const { return *m_unselected_pixmap; }
 
-    inline const PixmapWithMask &highlightBulletPixmap() const { return *m_hl_bullet_pixmap; }
-    inline const PixmapWithMask &highlightSelectedPixmap() const { return *m_hl_selected_pixmap; }
-    inline const PixmapWithMask &highlightUnselectedPixmap() const { return *m_hl_unselected_pixmap; }
+    const PixmapWithMask &highlightBulletPixmap() const { return *m_hl_bullet_pixmap; }
+    const PixmapWithMask &highlightSelectedPixmap() const { return *m_hl_selected_pixmap; }
+    const PixmapWithMask &highlightUnselectedPixmap() const { return *m_hl_unselected_pixmap; }
     /**
        @name fonts
     */
     ///@{
-    inline const Font &titleFont() const { return *titlefont; }
-    inline Font &titleFont() { return *titlefont; }
-    inline const Font &frameFont() const { return *framefont; }
-    inline Font &frameFont() { return *framefont; }
+    const Font &titleFont() const { return *titlefont; }
+    Font &titleFont() { return *titlefont; }
+    const Font &frameFont() const { return *framefont; }
+    Font &frameFont() { return *framefont; }
     ///@}
 
-    inline Justify frameFontJustify() const { return *framefont_justify; }
-    inline Justify titleFontJustify() const { return *titlefont_justify; }
-	
+    Justify frameFontJustify() const { return *framefont_justify; }
+    Justify titleFontJustify() const { return *titlefont_justify; }
+
     /**
        @name graphic contexts
     */
     ///@{
-    inline const GContext &titleTextGC() const { return t_text_gc; }
-    inline const GContext &frameTextGC() const { return f_text_gc; }
-    inline const GContext &frameUnderlineGC() const { return u_text_gc; }
-    inline const GContext &hiliteTextGC() const { return h_text_gc; }
-    inline const GContext &disableTextGC() const { return d_text_gc; }
-    inline const GContext &hiliteGC() const { return hilite_gc; }
-    inline GContext &titleTextGC() { return t_text_gc; }
-    inline GContext &frameTextGC() { return f_text_gc; }
-    inline GContext &frameUnderlineGC() { return u_text_gc; }
-    inline GContext &hiliteTextGC() { return h_text_gc; }
-    inline GContext &disableTextGC() { return d_text_gc; }
-    inline GContext &hiliteGC() { return hilite_gc; }
+    const GContext &titleTextGC() const { return t_text_gc; }
+    const GContext &frameTextGC() const { return f_text_gc; }
+    const GContext &frameUnderlineGC() const { return u_text_gc; }
+    const GContext &hiliteTextGC() const { return h_text_gc; }
+    const GContext &disableTextGC() const { return d_text_gc; }
+    const GContext &hiliteGC() const { return hilite_gc; }
+    GContext &titleTextGC() { return t_text_gc; }
+    GContext &frameTextGC() { return f_text_gc; }
+    GContext &frameUnderlineGC() { return u_text_gc; }
+    GContext &hiliteTextGC() { return h_text_gc; }
+    GContext &disableTextGC() { return d_text_gc; }
+    GContext &hiliteGC() { return hilite_gc; }
     ///@}
-    inline BulletType bullet() const { return *m_bullet; }
-    inline Justify bulletPos() const { return *bullet_pos; }
+    BulletType bullet() const { return *m_bullet; }
+    Justify bulletPos() const { return *bullet_pos; }
 
-    inline unsigned int titleHeight() const { return m_real_title_height; }
-    inline unsigned int itemHeight() const { return m_real_item_height; }
-    inline unsigned int borderWidth() const { return *m_border_width; }
-    inline unsigned int bevelWidth() const { return *m_bevel_width; }
+    unsigned int titleHeight() const { return m_real_title_height; }
+    unsigned int itemHeight() const { return m_real_item_height; }
+    unsigned int borderWidth() const { return *m_border_width; }
+    unsigned int bevelWidth() const { return *m_bevel_width; }
 
-    inline unsigned char alpha() const { return m_alpha; }
-    inline void setAlpha(unsigned char alpha) { m_alpha = alpha; }
+    unsigned char alpha() const { return m_alpha; }
+    void setAlpha(unsigned char alpha) { m_alpha = alpha; }
     // this isn't actually a theme item
     // but we'll let it be here for now, until there's a better way to
     // get resources into menu
-    inline void setMenuMode(MenuMode mode) { m_menumode = mode; }
-    inline MenuMode menuMode() const { return m_menumode; }
-    inline void setDelayOpen(int msec) { m_delayopen = msec; }
-    inline void setDelayClose(int msec) { m_delayclose = msec; }
-    inline int delayOpen() const { return m_delayopen; }
-    inline int delayClose() const { return m_delayclose; }
-    
-    inline const Color &borderColor() const { return *m_border_color; }
-    inline Shape::ShapePlace shapePlaces() const { return *m_shapeplace; }
+    void setMenuMode(MenuMode mode) { m_menumode = mode; }
+    MenuMode menuMode() const { return m_menumode; }
+    void setDelayOpen(int msec) { m_delayopen = msec; }
+    void setDelayClose(int msec) { m_delayclose = msec; }
+    int delayOpen() const { return m_delayopen; }
+    int delayClose() const { return m_delayclose; }
+
+    const Color &borderColor() const { return *m_border_color; }
+    Shape::ShapePlace shapePlaces() const { return *m_shapeplace; }
 
     // special override
-    inline void setSelectedPixmap(Pixmap pm, bool is_imagecached) {
-        m_selected_pixmap->pixmap() = pm; 
+    void setSelectedPixmap(Pixmap pm, bool is_imagecached) {
+        m_selected_pixmap->pixmap() = pm;
         if (is_imagecached)
             m_selected_pixmap->pixmap().dontFree();
     }
 
-    inline void setHighlightSelectedPixmap(Pixmap pm, bool is_imagecached) {
-        m_hl_selected_pixmap->pixmap() = pm; 
+    void setHighlightSelectedPixmap(Pixmap pm, bool is_imagecached) {
+        m_hl_selected_pixmap->pixmap() = pm;
         if (is_imagecached)
             m_hl_selected_pixmap->pixmap().dontFree();
     }
@@ -148,7 +148,7 @@ ThemeItem<Color> t_text, f_text, h_text, d_text, u_text;
     ThemeItem<Texture> title, frame, hilite;
     ThemeItem<Font> titlefont, framefont;
     ThemeItem<Justify> framefont_justify, titlefont_justify;
-    ThemeItem<Justify> bullet_pos; 
+    ThemeItem<Justify> bullet_pos;
     ThemeItem<BulletType> m_bullet;
     ThemeItem<Shape::ShapePlace> m_shapeplace;
     ThemeItem<unsigned int> m_title_height, m_item_height;

@@ -59,9 +59,9 @@ 
     XLayer *getLayer(size_t num);
     const XLayer *getLayer(size_t num) const;
 
-    inline bool isUpdatable() const { return m_lock == 0; }
-    inline void lock() { ++m_lock; }
-    inline void unlock() { if (--m_lock == 0) restack(); }
+    bool isUpdatable() const { return m_lock == 0; }
+    void lock() { ++m_lock; }
+    void unlock() { if (--m_lock == 0) restack(); }
 
 private:
     std::vector<XLayer *> m_layers;

@@ -40,7 +40,7 @@ void setCommand(int button, FbTk::RefCount<FbTk::Command> &cmd);
     /// executes command for the button click
     virtual void click(int button, int time, unsigned int mods);
     /// @return number of buttons this instance handles
-    inline unsigned int buttons() const { return m_buttons; }
+    unsigned int buttons() const { return m_buttons; }
 
 private:
     void init(int buttons);

@@ -55,8 +55,8 @@ /// Base class for resources, this is only used in ResourceManager
 class Resource_base:private FbTk::NotCopyable
 {
 public:
-    virtual ~Resource_base() { };	
-	
+    virtual ~Resource_base() { };
+
     /// set from string value
     virtual void setFromString(char const *strval) = 0;
     /// set default value
@@ -64,18 +64,18 @@ virtual void setDefaultValue() = 0;
     /// get string value
     virtual std::string getString() const = 0;
     /// get alternative name of this resource
-    inline const std::string& altName() const { return m_altname; }
+    const std::string& altName() const { return m_altname; }
     /// get name of this resource
-    inline const std::string& name() const { return m_name; }
+    const std::string& name() const { return m_name; }
 
-protected:	
+protected:
     Resource_base(const std::string &name, const std::string &altname):
-	m_name(name), m_altname(altname)
-	{ }
+    m_name(name), m_altname(altname)
+    { }
 
 private:
     std::string m_name; ///< name of this resource
-    std::string m_altname; ///< alternative name 
+    std::string m_altname; ///< alternative name
 };
 
 template <typename T>
@@ -99,7 +99,7 @@ /// Save all resouces registered to this class
     /// @return true on success
     virtual bool save(const char *filename, const char *mergefilename=0);
 
-    
+
 
     /// Add resource to list, only used in Resource<T>
     template <class T>
@@ -122,21 +122,21 @@ std::string resourceValue(const std::string &resourcename) const;
     void setResourceValue(const std::string &resourcename, const std::string &value);
 
     /**
-     * Will search and cast the resource to Resource<Type>, 
+     * Will search and cast the resource to Resource<Type>,
      * it will throw exception if it fails
      * @return reference to resource type
      */
     template <typename ResourceType>
     Resource<ResourceType> &getResource(const std::string &resource);
 
-    // this marks the database as "in use" and will avoid reloading 
+    // this marks the database as "in use" and will avoid reloading
     // resources unless it is zero.
-    // It returns this resource manager. Useful for passing to 
+    // It returns this resource manager. Useful for passing to
     // constructors like Object(m_rm.lock())
     ResourceManager &lock();
     void unlock();
     // for debugging
-    inline int lockDepth() const { return m_db_lock; }
+    int lockDepth() const { return m_db_lock; }
     void dump() {
         ResourceList::iterator it = m_resourcelist.begin();
         ResourceList::iterator it_end = m_resourcelist.end();
@@ -171,33 +171,33 @@ * }
  */
 template <typename T>
 class Resource:public Resource_base, public Accessor<T> {
-public:	
+public:
     typedef T Type;
-    Resource(ResourceManager &rm, T val, 
+    Resource(ResourceManager &rm, T val,
              const std::string &name, const std::string &altname):
-	Resource_base(name, altname),
+    Resource_base(name, altname),
         m_value(val), m_defaultval(val),
-	m_rm(rm) {
+    m_rm(rm) {
         m_rm.addResource(*this); // add this to resource handler
     }
     virtual ~Resource() {
         m_rm.removeResource(*this); // remove this from resource handler
     }
 
-    inline void setDefaultValue() {  m_value = m_defaultval; }
+    void setDefaultValue() {  m_value = m_defaultval; }
     /// sets resource from string, specialized, must be implemented
     void setFromString(const char *strval);
-    inline Resource<T>& operator = (const T& newvalue) { m_value = newvalue;  return *this;}
+    Resource<T>& operator = (const T& newvalue) { m_value = newvalue;  return *this;}
     /// specialized, must be implemented
     /// @return string value of resource
     std::string getString() const;
 
-    inline operator T() const { return m_value; }
-    inline T& get() { return m_value; }
-    inline T& operator*() { return m_value; }
-    inline const T& operator*() const { return m_value; }
-    inline T *operator->() { return &m_value; }
-    inline const T *operator->() const { return &m_value; }
+    operator T() const { return m_value; }
+    T& get() { return m_value; }
+    T& operator*() { return m_value; }
+    const T& operator*() const { return m_value; }
+    T *operator->() { return &m_value; }
+    const T *operator->() const { return &m_value; }
 private:
     T m_value, m_defaultval;
     ResourceManager &m_rm;
@@ -233,17 +233,17 @@ }
 
     unlock();
 }
-	
+
 
 template <typename ResourceType>
 Resource<ResourceType> &ResourceManager::getResource(const std::string &resname) {
     Resource_base *res = findResource(resname);
     if (res == 0) {
-        throw ResourceException("Could not find resource \"" + 
+        throw ResourceException("Could not find resource \"" +
                                 resname + "\"");
     }
 
-    Resource<ResourceType> *res_type = 
+    Resource<ResourceType> *res_type =
         dynamic_cast<Resource<ResourceType> *>(res);
     if (res_type == 0) {
         throw ResourceException("Could not convert resource \"" +

@@ -68,7 +68,7 @@ const std::string &text() const { return m_text; }
     const Font &font() const { return *m_font; }
     GC gc() const { return m_gc; }
     int cursorPosition() const { return m_cursor_pos; }
-    inline int textStartPos(){ return m_start_pos; }
+    int textStartPos(){ return m_start_pos; }
 
     unsigned int findEmptySpaceLeft();
     unsigned int findEmptySpaceRight();

@@ -66,10 +66,10 @@ void exposeEvent(XExposeEvent &event);
 
     void renderForeground(FbDrawable &drawable);
 
-    inline FbTk::Justify justify() const { return m_justify; }
-    inline const std::string &text() const { return m_text; }
-    inline FbTk::Font &font() const { return *m_font; }
-    inline FbTk::Orientation orientation() const { return m_orientation; }
+    FbTk::Justify justify() const { return m_justify; }
+    const std::string &text() const { return m_text; }
+    FbTk::Font &font() const { return *m_font; }
+    FbTk::Orientation orientation() const { return m_orientation; }
     unsigned int textWidth() const;
 #ifdef NOT_USED
     unsigned int textHeight() const;

@@ -1,4 +1,4 @@ 
-// Texture.hh for Fluxbox Window Manager 
+// Texture.hh for Fluxbox Window Manager
 // Copyright (c) 2002-2003 Henrik Kinnunen (fluxbox<at>users.sourceforge.net)
 //
 // from Image.hh for Blackbox - an X11 Window manager
@@ -63,9 +63,9 @@ PYRAMID =        0x00800,
         PIPECROSS =      0x01000,
         ELLIPTIC =       0x02000
     };
-	
+
     enum {
-        BEVEL1 =         0x04000, 
+        BEVEL1 =         0x04000,
         BEVEL2 =         0x08000, // bevel types
         INVERT =         0x10000, ///< inverted image
         PARENTRELATIVE = 0x20000,
@@ -78,7 +78,7 @@ 
     void setType(unsigned long t) { m_type = t; }
     void addType(unsigned long t) { m_type |= t; }
     void setFromString(const char * const str);
-	
+
     Color &color() { return m_color; }
     Color &colorTo() { return m_color_to; }
     Color &hiColor() { return m_hicolor; }
@@ -93,8 +93,8 @@ const Color &colorTo() const { return m_color_to; }
     const Color &hiColor() const { return m_hicolor; }
     const Color &loColor() const { return m_locolor; }
     const FbTk::FbPixmap &pixmap() const { return m_pixmap; }
-    inline unsigned long type() const { return m_type; }
-    inline bool usePixmap() const { return !( type() == (FLAT | SOLID) && pixmap().drawable() == 0); }
+    unsigned long type() const { return m_type; }
+    bool usePixmap() const { return !( type() == (FLAT | SOLID) && pixmap().drawable() == 0); }
 
 private:
     FbTk::Color m_color, m_color_to, m_hicolor, m_locolor;

@@ -66,7 +66,7 @@ public:
     ThemeItem(FbTk::Theme &tm, const std::string &name, const std::string &altname);
     virtual ~ThemeItem();
     /// specialized
-    void setDefaultValue(); 
+    void setDefaultValue();
     /// specialized
     virtual void setFromString(const char *strval);
     /// specialized
@@ -77,10 +77,10 @@ /**
        @name access operators
     */
     /**@{*/
-    inline T& operator*() { return m_value; }
-    inline const T& operator*() const { return m_value; }
-    inline T *operator->() { return &m_value; }
-    inline const T *operator->() const { return &m_value; }
+    T& operator*() { return m_value; }
+    const T& operator*() const { return m_value; }
+    T *operator->() { return &m_value; }
+    const T *operator->() const { return &m_value; }
     /**@}*/
 
     FbTk::Theme &theme() { return m_tm; }
@@ -112,7 +112,7 @@ virtual bool fallback(ThemeItem_base &) { return false; }
     FbTk::Subject &reconfigSig() { return m_reconfig_sig; }
     const FbTk::Subject &reconfigSig() const { return m_reconfig_sig; }
 
-    
+
 private:
     const int m_screen_num;
 
@@ -131,7 +131,7 @@ typedef std::list<FbTk::Theme *> ThemeList;
     typedef std::vector<ThemeList> ScreenThemeVector;
 
     static ThemeManager &instance();
-    /// load style file "filename" to screen 
+    /// load style file "filename" to screen
     bool load(const std::string &filename, const std::string &overlay_filename, int screen_num = -1);
     std::string resourceValue(const std::string &name, const std::string &altname);
     void loadTheme(Theme &tm);
@@ -149,9 +149,9 @@ ThemeManager();
     ~ThemeManager() { }
 
     friend class FbTk::Theme; // so only theme can register itself in constructor
-    /// @return false if screen_num if out of 
+    /// @return false if screen_num if out of
     /// range or theme already registered, else true
-    bool registerTheme(FbTk::Theme &tm); 
+    bool registerTheme(FbTk::Theme &tm);
     /// @return false if theme isn't registred in the manager
     bool unregisterTheme(FbTk::Theme &tm);
     /// map each theme manager to a screen
@@ -167,7 +167,7 @@ 
 
 
 template <typename T>
-ThemeItem<T>::ThemeItem(FbTk::Theme &tm, 
+ThemeItem<T>::ThemeItem(FbTk::Theme &tm,
                         const std::string &name, const std::string &altname):
     ThemeItem_base(name, altname),
     m_tm(tm) {

@@ -21,9 +21,9 @@ // 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.
-	
-#ifndef	 FBTK_TIMER_HH
-#define	 FBTK_TIMER_HH
+
+#ifndef FBTK_TIMER_HH
+#define FBTK_TIMER_HH
 
 #include "RefCount.hh"
 #include "Command.hh"
@@ -52,7 +52,7 @@ 
 namespace FbTk {
 
 /**
-	Handles Timeout
+    Handles Timeout
 */
 class Timer {
 public:
@@ -60,7 +60,7 @@ Timer();
     explicit Timer(RefCount<Command> &handler);
     virtual ~Timer();
 
-    inline void fireOnce(bool once) { m_once = once; }
+    void fireOnce(bool once) { m_once = once; }
     /// set timeout
     void setTimeout(time_t val);
     /// set timeout 

@@ -30,7 +30,7 @@ namespace FbTk {
 
 template <typename Items, typename Item_Type>
 class TypeAhead {
-/*
+#if 0
 
 a class template can't be split into separate interface + implementation files, an interface summary is given here:
 
@@ -38,7 +38,7 @@ public:
     void init(Items const &items);
 
 // accessors:
-    inline int stringSize() const { return m_searchstr.size(); }
+    int stringSize() const { return m_searchstr.size(); }
     Items matched() const;
 
 // modifiers:
@@ -65,7 +65,7 @@ SearchResult &mySearchResult) const;
     void doSearch(char to_test,
             BaseItems const &search,
             SearchResult &mySearchResult) const;
-*/
+#endif
 
 public:
     typedef std::vector < ITypeAheadable* > BaseItems;
@@ -75,7 +75,7 @@ typedef typename Items::const_iterator ItemscIt;
 
     void init(Items const &items) { m_ref = &items; }
 
-    inline size_t stringSize() const { return m_searchstr.size(); }
+    size_t stringSize() const { return m_searchstr.size(); }
 
     void seek() {
         if (!m_search_results.empty())

@@ -63,13 +63,13 @@ // STRICTINTERNAL means it doesn't go external automatically when no titlebar
     enum TabMode { NOTSET = 0, INTERNAL = 1, EXTERNAL };
 
    /// Toolbar placement on the screen
-    enum TabPlacement{ 
+    enum TabPlacement{
         // top and bottom placement
         TOPLEFT = 1, BOTTOMLEFT,
         TOPRIGHT, BOTTOMRIGHT,
         // left and right placement
         LEFTBOTTOM, LEFTTOP,
-        RIGHTBOTTOM, RIGHTTOP        
+        RIGHTBOTTOM, RIGHTTOP
     };
 
     /**
@@ -108,9 +108,9 @@ int x, int y,
                unsigned int width, unsigned int height);
 
 /*    /// create a frame window inside another FbWindow, NOT IMPLEMENTED!
-    FbWinFrame(BScreen &screen, FbWinFrameTheme &theme, FbTk::ImageControl &imgctrl, 
+    FbWinFrame(BScreen &screen, FbWinFrameTheme &theme, FbTk::ImageControl &imgctrl,
                const FbTk::FbWindow &parent,
-               int x, int y, 
+               int x, int y,
                unsigned int width, unsigned int height);
 */
     /// destroy frame
@@ -118,7 +118,7 @@ ~FbWinFrame();
 
     void hide();
     void show();
-    inline bool isVisible() const { return m_visible; }
+    bool isVisible() const { return m_visible; }
     /// shade frame (ie resize to titlebar size)
     void shade();
     void move(int x, int y);
@@ -127,17 +127,17 @@ /// resize client to specified size and resize frame to it
     void resizeForClient(unsigned int width, unsigned int height, int win_gravity=ForgetGravity, unsigned int client_bw = 0);
 
     // for when there needs to be an atomic move+resize operation
-    void moveResizeForClient(int x, int y, 
-                             unsigned int width, unsigned int height, 
+    void moveResizeForClient(int x, int y,
+                             unsigned int width, unsigned int height,
                              int win_gravity=ForgetGravity, unsigned int client_bw = 0, bool move = true, bool resize = true);
 
     // can elect to ignore move or resize (mainly for use of move/resize individual functions
-    void moveResize(int x, int y, 
-                    unsigned int width, unsigned int height, 
+    void moveResize(int x, int y,
+                    unsigned int width, unsigned int height,
                     bool move = true, bool resize = true);
 
     // move without transparency or special effects (generally when dragging)
-    void quietMoveResize(int x, int y, 
+    void quietMoveResize(int x, int y,
                          unsigned int width, unsigned int height);
 
     /// some outside move/resize happened, and we need to notify all of our windows
@@ -147,9 +147,9 @@ void clearAll();
 
     /// set focus/unfocus style
     void setFocus(bool newvalue);
-    inline void setFocusTitle(const std::string &str) { m_label.setText(str); }
+    void setFocusTitle(const std::string &str) { m_label.setText(str); }
     bool setTabMode(TabMode tabmode);
-    inline void updateTabProperties() { alignTabs(); }
+    void updateTabProperties() { alignTabs(); }
 
     /// Alpha settings
     void setAlpha(bool focused, unsigned char value);
@@ -215,7 +215,7 @@ void exposeEvent(XExposeEvent &event);
     void configureNotifyEvent(XConfigureEvent &event);
     void handleEvent(XEvent &event);
     //@}
- 
+
     void reconfigure();
     void setUseShape(bool value);
     void setShapingClient(FbTk::FbWindow *win, bool always_update);
@@ -225,10 +225,10 @@ /**
        @name accessors
     */
     //@{
-    inline int x() const { return m_window.x(); }
-    inline int y() const { return m_window.y(); }
-    inline unsigned int width() const { return m_window.width(); }
-    inline unsigned int height() const { return m_window.height(); }
+    int x() const { return m_window.x(); }
+    int y() const { return m_window.y(); }
+    unsigned int width() const { return m_window.width(); }
+    unsigned int height() const { return m_window.height(); }
     unsigned int normalHeight() const;
 
     // extra bits for tabs
@@ -237,31 +237,31 @@ int yOffset() const;
     int widthOffset() const;
     int heightOffset() const;
 
-    inline const FbTk::FbWindow &window() const { return m_window; }
-    inline FbTk::FbWindow &window() { return m_window; }
+    const FbTk::FbWindow &window() const { return m_window; }
+    FbTk::FbWindow &window() { return m_window; }
     /// @return titlebar window
-    inline const FbTk::FbWindow &titlebar() const { return m_titlebar; }
-    inline FbTk::FbWindow &titlebar() { return m_titlebar; }
-    inline const FbTk::FbWindow &label() const { return m_label; }
-    inline FbTk::FbWindow &label() { return m_label; }
+    const FbTk::FbWindow &titlebar() const { return m_titlebar; }
+    FbTk::FbWindow &titlebar() { return m_titlebar; }
+    const FbTk::FbWindow &label() const { return m_label; }
+    FbTk::FbWindow &label() { return m_label; }
+
+    const FbTk::Container &tabcontainer() const { return m_tab_container; }
+    FbTk::Container &tabcontainer() { return m_tab_container; }
 
-    inline const FbTk::Container &tabcontainer() const { return m_tab_container; }
-    inline FbTk::Container &tabcontainer() { return m_tab_container; }
-    
     /// @return clientarea window
-    inline const FbTk::FbWindow &clientArea() const { return m_clientarea; }
-    inline FbTk::FbWindow &clientArea() { return m_clientarea; }
+    const FbTk::FbWindow &clientArea() const { return m_clientarea; }
+    FbTk::FbWindow &clientArea() { return m_clientarea; }
     /// @return handle window
-    inline const FbTk::FbWindow &handle() const { return m_handle; }
-    inline FbTk::FbWindow &handle() { return m_handle; }
-    inline const FbTk::FbWindow &gripLeft() const { return m_grip_left; }
-    inline FbTk::FbWindow &gripLeft() { return m_grip_left; }
-    inline const FbTk::FbWindow &gripRight() const { return m_grip_right; }
-    inline FbTk::FbWindow &gripRight() { return m_grip_right; }
-    inline const IconButton *currentLabel() const { return m_current_label; }
-    inline bool focused() const { return m_focused; }
-    inline bool isShaded() const { return m_shaded; }
-    inline FbWinFrameTheme &theme() const { return m_theme; }
+    const FbTk::FbWindow &handle() const { return m_handle; }
+    FbTk::FbWindow &handle() { return m_handle; }
+    const FbTk::FbWindow &gripLeft() const { return m_grip_left; }
+    FbTk::FbWindow &gripLeft() { return m_grip_left; }
+    const FbTk::FbWindow &gripRight() const { return m_grip_right; }
+    FbTk::FbWindow &gripRight() { return m_grip_right; }
+    const IconButton *currentLabel() const { return m_current_label; }
+    bool focused() const { return m_focused; }
+    bool isShaded() const { return m_shaded; }
+    FbWinFrameTheme &theme() const { return m_theme; }
     /// @return titlebar height
     unsigned int titlebarHeight() const { return (m_use_titlebar?m_titlebar.height()+m_window.borderWidth():0); }
     unsigned int handleHeight() const { return (m_use_handle?m_handle.height()+m_window.borderWidth():0); }
@@ -269,8 +269,8 @@ /// @return size of button
     unsigned int buttonHeight() const;
     bool externalTabMode() const { return m_tabmode == EXTERNAL && m_use_tabs; }
 
-    inline const FbTk::XLayerItem &layerItem() const { return m_layeritem; }
-    inline FbTk::XLayerItem &layerItem() { return m_layeritem; }
+    const FbTk::XLayerItem &layerItem() const { return m_layeritem; }
+    FbTk::XLayerItem &layerItem() { return m_layeritem; }
 
     //@}
 
@@ -320,7 +320,7 @@ void init();
 
     BScreen &m_screen;
 
-    FbWinFrameTheme &m_theme; ///< theme to be used 
+    FbWinFrameTheme &m_theme; ///< theme to be used
     FbTk::ImageControl &m_imagectrl; ///< Image control for rendering
     /**
        @name windows
@@ -373,9 +373,9 @@ FbTk::Color m_tabcontainer_unfocused_color; ///< color for unfocused tab container
 
     FbTk::Color m_handle_focused_color, m_handle_unfocused_color;
     Pixmap m_handle_focused_pm, m_handle_unfocused_pm;
-    
 
-    Pixmap m_button_pm;  ///< normal button     
+
+    Pixmap m_button_pm;  ///< normal button
     FbTk::Color m_button_color; ///< normal color button
     Pixmap m_button_unfocused_pm; ///< unfocused button
     FbTk::Color m_button_unfocused_color; ///< unfocused color button

@@ -52,7 +52,7 @@ const FbTk::Texture &handleUnfocusTexture() const { return *m_handle_unfocus; }
 
     const FbTk::Texture &buttonFocusTexture() const { return *m_button_focus; }
     const FbTk::Texture &buttonUnfocusTexture() const { return *m_button_unfocus; }
-    const FbTk::Texture &buttonPressedTexture() const { return *m_button_pressed; }    
+    const FbTk::Texture &buttonPressedTexture() const { return *m_button_pressed; }
 
     const FbTk::Texture &gripFocusTexture() const { return *m_grip_focus; }
     const FbTk::Texture &gripUnfocusTexture() const { return *m_grip_unfocus; }
@@ -73,18 +73,18 @@ 
     bool fallback(FbTk::ThemeItem_base &item);
     void reconfigTheme();
 
-    inline Cursor moveCursor() const { return m_cursor_move; }
-    inline Cursor lowerLeftAngleCursor() const { return m_cursor_lower_left_angle; }
-    inline Cursor lowerRightAngleCursor() const { return m_cursor_lower_right_angle; }
-    inline Cursor upperLeftAngleCursor() const { return m_cursor_upper_left_angle; }
-    inline Cursor upperRightAngleCursor() const { return m_cursor_upper_right_angle; }
-    inline Cursor leftSideCursor() const { return m_cursor_left_side; }
-    inline Cursor rightSideCursor() const { return m_cursor_right_side; }
-    inline Cursor topSideCursor() const { return m_cursor_top_side; }
-    inline Cursor bottomSideCursor() const { return m_cursor_bottom_side; }
+    Cursor moveCursor() const { return m_cursor_move; }
+    Cursor lowerLeftAngleCursor() const { return m_cursor_lower_left_angle; }
+    Cursor lowerRightAngleCursor() const { return m_cursor_lower_right_angle; }
+    Cursor upperLeftAngleCursor() const { return m_cursor_upper_left_angle; }
+    Cursor upperRightAngleCursor() const { return m_cursor_upper_right_angle; }
+    Cursor leftSideCursor() const { return m_cursor_left_side; }
+    Cursor rightSideCursor() const { return m_cursor_right_side; }
+    Cursor topSideCursor() const { return m_cursor_top_side; }
+    Cursor bottomSideCursor() const { return m_cursor_bottom_side; }
 
-    inline FbTk::Shape::ShapePlace shapePlace() const { return *m_shape_place; }
-    inline const FbTk::BorderTheme &border(bool focus) const { return (focus ? m_border_focus : m_border_unfocus); }
+    FbTk::Shape::ShapePlace shapePlace() const { return *m_shape_place; }
+    const FbTk::BorderTheme &border(bool focus) const { return (focus ? m_border_focus : m_border_unfocus); }
 
     unsigned int titleHeight() const { return *m_title_height; }
     unsigned int bevelWidth() const { return *m_bevel_width; }
@@ -104,7 +104,7 @@ FbTk::ThemeItem<FbTk::Texture> m_button_focus, m_button_unfocus, m_button_pressed;
     FbTk::ThemeItem<FbTk::Texture> m_grip_focus, m_grip_unfocus;
 
     FbTk::ThemeItem<FbTk::Color> m_button_focus_color, m_button_unfocus_color;
-    
+
     FbTk::ThemeItem<FbTk::Font> m_font;
     FbTk::ThemeItem<FbTk::Shape::ShapePlace> m_shape_place;
 

@@ -69,27 +69,27 @@ /// @return return true if it can be focused
     virtual bool acceptsFocus() const { return true; }
 
     /// @return true if icon button should appear focused
-    inline bool getAttentionState() const { return m_attention_state; }
+    bool getAttentionState() const { return m_attention_state; }
     /// @set the attention state
     virtual void setAttentionState(bool value) {
         m_attention_state = value; attentionSig().notify();
     }
 
     /// @return the screen in which this object resides
-    inline BScreen &screen() { return m_screen; }
+    BScreen &screen() { return m_screen; }
     /// @return the screen in which this object resides
-    inline const BScreen &screen() const { return m_screen; }
+    const BScreen &screen() const { return m_screen; }
 
     /**
      *  For accessing window properties, like shaded, minimized, etc.
      *  @return window context
      */
-    inline const FluxboxWindow *fbwindow() const { return m_fbwin; }
+    const FluxboxWindow *fbwindow() const { return m_fbwin; }
     /**
      *  For accessing window properties, like shaded, minimized, etc.
      *  @return window context
      */
-    inline FluxboxWindow *fbwindow() { return m_fbwin; }
+    FluxboxWindow *fbwindow() { return m_fbwin; }
 
     /// @return WM_CLASS class string (for pattern matching)
     virtual const std::string &getWMClassClass() const { return m_class_name; }

@@ -48,57 +48,57 @@ class Application {
 public:
     Application(bool grouped, ClientPattern *pat = 0);
     void reset();
-    inline void forgetWorkspace() { workspace_remember = false; }
-    inline void forgetHead() { head_remember = false; }
-    inline void forgetDimensions() { dimensions_remember = false; }
-    inline void forgetPosition() { position_remember = false; }
-    inline void forgetShadedstate() { shadedstate_remember = false; }
-    inline void forgetTabstate() { tabstate_remember = false; }
-    inline void forgetDecostate() { decostate_remember = false; }
-    inline void forgetFocusHiddenstate() { focushiddenstate_remember= false; }
-    inline void forgetIconHiddenstate() { iconhiddenstate_remember= false; }
-    inline void forgetStuckstate() { stuckstate_remember = false; }
-    inline void forgetJumpworkspace() { jumpworkspace_remember = false; }
-    inline void forgetLayer() { layer_remember = false; }
-    inline void forgetSaveOnClose() { save_on_close_remember = false; }
-    inline void forgetAlpha() { alpha_remember = false; }
-    inline void forgetMinimizedstate() { minimizedstate_remember = false; }
-    inline void forgetMaximizedstate() { maximizedstate_remember = false; }
-    inline void forgetFullscreenstate() { fullscreenstate_remember = false; }
+    void forgetWorkspace() { workspace_remember = false; }
+    void forgetHead() { head_remember = false; }
+    void forgetDimensions() { dimensions_remember = false; }
+    void forgetPosition() { position_remember = false; }
+    void forgetShadedstate() { shadedstate_remember = false; }
+    void forgetTabstate() { tabstate_remember = false; }
+    void forgetDecostate() { decostate_remember = false; }
+    void forgetFocusHiddenstate() { focushiddenstate_remember= false; }
+    void forgetIconHiddenstate() { iconhiddenstate_remember= false; }
+    void forgetStuckstate() { stuckstate_remember = false; }
+    void forgetJumpworkspace() { jumpworkspace_remember = false; }
+    void forgetLayer() { layer_remember = false; }
+    void forgetSaveOnClose() { save_on_close_remember = false; }
+    void forgetAlpha() { alpha_remember = false; }
+    void forgetMinimizedstate() { minimizedstate_remember = false; }
+    void forgetMaximizedstate() { maximizedstate_remember = false; }
+    void forgetFullscreenstate() { fullscreenstate_remember = false; }
 
-    inline void rememberWorkspace(int ws)
+    void rememberWorkspace(int ws)
         { workspace = ws; workspace_remember = true; }
-    inline void rememberHead(int h)
+    void rememberHead(int h)
         { head = h; head_remember = true; }
-    inline void rememberDimensions(int width, int height)
+    void rememberDimensions(int width, int height)
         { w = width; h = height; dimensions_remember = true; }
-    inline void rememberFocusHiddenstate(bool state)
+    void rememberFocusHiddenstate(bool state)
         { focushiddenstate= state; focushiddenstate_remember= true; }
-    inline void rememberIconHiddenstate(bool state)
+    void rememberIconHiddenstate(bool state)
         { iconhiddenstate= state; iconhiddenstate_remember= true; }
-    inline void rememberPosition(int posx, int posy, unsigned char rfc= 0 )
+    void rememberPosition(int posx, int posy, unsigned char rfc= 0 )
         { x = posx; y = posy; refc = rfc; position_remember = true; }
-    inline void rememberShadedstate(bool state)
+    void rememberShadedstate(bool state)
         { shadedstate = state; shadedstate_remember = true; }
-    inline void rememberTabstate(bool state)
+    void rememberTabstate(bool state)
         { tabstate = state; tabstate_remember = true; }
-    inline void rememberDecostate(unsigned int state)
+    void rememberDecostate(unsigned int state)
         { decostate = state; decostate_remember = true; }
-    inline void rememberStuckstate(bool state)
+    void rememberStuckstate(bool state)
         { stuckstate = state; stuckstate_remember = true; }
-    inline void rememberJumpworkspace(bool state)
+    void rememberJumpworkspace(bool state)
         { jumpworkspace = state; jumpworkspace_remember = true; }
-    inline void rememberLayer(int layernum) 
+    void rememberLayer(int layernum) 
         { layer = layernum; layer_remember = true; }
-    inline void rememberSaveOnClose(bool state)
+    void rememberSaveOnClose(bool state)
         { save_on_close = state; save_on_close_remember = true; }
-    inline void rememberAlpha(int focused_a, int unfocused_a)
+    void rememberAlpha(int focused_a, int unfocused_a)
         { focused_alpha = focused_a; unfocused_alpha = unfocused_a; alpha_remember = true; }
-    inline void rememberMinimizedstate(bool state)
+    void rememberMinimizedstate(bool state)
         { minimizedstate = state; minimizedstate_remember = true; }
-    inline void rememberMaximizedstate(int state)
+    void rememberMaximizedstate(int state)
         { maximizedstate = state; maximizedstate_remember = true; }
-    inline void rememberFullscreenstate(bool state)
+    void rememberFullscreenstate(bool state)
         { fullscreenstate = state; fullscreenstate_remember = true; }
 
     bool workspace_remember;

@@ -24,8 +24,8 @@ // DEALINGS IN THE SOFTWARE.
 
 // $Id$
 
-#ifndef	 SCREEN_HH
-#define	 SCREEN_HH
+#ifndef SCREEN_HH
+#define SCREEN_HH
 
 #include "FbWinFrame.hh"
 #include "FbRootWindow.hh"
@@ -83,11 +83,11 @@ class BScreen: public FbTk::EventHandler, public FbTk::Observer,
                private FbTk::NotCopyable {
 public:
     /// a window becomes active / focussed on a different workspace
-    enum FollowModel { 
+    enum FollowModel {
         IGNORE_OTHER_WORKSPACES = 0, ///< who cares?
         FOLLOW_ACTIVE_WINDOW,     ///< go to that workspace
         SEMIFOLLOW_ACTIVE_WINDOW, ///< fetch iconified windows, else follow
-        FETCH_ACTIVE_WINDOW       ///< put that window to the current workspace 
+        FETCH_ACTIVE_WINDOW       ///< put that window to the current workspace
     };
 
 
@@ -129,41 +129,41 @@ const FbTk::Menu &windowMenu() const { return *m_windowmenu.get(); }
     FbTk::Menu &windowMenu() { return *m_windowmenu.get(); }
     ExtraMenus &extraWindowMenus() { return m_extramenus; }
     const ExtraMenus &extraWindowMenus() const { return m_extramenus; }
-    
+
     FbWinFrame::TabPlacement getTabPlacement() const { return *resource.tab_placement; }
 
-    inline unsigned int noFocusWhileTypingDelay() const { return *resource.typing_delay; }
-    inline FollowModel getFollowModel() const { return *resource.follow_model; }
-    inline FollowModel getUserFollowModel() const { return *resource.user_follow_model; }
+    unsigned int noFocusWhileTypingDelay() const { return *resource.typing_delay; }
+    FollowModel getFollowModel() const { return *resource.follow_model; }
+    FollowModel getUserFollowModel() const { return *resource.user_follow_model; }
 
-    inline const std::string &getScrollAction() const { return *resource.scroll_action; }
-    inline const bool getScrollReverse() const { return *resource.scroll_reverse; }
-    inline const bool allowRemoteActions() const { return *resource.allow_remote_actions; }
-    inline const bool clientMenuUsePixmap() const { return *resource.clientmenu_use_pixmap; }
-    inline const bool getDefaultInternalTabs() const { return *resource.default_internal_tabs; }
-    inline const bool getTabsUsePixmap() const { return *resource.tabs_use_pixmap; }
-    inline const bool getMaxOverTabs() const { return *resource.max_over_tabs; }
+    const std::string &getScrollAction() const { return *resource.scroll_action; }
+    const bool getScrollReverse() const { return *resource.scroll_reverse; }
+    const bool allowRemoteActions() const { return *resource.allow_remote_actions; }
+    const bool clientMenuUsePixmap() const { return *resource.clientmenu_use_pixmap; }
+    const bool getDefaultInternalTabs() const { return *resource.default_internal_tabs; }
+    const bool getTabsUsePixmap() const { return *resource.tabs_use_pixmap; }
+    const bool getMaxOverTabs() const { return *resource.max_over_tabs; }
 
-    inline unsigned int getTabWidth() const { return *resource.tab_width; }
+    unsigned int getTabWidth() const { return *resource.tab_width; }
     /// @return the slit, @see Slit
-    inline Slit *slit() { return m_slit.get(); }
+    Slit *slit() { return m_slit.get(); }
     /// @return the slit, @see Slit
-    inline const Slit *slit() const { return m_slit.get(); }
+    const Slit *slit() const { return m_slit.get(); }
     /**
      * @param w the workspace number
      * @return workspace for the given workspace number
      */
-    inline Workspace *getWorkspace(unsigned int w) { return ( w < m_workspaces_list.size() ? m_workspaces_list[w] : 0); }
+    Workspace *getWorkspace(unsigned int w) { return ( w < m_workspaces_list.size() ? m_workspaces_list[w] : 0); }
     /**
      * @param w the workspace number
      * @return workspace for the given workspace number
      */
-    inline const Workspace *getWorkspace(unsigned int w) const {
+    const Workspace *getWorkspace(unsigned int w) const {
         return (w < m_workspaces_list.size() ? m_workspaces_list[w] : 0);
     }
     /// @return the current workspace
-    inline Workspace *currentWorkspace() { return m_current_workspace; }
-    inline const Workspace *currentWorkspace() const { return m_current_workspace; }
+    Workspace *currentWorkspace() { return m_current_workspace; }
+    const Workspace *currentWorkspace() const { return m_current_workspace; }
     /// @return the workspace menu
     const FbTk::Menu &workspaceMenu() const { return *m_workspacemenu.get(); }
     /// @return the workspace menu
@@ -211,12 +211,12 @@ @name Screen signals
     */
     //@{
     /// client list signal
-    FbTk::Subject &clientListSig() { return m_clientlist_sig; } 
+    FbTk::Subject &clientListSig() { return m_clientlist_sig; }
     /// icon list sig
     FbTk::Subject &iconListSig() { return m_iconlist_sig; }
     /// workspace count signal
     FbTk::Subject &workspaceCountSig() { return m_workspacecount_sig; }
-    /// workspace names signal 
+    /// workspace names signal
     FbTk::Subject &workspaceNamesSig() { return m_workspacenames_sig; }
     /// workspace area signal
     FbTk::Subject &workspaceAreaSig() { return m_workspace_area_sig; }
@@ -260,14 +260,14 @@ * @return created menu
      */
     FbTk::Menu *createToggleMenu(const std::string &label);
 
-    /** 
+    /**
      * For extras to add menus.
      * These menus will be marked internal,
      * and deleted when the window dies (as opposed to Screen
      */
     void addExtraWindowMenu(const FbTk::FbString &label, FbTk::Menu *menu);
 
-    inline int getEdgeSnapThreshold() const { return *resource.edge_snap_threshold; }
+    int getEdgeSnapThreshold() const { return *resource.edge_snap_threshold; }
 
     void setRootColormapInstalled(bool r) { root_colormap_installed = r;  }
 
@@ -302,7 +302,7 @@ bool isRestart();
 
     ScreenPlacement &placementStrategy() { return *m_placement_strategy; }
     const ScreenPlacement &placementStrategy() const { return *m_placement_strategy; }
-    
+
     int addWorkspace();
     int removeLastWorkspace();
     // scroll workspaces
@@ -333,7 +333,7 @@ void leftWorkspace(int delta);
 
     /// update workspace name for given workspace
     void updateWorkspaceName(unsigned int w);
-    /// remove all workspace names 
+    /// remove all workspace names
     void removeWorkspaceNames();
     /// update the workspace name atom
     void updateWorkspaceNamesAtom();
@@ -361,7 +361,7 @@ * @param workspace the workspace id
      * @param win the window to send
      * @param changeworkspace whether current workspace should change
      */
-    void sendToWorkspace(unsigned int workspace, FluxboxWindow *win=0, 
+    void sendToWorkspace(unsigned int workspace, FluxboxWindow *win=0,
                          bool changeworkspace=true);
     /**
      * Reassociate a window to another workspace
@@ -369,12 +369,12 @@ * @param window the window to reassociate
      * @param workspace_id id of the workspace
      * @param ignore_sticky ignores any sticky windows
      */
-    void reassociateWindow(FluxboxWindow *window, unsigned int workspace_id, 
+    void reassociateWindow(FluxboxWindow *window, unsigned int workspace_id,
                            bool ignore_sticky);
 
 
-    void reconfigure();	
-    void reconfigureTabs();	
+    void reconfigure();
+    void reconfigureTabs();
     void rereadMenu();
     void shutdown();
     /// show position window centered on the screen with "X x Y" text
@@ -383,11 +383,11 @@ void hidePosition();
     /// show geomentry with "width x height"-text, not size of window
     void showGeometry(int width, int height);
     void hideGeometry();
-    
+
     void setLayer(FbTk::XLayerItem &item, int layernum);
     // remove? no, items are never removed from their layer until they die
 
-    /// updates root window size and resizes/reconfigures screen clients 
+    /// updates root window size and resizes/reconfigures screen clients
     /// that depends on screen size (slit)
     /// (and maximized windows?)
     void updateSize();
@@ -428,7 +428,7 @@ // the object really knowing about it.
     template <typename OnHeadObject>
     int getOnHead(OnHeadObject &obj) const;
 
-    // grouping - we want ordering, so we can either search for a 
+    // grouping - we want ordering, so we can either search for a
     // group to the left, or to the right (they'll be different if
     // they exist).
     WinClient *findGroupLeft(WinClient &winclient);
@@ -441,7 +441,7 @@ FluxboxWindow *createWindow(WinClient &client);
     /// request workspace space, i.e "don't maximize over this area"
     Strut *requestStrut(int head, int left, int right, int top, int bottom);
     /// remove requested space and destroy strut
-    void clearStrut(Strut *strut); 
+    void clearStrut(Strut *strut);
     /// updates max avaible area for the workspace
     void updateAvailableWorkspaceArea();
 
@@ -477,20 +477,20 @@ void renderPosWindow();
 
     const Strut* availableWorkspaceArea(int head) const;
 
-    ScreenSubject 
+    ScreenSubject
     m_clientlist_sig,  ///< client signal
         m_iconlist_sig, ///< notify if a window gets iconified/deiconified
         m_workspacecount_sig, ///< workspace count signal
-        m_workspacenames_sig, ///< workspace names signal 
+        m_workspacenames_sig, ///< workspace names signal
         m_workspace_area_sig, ///< workspace area changed signal
         m_currentworkspace_sig, ///< current workspace signal
         m_focusedwindow_sig, ///< focused window signal
         m_reconfigure_sig, ///< reconfigure signal
         m_resize_sig, ///< resize signal
         m_bg_change_sig; ///< background change signal
-		
+
     FbTk::MultLayers m_layermanager;
-	
+
     bool root_colormap_installed, managed, geom_visible, pos_visible;
 
     GC opGC;
@@ -585,7 +585,7 @@ 
     HeadArea *m_head_areas;
 
     struct XineramaHeadInfo {
-        int x, y, width, height;        
+        int x, y, width, height;
     } *m_xinerama_headinfo;
 
     bool m_restart, m_shutdown;

@@ -8,24 +8,24 @@ // 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 
+// 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 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 
+// 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$
 
-#ifndef	 SLIT_HH
-#define	 SLIT_HH
+#ifndef SLIT_HH
+#define SLIT_HH
 
 
 #include "LayerMenu.hh"
@@ -54,7 +54,7 @@ 
 /// Handles dock apps
 class Slit: public FbTk::EventHandler, public FbTk::Observer, public LayerObject {
 public:
-    typedef std::list<SlitClient *> SlitClients;    
+    typedef std::list<SlitClient *> SlitClients;
     /**
        Client alignment
     */
@@ -100,7 +100,7 @@ void exposeEvent(XExposeEvent &event);
     //@}
 
     void update(FbTk::Subject *subj);
-	
+
     void moveToLayer(int layernum);
     void toggleHidden();
 
@@ -111,29 +111,29 @@ const SlitTheme &theme() const { return *m_slit_theme.get(); }
 
     int layerNumber() const { return m_layeritem->getLayerNum(); }
 
-    inline bool isHidden() const { return m_hidden; }
-    inline bool acceptKdeDockapp() const { return *m_rc_kde_dockapp; }
-    inline bool doAutoHide() const { return *m_rc_auto_hide; }
-    inline Direction direction() const { return *m_rc_direction; }
-    inline Placement placement() const { return *m_rc_placement; }
-    inline int getOnHead() const { return *m_rc_on_head; }
+    bool isHidden() const { return m_hidden; }
+    bool acceptKdeDockapp() const { return *m_rc_kde_dockapp; }
+    bool doAutoHide() const { return *m_rc_auto_hide; }
+    Direction direction() const { return *m_rc_direction; }
+    Placement placement() const { return *m_rc_placement; }
+    int getOnHead() const { return *m_rc_on_head; }
     void saveOnHead(int head);
     FbTk::Menu &menu() { return m_slitmenu; }
 
-    inline const FbTk::FbWindow &window() const { return frame.window; }
+    const FbTk::FbWindow &window() const { return frame.window; }
 
-    inline int x() const { return (m_hidden ? frame.x_hidden : frame.x); }
-    inline int y() const { return (m_hidden ? frame.y_hidden : frame.y); }
+    int x() const { return (m_hidden ? frame.x_hidden : frame.x); }
+    int y() const { return (m_hidden ? frame.y_hidden : frame.y); }
 
-    inline unsigned int width() const { return frame.width; }
-    inline unsigned int height() const { return frame.height; }
+    unsigned int width() const { return frame.width; }
+    unsigned int height() const { return frame.height; }
     const SlitClients &clients() const { return m_client_list; }
     SlitClients &clients() { return m_client_list; }
 private:
     void updateAlpha();
     void clearWindow();
     void setupMenu();
-	
+
     void removeClient(SlitClient *client, bool remap, bool destroy);
     void loadClientList(const char *filename);
     void updateClientmenu();
@@ -153,9 +153,9 @@ std::string m_filename;
 
     struct frame {
         frame(const FbTk::FbWindow &parent):
-            window(parent, 0, 0, 10, 10, 
-                   SubstructureRedirectMask |  ButtonPressMask | 
-                   EnterWindowMask | LeaveWindowMask | ExposureMask, 
+            window(parent, 0, 0, 10, 10,
+                   SubstructureRedirectMask |  ButtonPressMask |
+                   EnterWindowMask | LeaveWindowMask | ExposureMask,
                    true),  // override redirect
             x(0), y(0), x_hidden(0), y_hidden(0),
         width(10), height(10) {}

@@ -40,14 +40,14 @@ SlitClient(BScreen *screen, Window win);
     /// For adding a placeholder
     explicit SlitClient(const char *name);
 
-    inline const std::string &matchName() const { return m_match_name; }
-    inline Window window() const { return m_window; }
-    inline Window clientWindow() const { return m_client_window; }
-    inline Window iconWindow() const { return m_icon_window; }
-    inline int x() const { return m_x; }
-    inline int y() const { return m_y; }
-    inline unsigned int width() const { return m_width; }
-    inline unsigned int height() const { return m_height; }
+    const std::string &matchName() const { return m_match_name; }
+    Window window() const { return m_window; }
+    Window clientWindow() const { return m_client_window; }
+    Window iconWindow() const { return m_icon_window; }
+    int x() const { return m_x; }
+    int y() const { return m_y; }
+    unsigned int width() const { return m_width; }
+    unsigned int height() const { return m_height; }
     bool visible() const { return m_visible; }
 
 

@@ -27,16 +27,16 @@ #define STRUT_HH
 
 class Strut {
 public:
-    Strut(int head, int left, int right, 
+    Strut(int head, int left, int right,
           int top, int bottom, Strut* next = 0)
-        :m_head(head), m_left(left), m_right(right), 
+        :m_head(head), m_left(left), m_right(right),
          m_top(top), m_bottom(bottom), m_next(next) { }
-    inline int head() const { return m_head; }
-    inline int left() const { return m_left; }
-    inline int right() const { return m_right; }
-    inline int bottom() const { return m_bottom; }
-    inline int top() const { return m_top; }
-    inline Strut* next() const { return m_next; }
+    int head() const { return m_head; }
+    int left() const { return m_left; }
+    int right() const { return m_right; }
+    int bottom() const { return m_bottom; }
+    int top() const { return m_top; }
+    Strut* next() const { return m_next; }
     bool operator == (const Strut &test) const {
         return (head() == test.head() &&
                 left() == test.left() &&

@@ -69,8 +69,8 @@ 
     int numClients() const { return m_clients.size(); }
     const FbTk::FbWindow &window() const { return m_window; }
 
-    inline void renderTheme(unsigned char alpha) { m_window.setAlpha(alpha); update(0); }
-    inline void updateSizing() {}
+    void renderTheme(unsigned char alpha) { m_window.setAlpha(alpha); update(0); }
+    void updateSizing() {}
 
     void parentMoved() { m_window.parentMoved(); }
 
@@ -79,7 +79,7 @@ 
 private:
 
     void update(FbTk::Subject *subj);
-    
+
     typedef std::list<TrayWindow *> ClientList;
     ClientList::iterator findClient(Window win);
 

@@ -48,8 +48,8 @@ 
     ToolbarItem *create(const std::string &name, const FbTk::FbWindow &parent, Toolbar &tbar);
     void updateThemes();
     int maxFontHeight();
-    inline const BScreen &screen() const { return m_screen; }
-    inline BScreen &screen() { return m_screen; }
+    const BScreen &screen() const { return m_screen; }
+    BScreen &screen() { return m_screen; }
 
 private:
     BScreen &m_screen;

@@ -45,8 +45,8 @@ void reconfigTheme();
     // textures
     const FbTk::Texture &texture() const { return *m_texture; }
     const FbTk::BorderTheme &border() const { return m_border; }
-    inline unsigned char alpha() const { return m_alpha; }
-    inline void setAlpha(unsigned char alpha) { m_alpha = alpha; }
+    unsigned char alpha() const { return m_alpha; }
+    void setAlpha(unsigned char alpha) { m_alpha = alpha; }
 
 protected:
     FbTk::ThemeItem<FbTk::Texture> &textureTheme() { return m_texture; }

@@ -24,8 +24,8 @@ // DEALINGS IN THE SOFTWARE.
 
 // $Id$
 
-#ifndef	 TOOLBAR_HH
-#define	 TOOLBAR_HH
+#ifndef TOOLBAR_HH
+#define TOOLBAR_HH
 
 #include "ToolbarTheme.hh"
 #include "LayerMenu.hh"
@@ -53,19 +53,19 @@ class ImageControl;
 class Shape;
 }
 
-///	The toolbar.
+/// The toolbar.
 /// Handles iconbar, workspace name view and clock view
 class Toolbar: public FbTk::EventHandler, public FbTk::Observer, public LayerObject {
 public:
-       
+
     /// Toolbar placement on the screen
-    enum Placement{ 
+    enum Placement{
         // top and bottom placement
         TOPLEFT = 1, BOTTOMLEFT, TOPCENTER,
         BOTTOMCENTER, TOPRIGHT, BOTTOMRIGHT,
         // left and right placement
         LEFTCENTER, LEFTBOTTOM, LEFTTOP,
-        RIGHTCENTER, RIGHTBOTTOM, RIGHTTOP        
+        RIGHTCENTER, RIGHTBOTTOM, RIGHTTOP
     };
 
     /// Create a toolbar on the screen with specific width
@@ -93,7 +93,7 @@ void leaveNotifyEvent(XCrossingEvent &ce);
     void exposeEvent(XExposeEvent &ee);
     void handleEvent(XEvent &event);
     //@}
-	
+
     void reconfigure();
     void setPlacement(Placement where);
 
@@ -101,35 +101,35 @@ void update(FbTk::Subject *subj);
 
     int layerNumber() const { return const_cast<FbTk::XLayerItem &>(m_layeritem).getLayerNum(); }
 
-    inline const FbTk::Menu &menu() const { return m_toolbarmenu; }
-    inline FbTk::Menu &menu() { return m_toolbarmenu; }
-    inline FbTk::Menu &placementMenu() { return m_placementmenu; }
-    inline const FbTk::Menu &placementMenu() const { return m_placementmenu; }
+    const FbTk::Menu &menu() const { return m_toolbarmenu; }
+    FbTk::Menu &menu() { return m_toolbarmenu; }
+    FbTk::Menu &placementMenu() { return m_placementmenu; }
+    const FbTk::Menu &placementMenu() const { return m_placementmenu; }
 
-    inline FbTk::Menu &layerMenu() { return m_layermenu; }
-    inline const FbTk::Menu &layerMenu() const { return m_layermenu; }
+    FbTk::Menu &layerMenu() { return m_layermenu; }
+    const FbTk::Menu &layerMenu() const { return m_layermenu; }
 
     /// are we hidden?
-    inline bool isHidden() const { return m_hidden; }
+    bool isHidden() const { return m_hidden; }
     /// do we auto hide the toolbar?
-    inline bool doAutoHide() const { return *m_rc_auto_hide; }
+    bool doAutoHide() const { return *m_rc_auto_hide; }
     ///	@return X window of the toolbar
-    inline const FbTk::FbWindow &window() const { return frame.window; }
-    inline BScreen &screen() { return m_screen; }
-    inline const BScreen &screen() const { return m_screen; }
-    inline unsigned int width() const { return frame.window.width(); }
-    inline unsigned int height() const { return frame.window.height(); }
-    inline int x() const { return isHidden() ? frame.x_hidden : frame.x; }
-    inline int y() const { return isHidden() ? frame.y_hidden : frame.y; }
-    inline Placement placement() const { return *m_rc_placement; }
+    const FbTk::FbWindow &window() const { return frame.window; }
+    BScreen &screen() { return m_screen; }
+    const BScreen &screen() const { return m_screen; }
+    unsigned int width() const { return frame.window.width(); }
+    unsigned int height() const { return frame.window.height(); }
+    int x() const { return isHidden() ? frame.x_hidden : frame.x; }
+    int y() const { return isHidden() ? frame.y_hidden : frame.y; }
+    Placement placement() const { return *m_rc_placement; }
     /// @return pointer to iconbar if it got one, else 0
-    inline const ToolbarTheme &theme() const { return m_theme; }
-    inline ToolbarTheme &theme() { return m_theme; }
+    const ToolbarTheme &theme() const { return m_theme; }
+    ToolbarTheme &theme() { return m_theme; }
     bool isVertical() const;
 
-    inline int getOnHead() const { return *m_rc_on_head; }
+    int getOnHead() const { return *m_rc_on_head; }
 
-    inline unsigned char alpha() const { return *m_rc_alpha; }
+    unsigned char alpha() const { return *m_rc_alpha; }
 private:
     void rearrangeItems();
     void deleteItems();
@@ -165,7 +165,7 @@ 
 
     // themes
     ToolbarTheme m_theme;
-    
+
 
     typedef std::list<ToolbarItem *> ItemList;
     ItemList m_item_list;

@@ -36,17 +36,16 @@ explicit ToolbarTheme(int screen_num);
     virtual ~ToolbarTheme();
 
     void reconfigTheme();
-    
 
-    inline const FbTk::BorderTheme &border() const { return m_border; }
-    inline const FbTk::Texture &toolbar() const { return *m_toolbar; }
+    const FbTk::BorderTheme &border() const { return m_border; }
+    const FbTk::Texture &toolbar() const { return *m_toolbar; }
 
     bool fallback(FbTk::ThemeItem_base &item);
 
-    inline int bevelWidth() const { return *m_bevel_width; }    
-    inline bool shape() const { return *m_shape; }
-    inline int height() const { return *m_height; }
-    inline int buttonSize() const { return *m_button_size; }
+    int bevelWidth() const { return *m_bevel_width; }    
+    bool shape() const { return *m_shape; }
+    int height() const { return *m_height; }
+    int buttonSize() const { return *m_button_size; }
 private:
     FbTk::ThemeItem<FbTk::Texture> m_toolbar;
     FbTk::BorderTheme m_border;

@@ -56,7 +56,7 @@ // i.e. whether we assume the focus will get taken
     bool acceptsFocus() const; // will this window accept focus (according to hints)
     void sendClose(bool forceful = false);
     // not aware of anything that makes this false at present
-    inline bool isClosable() const { return true; }
+    bool isClosable() const { return true; }
 
     /// updates from wm class hints
     void updateWMClassHint();
@@ -111,26 +111,26 @@ std::string getWMRole() const;
     Focusable::WindowType getWindowType() const { return m_window_type; }
     void setWindowType(Focusable::WindowType type) { m_window_type = type; }
 
-    inline WinClient *transientFor() { return transient_for; }
-    inline const WinClient *transientFor() const { return transient_for; }
-    inline TransientList &transientList() { return transients; }
-    inline const TransientList &transientList() const { return transients; }
-    inline bool isTransient() const { return transient_for != 0; }
+    WinClient *transientFor() { return transient_for; }
+    const WinClient *transientFor() const { return transient_for; }
+    TransientList &transientList() { return transients; }
+    const TransientList &transientList() const { return transients; }
+    bool isTransient() const { return transient_for != 0; }
 
-    inline bool isModal() const { return m_modal_count > 0; }
-    inline bool isStateModal() const { return m_modal; }
+    bool isModal() const { return m_modal_count > 0; }
+    bool isStateModal() const { return m_modal; }
     void setStateModal(bool state);
 
-    inline int gravity() const { return m_win_gravity; }
+    int gravity() const { return m_win_gravity; }
 
     bool hasGroupLeftWindow() const;
     // grouping is tracked by remembering the window to the left in the group
     Window getGroupLeftWindow() const;
 
-    inline const MwmHints *getMwmHint() const { return m_mwm_hint; }
+    const MwmHints *getMwmHint() const { return m_mwm_hint; }
 
-    inline unsigned int maxWidth() const { return max_width; }
-    inline unsigned int maxHeight() const { return max_height; }
+    unsigned int maxWidth() const { return max_width; }
+    unsigned int maxHeight() const { return max_height; }
 
     static const int PropMwmHintsElements = 3;
 

@@ -24,8 +24,8 @@ // DEALINGS IN THE SOFTWARE.
 
 // $Id$
 
-#ifndef	 WINDOW_HH
-#define	 WINDOW_HH
+#ifndef WINDOW_HH
+#define WINDOW_HH
 
 #include "FbTk/DefaultValue.hh"
 #include "FbTk/Timer.hh"
@@ -67,7 +67,7 @@ public:
     /// Motif wm Hints
     enum {
         MwmHintsFunctions   = (1l << 0), ///< use motif wm functions
-        MwmHintsDecorations	= (1l << 1) ///< use motif wm decorations
+        MwmHintsDecorations = (1l << 1) ///< use motif wm decorations
     };
 
     /// Motif wm functions
@@ -99,7 +99,7 @@ ATTRIB_MAXVERT = 0x04,     ///< maximized vertical
         ATTRIB_OMNIPRESENT = 0x08, ///< omnipresent (sticky)
         ATTRIB_WORKSPACE = 0x10,   ///< workspace
         ATTRIB_STACK = 0x20,       ///< stack
-        ATTRIB_DECORATION = 0x40,  ///< decorations 
+        ATTRIB_DECORATION = 0x40,  ///< decorations
         ATTRIB_HIDDEN = 0x80,      ///< hidden
     };
 
@@ -114,7 +114,7 @@ MAX_FULL = 3  ///< maximize full
     };
 
     /// Different resize modes when resizing a window
-    enum ResizeModel { 
+    enum ResizeModel {
         QUADRANTRESIZE,                   ///< resizes from one quadrant
         CENTERRESIZE,                     ///< resizes from center
         NEARESTEDGERESIZE,                ///< resizes the nearest edge
@@ -133,13 +133,13 @@ /**
      * Resize direction while resizing
      */
      enum ResizeDirection {
-         NOCORNER = -1, 
+         NOCORNER = -1,
          LEFTTOP  = 0,
          TOP      = 1,
          RIGHTTOP = 2,
          RIGHT    = 3,
          RIGHTBOTTOM  = 4,
-         BOTTOM       = 5,        
+         BOTTOM       = 5,
          LEFTBOTTOM   = 6,
          LEFT         = 7,
          ALLCORNERS   = 8
@@ -172,7 +172,7 @@ bool removeClient(WinClient &client);
     /// set new current client and raise it
     bool setCurrentClient(WinClient &client, bool setinput = true);
     /**
-     * Searches for a client 
+     * Searches for a client
      * @param win the client X window
      * @return pointer to client matching the window or NULL
      */
@@ -316,7 +316,7 @@ /// move to pos x,y and resize client window to size width, height
     void moveResizeForClient(int x, int y, unsigned int width, unsigned int height, int gravity = ForgetGravity, unsigned int client_bw = 0);
     /**
      * Determines maximum size using all clients that this window can have.
-     * @param width will be filled in with maximum width 
+     * @param width will be filled in with maximum width
      * @param height will be filled in with maximum height
      */
     void maxSize(unsigned int &width, unsigned int &height);
@@ -391,55 +391,55 @@ /**
        @name accessors
     */
     //@{
-    
+
     // whether this window can be tabbed with other windows,
     // and others tabbed with it
-    inline void setTabable(bool tabable) { functions.tabable = tabable; }
-    inline bool isTabable() { return functions.tabable; }
-    inline void setMovable(bool movable) { functions.move = movable; }
-    inline void setResizable(bool resizable) { functions.resize = resizable; }
+    void setTabable(bool tabable) { functions.tabable = tabable; }
+    bool isTabable() { return functions.tabable; }
+    void setMovable(bool movable) { functions.move = movable; }
+    void setResizable(bool resizable) { functions.resize = resizable; }
 
-    inline bool isFocusHidden() const { return m_focus_hidden; }
-    inline bool isIconHidden() const { return m_icon_hidden; }
-    inline bool isManaged() const { return m_initialized; }
+    bool isFocusHidden() const { return m_focus_hidden; }
+    bool isIconHidden() const { return m_icon_hidden; }
+    bool isManaged() const { return m_initialized; }
     bool isVisible() const;
-    inline bool isIconic() { return iconic; }
-    inline bool isIconic() const { return iconic; }
-    inline bool isShaded() { return shaded; }
-    inline bool isShaded() const { return shaded; }
-    inline bool isFullscreen() const { return fullscreen; }
-    inline bool isMaximized() const { return maximized == MAX_FULL; }
-    inline bool isMaximizedVert() const { return (bool)(maximized & MAX_VERT); }
-    inline bool isMaximizedHorz() const { return (bool)(maximized & MAX_HORZ); }
-    inline int maximizedState() const { return maximized; }
-    inline bool isIconifiable() const { return functions.iconify; }
-    inline bool isMaximizable() const { return functions.maximize; }
-    inline bool isResizable() const { return functions.resize; }
-    inline bool isClosable() const { return functions.close; }
-    inline bool isMoveable() const { return functions.move; }
-    inline bool isStuck() const { return stuck; }
-    inline bool hasTitlebar() const { return decorations.titlebar; }
-    inline bool isMoving() const { return moving; }
-    inline bool isResizing() const { return resizing; }
+    bool isIconic() { return iconic; }
+    bool isIconic() const { return iconic; }
+    bool isShaded() { return shaded; }
+    bool isShaded() const { return shaded; }
+    bool isFullscreen() const { return fullscreen; }
+    bool isMaximized() const { return maximized == MAX_FULL; }
+    bool isMaximizedVert() const { return (bool)(maximized & MAX_VERT); }
+    bool isMaximizedHorz() const { return (bool)(maximized & MAX_HORZ); }
+    int maximizedState() const { return maximized; }
+    bool isIconifiable() const { return functions.iconify; }
+    bool isMaximizable() const { return functions.maximize; }
+    bool isResizable() const { return functions.resize; }
+    bool isClosable() const { return functions.close; }
+    bool isMoveable() const { return functions.move; }
+    bool isStuck() const { return stuck; }
+    bool hasTitlebar() const { return decorations.titlebar; }
+    bool isMoving() const { return moving; }
+    bool isResizing() const { return resizing; }
     bool isGroupable() const;
-    inline int numClients() const { return m_clientlist.size(); }
-    inline bool empty() const { return m_clientlist.empty(); }
-    inline ClientList &clientList() { return m_clientlist; }
-    inline const ClientList &clientList() const { return m_clientlist; }
-    inline WinClient &winClient() { return *m_client; }
-    inline const WinClient &winClient() const { return *m_client; }
+    int numClients() const { return m_clientlist.size(); }
+    bool empty() const { return m_clientlist.empty(); }
+    ClientList &clientList() { return m_clientlist; }
+    const ClientList &clientList() const { return m_clientlist; }
+    WinClient &winClient() { return *m_client; }
+    const WinClient &winClient() const { return *m_client; }
 
     bool isTyping();
 
-    inline const FbTk::XLayerItem &layerItem() const { return m_frame.layerItem(); }
-    inline FbTk::XLayerItem &layerItem() { return m_frame.layerItem(); }
+    const FbTk::XLayerItem &layerItem() const { return m_frame.layerItem(); }
+    FbTk::XLayerItem &layerItem() { return m_frame.layerItem(); }
 
     Window clientWindow() const;
 
     FbTk::FbWindow &fbWindow();
     const FbTk::FbWindow &fbWindow() const;
 
-    FbTk::Menu &menu(); 
+    FbTk::Menu &menu();
     const FbTk::Menu &menu() const;
 
     const FbTk::FbWindow &parent() const { return m_parent; }
@@ -448,27 +448,27 @@ 
     bool acceptsFocus() const;
     const FbTk::PixmapWithMask &icon() const;
     const std::string &title() const;
-    const std::string &getWMClassName() const; 
+    const std::string &getWMClassName() const;
     const std::string &getWMClassClass() const;
     std::string getWMRole() const;
     Focusable::WindowType getWindowType() const;
     void setWindowType(Focusable::WindowType type);
     bool isTransient() const;
 
-    inline int x() const { return frame().x(); }
-    inline int y() const { return frame().y(); }
-    inline unsigned int width() const { return frame().width(); }
-    inline unsigned int height() const { return frame().height(); }
+    int x() const { return frame().x(); }
+    int y() const { return frame().y(); }
+    unsigned int width() const { return frame().width(); }
+    unsigned int height() const { return frame().height(); }
 
     int normalX() const;
     int normalY() const;
     unsigned int normalWidth() const;
     unsigned int normalHeight() const;
 
-    inline int xOffset() const { return frame().xOffset(); }
-    inline int yOffset() const { return frame().yOffset(); }
-    inline int widthOffset() const { return frame().widthOffset(); }
-    inline int heightOffset() const { return frame().heightOffset(); }
+    int xOffset() const { return frame().xOffset(); }
+    int yOffset() const { return frame().yOffset(); }
+    int widthOffset() const { return frame().widthOffset(); }
+    int heightOffset() const { return frame().heightOffset(); }
 
     unsigned int workspaceNumber() const { return m_workspace_number; }
 
@@ -481,8 +481,8 @@ unsigned int titlebarHeight() const;
 
     int initialState() const;
 
-    inline FbWinFrame &frame() { return m_frame; }
-    inline const FbWinFrame &frame() const { return m_frame; }
+    FbWinFrame &frame() { return m_frame; }
+    const FbWinFrame &frame() const { return m_frame; }
 
     /**
        @name signals
@@ -556,9 +556,9 @@ 
     void associateClient(WinClient &client);
 
     // state and hint signals
-    WinSubject m_hintsig, 
-        m_statesig, 
-        m_layersig, 
+    WinSubject m_hintsig,
+        m_statesig,
+        m_layersig,
         m_workspacesig;
 
     class ThemeListener: public FbTk::Observer {

@@ -74,11 +74,11 @@ typedef void (FluxboxWindow:: *Setter)(Ret);
     WindowAccessor(Getter g, Setter s, Def def):
             m_getter(g), m_setter(s), m_def(def) { }
 
-    inline operator Ret() const {
+    operator Ret() const {
         FluxboxWindow *fbwin = WindowCmd<void>::window();
         return fbwin ? (fbwin->*m_getter)() : m_def;
     }
-    inline FbTk::Accessor<Ret> &operator =(const Ret &val) {
+    FbTk::Accessor<Ret> &operator =(const Ret &val) {
         FluxboxWindow *fbwin = WindowCmd<void>::window();
         if (fbwin)
             (fbwin->*m_setter)(val);
@@ -99,11 +99,11 @@ typedef Ret (FluxboxWindow:: *Getter)() const;
     ConstWindowAccessor(Getter g, Def def):
             m_getter(g), m_def(def) { }
 
-    inline operator Ret() const {
+    operator Ret() const {
         FluxboxWindow *fbwin = WindowCmd<void>::window();
         return fbwin ? (fbwin->*m_getter)() : m_def;
     }
-    inline FbTk::Accessor<Ret> &operator =(const Ret &val) { return *this; }
+    FbTk::Accessor<Ret> &operator =(const Ret &val) { return *this; }
 
 private:
     Getter m_getter;