@@ -795,13 +795,14 @@ }
 
 void action_send_to_desktop(union ActionData *data)
 {
-    if (data->sendto.c) {
-        if (data->sendto.desk < screen_num_desktops ||
-            data->sendto.desk == DESKTOP_ALL) {
-            client_set_desktop(data->desktop.c,
-                               data->sendto.desk, data->sendto.follow);
-            if (data->sendto.follow) screen_set_desktop(data->sendto.desk);
-        }
+    ObClient *c = data->sendto.c;
+
+    if (!c || !client_normal(c)) return;
+
+    if (data->sendto.desk < screen_num_desktops ||
+        data->sendto.desk == DESKTOP_ALL) {
+        client_set_desktop(c, data->sendto.desk, data->sendto.follow);
+        if (data->sendto.follow) screen_set_desktop(data->sendto.desk);
     }
 }
 
@@ -942,25 +943,26 @@ }
 
 void action_send_to_desktop_right(union ActionData *data)
 {
+    ObClient *cl = data->sendto.c;
     guint r, c, d;
 
-    if (data->sendtodir.c) {
-        cur_row_col(&r, &c);
+    if (!cl || !client_normal(cl)) return;
+
+    cur_row_col(&r, &c);
+    ++c;
+    if (c >= screen_desktop_layout.columns) {
+        if (!data->sendtodir.wrap) return;
+        c = 0;
+    }
+    d = translate_row_col(r, c);
+    if (d >= screen_num_desktops) {
+        if (!data->sendtodir.wrap) return;
         ++c;
-        if (c >= screen_desktop_layout.columns) {
-            if (!data->sendtodir.wrap) return;
-            c = 0;
-        }
-        d = translate_row_col(r, c);
-        if (d >= screen_num_desktops) {
-            if (!data->sendtodir.wrap) return;
-            ++c;
-        }
-        d = translate_row_col(r, c);
-        if (d < screen_num_desktops) {
-            client_set_desktop(data->sendtodir.c, d, data->sendtodir.follow);
-            if (data->sendtodir.follow) screen_set_desktop(d);
-        }
+    }
+    d = translate_row_col(r, c);
+    if (d < screen_num_desktops) {
+        client_set_desktop(cl, d, data->sendtodir.follow);
+        if (data->sendtodir.follow) screen_set_desktop(d);
     }
 }
 
@@ -986,25 +988,26 @@ }
 
 void action_send_to_desktop_left(union ActionData *data)
 {
+    ObClient *cl = data->sendto.c;
     guint r, c, d;
 
-    if (data->sendtodir.c) {
-        cur_row_col(&r, &c);
+    if (!cl || !client_normal(cl)) return;
+
+    cur_row_col(&r, &c);
+    --c;
+    if (c >= screen_desktop_layout.columns) {
+        if (!data->sendtodir.wrap) return;
+        c = screen_desktop_layout.columns - 1;
+    }
+    d = translate_row_col(r, c);
+    if (d >= screen_num_desktops) {
+        if (!data->sendtodir.wrap) return;
         --c;
-        if (c >= screen_desktop_layout.columns) {
-            if (!data->sendtodir.wrap) return;
-            c = screen_desktop_layout.columns - 1;
-        }
-        d = translate_row_col(r, c);
-        if (d >= screen_num_desktops) {
-            if (!data->sendtodir.wrap) return;
-            --c;
-        }
-        d = translate_row_col(r, c);
-        if (d < screen_num_desktops) {
-            client_set_desktop(data->sendtodir.c, d, data->sendtodir.follow);
-            if (data->sendtodir.follow) screen_set_desktop(d);
-        }
+    }
+    d = translate_row_col(r, c);
+    if (d < screen_num_desktops) {
+        client_set_desktop(cl, d, data->sendtodir.follow);
+        if (data->sendtodir.follow) screen_set_desktop(d);
     }
 }
 

@@ -255,7 +255,7 @@ focus_order_add_new(self);
 
     /* focus the new window? */
     if (ob_state != OB_STATE_STARTING && config_focus_new &&
-        (self->type == Type_Normal || self->type == Type_Dialog)) {
+        (self->type == OB_CLIENT_TYPE_NORMAL || self->type == OB_CLIENT_TYPE_DIALOG)) {
         gboolean group_foc = FALSE;
         
         if (self->group) {
@@ -322,7 +322,7 @@ }
 
 void client_unmanage(ObClient *self)
 {
-    int j;
+    guint j;
     GSList *it;
 
     g_message("Unmanaging window: %lx (%s)", self->window, self->class);
@@ -784,21 +784,21 @@ if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
 	/* use the first value that we know about in the array */
 	for (i = 0; i < num; ++i) {
 	    if (val[i] == prop_atoms.net_wm_window_type_desktop)
-		self->type = Type_Desktop;
+		self->type = OB_CLIENT_TYPE_DESKTOP;
 	    else if (val[i] == prop_atoms.net_wm_window_type_dock)
-		self->type = Type_Dock;
+		self->type = OB_CLIENT_TYPE_DOCK;
 	    else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
-		self->type = Type_Toolbar;
+		self->type = OB_CLIENT_TYPE_TOOLBAR;
 	    else if (val[i] == prop_atoms.net_wm_window_type_menu)
-		self->type = Type_Menu;
+		self->type = OB_CLIENT_TYPE_MENU;
 	    else if (val[i] == prop_atoms.net_wm_window_type_utility)
-		self->type = Type_Utility;
+		self->type = OB_CLIENT_TYPE_UTILITY;
 	    else if (val[i] == prop_atoms.net_wm_window_type_splash)
-		self->type = Type_Splash;
+		self->type = OB_CLIENT_TYPE_SPLASH;
 	    else if (val[i] == prop_atoms.net_wm_window_type_dialog)
-		self->type = Type_Dialog;
+		self->type = OB_CLIENT_TYPE_DIALOG;
 	    else if (val[i] == prop_atoms.net_wm_window_type_normal)
-		self->type = Type_Normal;
+		self->type = OB_CLIENT_TYPE_NORMAL;
 	    else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
 		/* prevent this window from getting any decor or
 		   functionality */
@@ -807,20 +807,20 @@ OB_MWM_FLAG_DECORATIONS);
 		self->mwmhints.decorations = 0;
 		self->mwmhints.functions = 0;
 	    }
-	    if (self->type != (WindowType) -1)
+	    if (self->type != (ObClientType) -1)
 		break; /* grab the first legit type */
 	}
 	g_free(val);
     }
     
-    if (self->type == (WindowType) -1) {
+    if (self->type == (ObClientType) -1) {
 	/*the window type hint was not set, which means we either classify
 	  ourself as a normal window or a dialog, depending on if we are a
 	  transient. */
 	if (self->transient)
-	    self->type = Type_Dialog;
+	    self->type = OB_CLIENT_TYPE_DIALOG;
 	else
-	    self->type = Type_Normal;
+	    self->type = OB_CLIENT_TYPE_NORMAL;
     }
 }
 
@@ -915,43 +915,44 @@ /* start with everything (cept fullscreen) */
     self->decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
 	Decor_Icon | Decor_AllDesktops | Decor_Iconify | Decor_Maximize |
         Decor_Shade;
-    self->functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize |
-	Func_Shade;
+    self->functions = OB_CLIENT_FUNC_RESIZE | OB_CLIENT_FUNC_MOVE |
+        OB_CLIENT_FUNC_ICONIFY | OB_CLIENT_FUNC_MAXIMIZE |
+        OB_CLIENT_FUNC_SHADE;
     if (self->delete_window) {
 	self->decorations |= Decor_Close;
-	self->functions |= Func_Close;
+	self->functions |= OB_CLIENT_FUNC_CLOSE;
     }
 
     if (!(self->min_size.width < self->max_size.width ||
 	  self->min_size.height < self->max_size.height)) {
 	self->decorations &= ~(Decor_Maximize | Decor_Handle);
-	self->functions &= ~(Func_Resize | Func_Maximize);
+	self->functions &= ~OB_CLIENT_FUNC_RESIZE;
     }
 
     switch (self->type) {
-    case Type_Normal:
+    case OB_CLIENT_TYPE_NORMAL:
 	/* normal windows retain all of the possible decorations and
 	   functionality, and are the only windows that you can fullscreen */
-	self->functions |= Func_Fullscreen;
+	self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
 	break;
 
-    case Type_Dialog:
-    case Type_Utility:
+    case OB_CLIENT_TYPE_DIALOG:
+    case OB_CLIENT_TYPE_UTILITY:
 	/* these windows cannot be maximized */
 	self->decorations &= ~Decor_Maximize;
-	self->functions &= ~Func_Maximize;
+	self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
 	break;
 
-    case Type_Menu:
-    case Type_Toolbar:
+    case OB_CLIENT_TYPE_MENU:
+    case OB_CLIENT_TYPE_TOOLBAR:
 	/* these windows get less functionality */
 	self->decorations &= ~(Decor_Iconify | Decor_Handle);
-	self->functions &= ~(Func_Iconify | Func_Resize);
+	self->functions &= ~(OB_CLIENT_FUNC_ICONIFY | OB_CLIENT_FUNC_RESIZE);
 	break;
 
-    case Type_Desktop:
-    case Type_Dock:
-    case Type_Splash:
+    case OB_CLIENT_TYPE_DESKTOP:
+    case OB_CLIENT_TYPE_DOCK:
+    case OB_CLIENT_TYPE_SPLASH:
 	/* none of these windows are manipulated by the window manager */
 	self->decorations = 0;
 	self->functions = 0;
@@ -978,13 +979,13 @@ 
     if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
 	if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
 	    if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
-		self->functions &= ~Func_Resize;
+		self->functions &= ~OB_CLIENT_FUNC_RESIZE;
 	    if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
-		self->functions &= ~Func_Move;
+		self->functions &= ~OB_CLIENT_FUNC_MOVE;
 	    if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
-		self->functions &= ~Func_Iconify;
+		self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
 	    if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
-		self->functions &= ~Func_Maximize;
+		self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
 	    /* dont let mwm hints kill the close button
 	       if (! (self->mwmhints.functions & MwmFunc_Close))
 	       self->functions &= ~Func_Close; */
@@ -992,8 +993,10 @@ }
     }
 
     /* can't maximize without moving/resizing */
-    if (!((self->functions & Func_Move) && (self->functions & Func_Resize)))
-	self->functions &= ~(Func_Maximize | Func_Fullscreen);
+    if (!((self->functions & OB_CLIENT_FUNC_MOVE) &&
+          (self->functions & OB_CLIENT_FUNC_RESIZE)))
+	self->functions &= ~(OB_CLIENT_FUNC_MAXIMIZE |
+                             OB_CLIENT_FUNC_FULLSCREEN);
 
     /* finally, user specified disabled decorations are applied to subtract
        decorations */
@@ -1016,11 +1019,13 @@ self->decorations &= ~Decor_Close;
 
     /* if we don't have a titlebar, then we cannot shade! */
     if (!(self->decorations & Decor_Titlebar))
-	self->functions &= ~Func_Shade;
+	self->functions &= ~OB_CLIENT_FUNC_SHADE;
 
     /* now we need to check against rules for the client's current state */
     if (self->fullscreen) {
-	self->functions &= (Func_Close | Func_Fullscreen | Func_Iconify);
+	self->functions &= (OB_CLIENT_FUNC_CLOSE |
+                            OB_CLIENT_FUNC_FULLSCREEN |
+                            OB_CLIENT_FUNC_ICONIFY);
 	self->decorations = 0;
     }
 
@@ -1028,15 +1033,19 @@ client_change_allowed_actions(self);
 
     if (self->frame) {
         /* this makes sure that these windows appear on all desktops */
-        if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
+        if (self->type == OB_CLIENT_TYPE_DESKTOP &&
+            self->desktop != DESKTOP_ALL)
             client_set_desktop(self, DESKTOP_ALL, FALSE);
 
 	/* adjust the client's decorations, etc. */
 	client_reconfigure(self);
     } else {
         /* this makes sure that these windows appear on all desktops */
-        if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
+        if (self->type == OB_CLIENT_TYPE_DESKTOP &&
+            self->desktop != DESKTOP_ALL)
+        {
             self->desktop = DESKTOP_ALL;
+        }
     }
 }
 
@@ -1046,22 +1055,22 @@ guint32 actions[9];
     int num = 0;
 
     /* desktop windows are kept on all desktops */
-    if (self->type != Type_Desktop)
+    if (self->type != OB_CLIENT_TYPE_DESKTOP)
         actions[num++] = prop_atoms.net_wm_action_change_desktop;
 
-    if (self->functions & Func_Shade)
+    if (self->functions & OB_CLIENT_FUNC_SHADE)
 	actions[num++] = prop_atoms.net_wm_action_shade;
-    if (self->functions & Func_Close)
+    if (self->functions & OB_CLIENT_FUNC_CLOSE)
 	actions[num++] = prop_atoms.net_wm_action_close;
-    if (self->functions & Func_Move)
+    if (self->functions & OB_CLIENT_FUNC_MOVE)
 	actions[num++] = prop_atoms.net_wm_action_move;
-    if (self->functions & Func_Iconify)
+    if (self->functions & OB_CLIENT_FUNC_ICONIFY)
 	actions[num++] = prop_atoms.net_wm_action_minimize;
-    if (self->functions & Func_Resize)
+    if (self->functions & OB_CLIENT_FUNC_RESIZE)
 	actions[num++] = prop_atoms.net_wm_action_resize;
-    if (self->functions & Func_Fullscreen)
+    if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
 	actions[num++] = prop_atoms.net_wm_action_fullscreen;
-    if (self->functions & Func_Maximize) {
+    if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
 	actions[num++] = prop_atoms.net_wm_action_maximize_horz;
 	actions[num++] = prop_atoms.net_wm_action_maximize_vert;
     }
@@ -1070,21 +1079,21 @@ PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num);
 
     /* make sure the window isn't breaking any rules now */
 
-    if (!(self->functions & Func_Shade) && self->shaded) {
+    if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
 	if (self->frame) client_shade(self, FALSE);
 	else self->shaded = FALSE;
     }
-    if (!(self->functions & Func_Iconify) && self->iconic) {
+    if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) {
         g_message("UNSETTING ICONIC");
 	if (self->frame) client_iconify(self, FALSE, TRUE);
 	else self->iconic = FALSE;
     }
-    if (!(self->functions & Func_Fullscreen) && self->fullscreen) {
+    if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) {
 	if (self->frame) client_fullscreen(self, FALSE, TRUE);
 	else self->fullscreen = FALSE;
     }
-    if (!(self->functions & Func_Maximize) && (self->max_horz ||
-					       self->max_vert)) {
+    if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && (self->max_horz ||
+                                                         self->max_vert)) {
 	if (self->frame) client_maximize(self, FALSE, 0, TRUE);
 	else self->max_vert = self->max_horz = FALSE;
     }
@@ -1305,11 +1314,10 @@ void client_update_icons(ObClient *self)
 {
     guint num;
     guint32 *data;
-    guint w, h, i;
-    int j;
+    guint w, h, i, j;
 
-    for (j = 0; j < self->nicons; ++j)
-	g_free(self->icons[j].data);
+    for (i = 0; i < self->nicons; ++i)
+	g_free(self->icons[i].data);
     if (self->nicons > 0)
 	g_free(self->icons);
     self->nicons = 0;
@@ -1482,8 +1490,8 @@ {
     StackLayer l;
 
     if (self->fullscreen) l = Layer_Fullscreen;
-    else if (self->type == Type_Desktop) l = Layer_Desktop;
-    else if (self->type == Type_Dock) {
+    else if (self->type == OB_CLIENT_TYPE_DESKTOP) l = Layer_Desktop;
+    else if (self->type == OB_CLIENT_TYPE_DOCK) {
         if (!self->below) l = Layer_Top;
         else l = Layer_Normal;
     }
@@ -1551,8 +1559,9 @@ frame_hide(self->frame);
 }
 
 gboolean client_normal(ObClient *self) {
-    return ! (self->type == Type_Desktop || self->type == Type_Dock ||
-	      self->type == Type_Splash);
+    return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
+              self->type == OB_CLIENT_TYPE_DOCK ||
+	      self->type == OB_CLIENT_TYPE_SPLASH);
 }
 
 static void client_apply_startup_state(ObClient *self)
@@ -1659,11 +1668,11 @@ frame_frame_gravity(self->frame, &x, &y);
 
     /* these override the above states! if you cant move you can't move! */
     if (user) {
-        if (!(self->functions & Func_Move)) {
+        if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
             x = self->area.x;
             y = self->area.y;
         }
-        if (!(self->functions & Func_Resize)) {
+        if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
             w = self->area.width;
             h = self->area.height;
         }
@@ -1818,8 +1827,8 @@ void client_fullscreen(ObClient *self, gboolean fs, gboolean savearea)
 {
     int x, y, w, h;
 
-    if (!(self->functions & Func_Fullscreen) || /* can't */
-	self->fullscreen == fs) return;         /* already done */
+    if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
+	self->fullscreen == fs) return;                   /* already done */
 
     self->fullscreen = fs;
     client_change_state(self); /* change the state hints on the client,
@@ -1886,7 +1895,7 @@ 
         self->iconic = iconic;
 
         if (iconic) {
-            if (self->functions & Func_Iconify) {
+            if (self->functions & OB_CLIENT_FUNC_ICONIFY) {
                 self->wmstate = IconicState;
                 self->ignore_unmaps++;
                 /* we unmap the client itself so that we can get MapRequest
@@ -1949,7 +1958,7 @@ {
     int x, y, w, h;
      
     g_assert(dir == 0 || dir == 1 || dir == 2);
-    if (!(self->functions & Func_Maximize)) return; /* can't */
+    if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */
 
     /* check if already done */
     if (max) {
@@ -2048,7 +2057,8 @@ }
 
 void client_shade(ObClient *self, gboolean shade)
 {
-    if ((!(self->functions & Func_Shade) && shade) || /* can't shade */
+    if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
+         shade) ||                         /* can't shade */
 	self->shaded == shade) return;     /* already done */
 
     /* when we're iconic, don't change the wmstate */
@@ -2064,7 +2074,7 @@ void client_close(ObClient *self)
 {
     XEvent ce;
 
-    if (!(self->functions & Func_Close)) return;
+    if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
 
     /*
       XXX: itd be cool to do timeouts and shit here for killing the client's
@@ -2434,7 +2444,7 @@ }
 
 ObClientIcon *client_icon(ObClient *self, int w, int h)
 {
-    int i;
+    guint i;
     /* si is the smallest image >= req */
     /* li is the largest image < req */
     unsigned long size, smallest = 0xffffffff, largest = 0, si = 0, li = 0;

@@ -29,27 +29,29 @@ RrPixel32 *data;
 };
      
 /*! Possible window types */
-typedef enum {
-    Type_Desktop, /*!< A desktop (bottom-most window) */
-    Type_Dock,    /*!< A dock bar/panel window */
-    Type_Toolbar, /*!< A toolbar window, pulled off an app */
-    Type_Menu,    /*!< An unpinned menu from an app */
-    Type_Utility, /*!< A small utility window such as a palette */
-    Type_Splash,  /*!< A splash screen window */
-    Type_Dialog,  /*!< A dialog window */
-    Type_Normal   /*!< A normal application window */
-} WindowType;
+typedef enum
+{
+    OB_CLIENT_TYPE_DESKTOP, /*!< A desktop (bottom-most window) */
+    OB_CLIENT_TYPE_DOCK,    /*!< A dock bar/panel window */
+    OB_CLIENT_TYPE_TOOLBAR, /*!< A toolbar window, pulled off an app */
+    OB_CLIENT_TYPE_MENU,    /*!< An unpinned menu from an app */
+    OB_CLIENT_TYPE_UTILITY, /*!< A small utility window such as a palette */
+    OB_CLIENT_TYPE_SPLASH,  /*!< A splash screen window */
+    OB_CLIENT_TYPE_DIALOG,  /*!< A dialog window */
+    OB_CLIENT_TYPE_NORMAL   /*!< A normal application window */
+} ObClientType;
 
 /*! The things the user can do to the client window */
-typedef enum {
-    Func_Resize     = 1 << 0, /*!< Allow resizing */
-    Func_Move       = 1 << 1, /*!< Allow moving */
-    Func_Iconify    = 1 << 2, /*!< Allow to be iconified */
-    Func_Maximize   = 1 << 3, /*!< Allow to be maximized */
-    Func_Shade      = 1 << 4, /*!< Allow to be shaded */
-    Func_Fullscreen = 1 << 5, /*!< Allow to be made fullscreen */
-    Func_Close      = 1 << 6  /*!< Allow to be closed */
-} Function;
+typedef enum
+{
+    OB_CLIENT_FUNC_RESIZE     = 1 << 0, /*!< Allow user resizing */
+    OB_CLIENT_FUNC_MOVE       = 1 << 1, /*!< Allow user moving */
+    OB_CLIENT_FUNC_ICONIFY    = 1 << 2, /*!< Allow to be iconified */
+    OB_CLIENT_FUNC_MAXIMIZE   = 1 << 3, /*!< Allow to be maximized */
+    OB_CLIENT_FUNC_SHADE      = 1 << 4, /*!< Allow to be shaded */
+    OB_CLIENT_FUNC_FULLSCREEN = 1 << 5, /*!< Allow to be made fullscreen */
+    OB_CLIENT_FUNC_CLOSE      = 1 << 6  /*!< Allow to be closed */
+} ObFunctions;
 
 /*! The decorations the client window wants to be displayed on it */
 typedef enum {
@@ -112,7 +114,7 @@ /*! The specified role of the window, used for identification */
     gchar *role;
 
     /*! The type of window (what its function is) */
-    WindowType type;
+    ObClientType type;
 
     /*! Position and size of the window
       This will not always be the actual position of the window on screen, it
@@ -227,23 +229,23 @@ /*! A bitmask of values in the Decoration enum
       The values in the variable are the decorations that the client wants to
       be displayed around it.
     */
-    int decorations;
+    guint decorations;
 
     /*! A bitmask of values in the Decoration enum.
       Specifies the decorations that should NOT be displayed on the client.
     */
-    int disabled_decorations;
+    guint disabled_decorations;
 
-    /*! A bitmask of values in the Function enum
+    /*! A bitmask of values in the ObFunctions enum
       The values in the variable specify the ways in which the user is allowed
       to modify this window.
     */
-    int functions;
+    guint functions;
 
     /*! Icons for the client as specified on the client window */
     ObClientIcon *icons;
     /*! The number of icons in icons */
-    int nicons;
+    guint nicons;
 };
 
 extern GList *client_list;

@@ -31,25 +31,25 @@ 
 typedef struct Frame {
     ObClient *client;
 
-    Window window;
-    Window plate;
+    Window    window;
+    Window    plate;
 
-    Strut  size;
-    Rect   area;
-    gboolean visible;
-    int    decorations;
+    Strut     size;
+    Rect      area;
+    gboolean  visible;
+    guint     decorations;
 
-    Window title;
-    Window label;
-    Window max;
-    Window close;
-    Window desk;
-    Window shade;
-    Window icon;
-    Window iconify;
-    Window handle;
-    Window lgrip;
-    Window rgrip;
+    Window    title;
+    Window    label;
+    Window    max;
+    Window    close;
+    Window    desk;
+    Window    shade;
+    Window    icon;
+    Window    iconify;
+    Window    handle;
+    Window    lgrip;
+    Window    rgrip;
 
     RrAppearance *a_unfocused_title;
     RrAppearance *a_focused_title;
@@ -59,29 +59,29 @@ RrAppearance *a_icon;
     RrAppearance *a_unfocused_handle;
     RrAppearance *a_focused_handle;
 
-    Strut  innersize;
+    Strut     innersize;
 
-    GSList *clients;
+    GSList   *clients;
 
-    int width;         /* title and handle */
-    int label_width;
-    int icon_x;        /* x-position of the window icon button */
-    int label_x;       /* x-position of the window title */
-    int iconify_x;     /* x-position of the window iconify button */
-    int desk_x;        /* x-position of the window all-desktops button */
-    int shade_x;       /* x-position of the window shade button */
-    int max_x;         /* x-position of the window maximize button */
-    int close_x;       /* x-position of the window close button */
-    int bwidth;        /* border width */
-    int cbwidth;       /* client border width */
+    gint      width;         /* title and handle */
+    gint      label_width;
+    gint      icon_x;        /* x-position of the window icon button */
+    gint      label_x;       /* x-position of the window title */
+    gint      iconify_x;     /* x-position of the window iconify button */
+    gint      desk_x;        /* x-position of the window all-desktops button */
+    gint      shade_x;       /* x-position of the window shade button */
+    gint      max_x;         /* x-position of the window maximize button */
+    gint      close_x;       /* x-position of the window close button */
+    gint      bwidth;        /* border width */
+    gint      cbwidth;       /* client border width */
 
-    gboolean max_press;
-    gboolean close_press;
-    gboolean desk_press;
-    gboolean shade_press;
-    gboolean iconify_press;
+    gboolean  max_press;
+    gboolean  close_press;
+    gboolean  desk_press;
+    gboolean  shade_press;
+    gboolean  iconify_press;
 
-    gboolean focused;
+    gboolean  focused;
 } Frame;
 
 void frame_startup();

@@ -485,7 +485,7 @@ 
     if (show) {
         /* focus desktop */
         for (it = focus_order[screen_desktop]; it; it = it->next)
-            if (((ObClient*)it->data)->type == Type_Desktop &&
+            if (((ObClient*)it->data)->type == OB_CLIENT_TYPE_DESKTOP &&
                 client_focus(it->data))
                 break;
     } else {