...

src/api.h

@@ -28,10 +28,36 @@
 #include <X11/Xlib.h>
 #include <pango/pangox.h>
 
-PangoContext* meta_get_pango_context (Screen                     *xscreen,
+/* Colors/state stuff matches GTK since we get the info from
-                                      const PangoFontDescription *desc,
+ * the GTK UI slave
-                                      Window                      frame);
+ */
-gulong        meta_get_x_pixel       (Screen                     *xscreen,
+typedef struct _MetaUIColors MetaUIColors;
-                                      const PangoColor           *color);
+
+typedef enum
+{
+  META_STATE_NORMAL,
+  META_STATE_ACTIVE,
+  META_STATE_PRELIGHT,
+  META_STATE_SELECTED,
+  META_STATE_INSENSITIVE
+} MetaUIState;
+
+struct _MetaUIColors
+{
+  PangoColor fg[5];
+  PangoColor bg[5];
+  PangoColor light[5];
+  PangoColor dark[5];
+  PangoColor mid[5];
+  PangoColor text[5];
+  PangoColor base[5];
+  PangoColor text_aa[5];
+};
+
+PangoContext*       meta_get_pango_context (Screen                     *xscreen,
+                                            const PangoFontDescription *desc,
+                                            Window                      frame);
+gulong              meta_get_x_pixel       (Screen                     *xscreen,
+                                            const PangoColor           *color);
 
 #endif

src/colors.c

@@ -21,22 +21,348 @@
 
 #include "colors.h"
 
+
+static void
+visual_decompose_mask (gulong  mask,
+                       gint   *shift,
+                       gint   *prec)
+{
+  /* This code is from GTK+, (C) GTK+ Team */
+  *shift = 0;
+  *prec = 0;
+
+  while (!(mask & 0x1))
+    {
+      (*shift)++;
+      mask >>= 1;
+    }
+
+  while (mask & 0x1)
+    {
+      (*prec)++;
+      mask >>= 1;
+    }
+}
+
+void
+meta_screen_init_visual_info (MetaScreen *screen)
+{
+  Visual *xvisual;
+  int nxvisuals;
+  XVisualInfo *visual_list;
+  XVisualInfo visual_template;
+
+  /* root window visual */
+  xvisual = DefaultVisual (screen->display->xdisplay,
+                           screen->number);
+
+  visual_template.visualid = XVisualIDFromVisual (xvisual);
+  visual_list = XGetVisualInfo (screen->display->xdisplay,
+                                VisualIDMask, &visual_template, &nxvisuals);
+
+  if (nxvisuals != 1)
+    meta_warning ("Matched weird number of visuals %d\n", nxvisuals);
+
+  screen->visual_info = *visual_list;
+
+  meta_verbose ("Using visual class %d\n", screen->visual_info.class);
+  
+  XFree (visual_list);
+}
+
 gulong
 meta_screen_get_x_pixel (MetaScreen       *screen,
                          const PangoColor *color)
 {
-#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
+  /* This code is derived from GTK+, (C) GTK+ Team */
-  double r, g, b;
+  gulong pixel;
 
-  r = color->red / (double) 0xffff;
+  if (screen->visual_info.class == TrueColor ||
-  g = color->green / (double) 0xffff;
+      screen->visual_info.class == DirectColor)
-  b = color->blue / (double) 0xffff;    
+    {
+      int red_prec, red_shift, green_prec, green_shift, blue_prec, blue_shift;
 
-  /* Now this is a low-bloat GdkRGB replacement! */
+      visual_decompose_mask (screen->visual_info.red_mask,
-  if (INTENSITY (r, g, b) > 0.5)
+                             &red_shift, &red_prec);
-    return WhitePixel (screen->display->xdisplay, screen->number);
+      visual_decompose_mask (screen->visual_info.green_mask,
+                             &green_shift, &green_prec);
+      visual_decompose_mask (screen->visual_info.blue_mask,
+                             &blue_shift, &blue_prec);
+      
+      pixel = (((color->red >> (16 - red_prec)) << red_shift) +
+               ((color->green >> (16 - green_prec)) << green_shift) +
+               ((color->blue >> (16 - blue_prec)) << blue_shift));
+    }
   else
-    return BlackPixel (screen->display->xdisplay, screen->number);
+    {
-  
+#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
+      double r, g, b;
+      
+      r = color->red / (double) 0xffff;
+      g = color->green / (double) 0xffff;
+      b = color->blue / (double) 0xffff;    
+      
+      /* Now this is a low-bloat GdkRGB replacement! */
+      if (INTENSITY (r, g, b) > 0.5)
+        pixel = WhitePixel (screen->display->xdisplay, screen->number);
+      else
+        pixel = BlackPixel (screen->display->xdisplay, screen->number);  
 #undef INTENSITY
+    }
+
+  return pixel;
+}
+
+void
+meta_screen_set_ui_colors (MetaScreen         *screen,
+                           const MetaUIColors *colors)
+{
+  screen->colors = *colors;
+  meta_screen_queue_frame_redraws (screen);
+}
+
+/* Straight out of gtkstyle.c */
+static PangoColor meta_default_normal_fg =      {      0,      0,      0 };
+static PangoColor meta_default_active_fg =      {      0,      0,      0 };
+static PangoColor meta_default_prelight_fg =    {      0,      0,      0 };
+static PangoColor meta_default_selected_fg =    { 0xffff, 0xffff, 0xffff };
+static PangoColor meta_default_insensitive_fg = { 0x7530, 0x7530, 0x7530 };
+
+static PangoColor meta_default_normal_bg =      { 0xd6d6, 0xd6d6, 0xd6d6 };
+static PangoColor meta_default_active_bg =      { 0xc350, 0xc350, 0xc350 };
+static PangoColor meta_default_prelight_bg =    { 0xea60, 0xea60, 0xea60 };
+static PangoColor meta_default_selected_bg =    {     0,      0, 0x9c40 };
+static PangoColor meta_default_insensitive_bg = { 0xd6d6, 0xd6d6, 0xd6d6 };
+
+static void
+rgb_to_hls (gdouble *r,
+            gdouble *g,
+            gdouble *b)
+{
+  gdouble min;
+  gdouble max;
+  gdouble red;
+  gdouble green;
+  gdouble blue;
+  gdouble h, l, s;
+  gdouble delta;
+  
+  red = *r;
+  green = *g;
+  blue = *b;
+  
+  if (red > green)
+    {
+      if (red > blue)
+        max = red;
+      else
+        max = blue;
+      
+      if (green < blue)
+        min = green;
+      else
+        min = blue;
+    }
+  else
+    {
+      if (green > blue)
+        max = green;
+      else
+        max = blue;
+      
+      if (red < blue)
+        min = red;
+      else
+        min = blue;
+    }
+  
+  l = (max + min) / 2;
+  s = 0;
+  h = 0;
+  
+  if (max != min)
+    {
+      if (l <= 0.5)
+        s = (max - min) / (max + min);
+      else
+        s = (max - min) / (2 - max - min);
+      
+      delta = max -min;
+      if (red == max)
+        h = (green - blue) / delta;
+      else if (green == max)
+        h = 2 + (blue - red) / delta;
+      else if (blue == max)
+        h = 4 + (red - green) / delta;
+      
+      h *= 60;
+      if (h < 0.0)
+        h += 360;
+    }
+  
+  *r = h;
+  *g = l;
+  *b = s;
+}
+
+static void
+hls_to_rgb (gdouble *h,
+            gdouble *l,
+            gdouble *s)
+{
+  gdouble hue;
+  gdouble lightness;
+  gdouble saturation;
+  gdouble m1, m2;
+  gdouble r, g, b;
+  
+  lightness = *l;
+  saturation = *s;
+  
+  if (lightness <= 0.5)
+    m2 = lightness * (1 + saturation);
+  else
+    m2 = lightness + saturation - lightness * saturation;
+  m1 = 2 * lightness - m2;
+  
+  if (saturation == 0)
+    {
+      *h = lightness;
+      *l = lightness;
+      *s = lightness;
+    }
+  else
+    {
+      hue = *h + 120;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+      
+      if (hue < 60)
+        r = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        r = m2;
+      else if (hue < 240)
+        r = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        r = m1;
+      
+      hue = *h;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+      
+      if (hue < 60)
+        g = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        g = m2;
+      else if (hue < 240)
+        g = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        g = m1;
+      
+      hue = *h - 120;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+      
+      if (hue < 60)
+        b = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        b = m2;
+      else if (hue < 240)
+        b = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        b = m1;
+      
+      *h = r;
+      *l = g;
+      *s = b;
+    }
+}
+
+static void
+style_shade (PangoColor *a,
+             PangoColor *b,
+             gdouble     k)
+{
+  gdouble red;
+  gdouble green;
+  gdouble blue;
+  
+  red = (gdouble) a->red / 65535.0;
+  green = (gdouble) a->green / 65535.0;
+  blue = (gdouble) a->blue / 65535.0;
+  
+  rgb_to_hls (&red, &green, &blue);
+  
+  green *= k;
+  if (green > 1.0)
+    green = 1.0;
+  else if (green < 0.0)
+    green = 0.0;
+  
+  blue *= k;
+  if (blue > 1.0)
+    blue = 1.0;
+  else if (blue < 0.0)
+    blue = 0.0;
+  
+  hls_to_rgb (&red, &green, &blue);
+  
+  b->red = red * 65535.0;
+  b->green = green * 65535.0;
+  b->blue = blue * 65535.0;
+}
+
+#define LIGHTNESS_MULT  1.3
+#define DARKNESS_MULT   0.7
+void
+meta_screen_init_ui_colors (MetaScreen *screen)
+{
+  int i;
+  MetaUIColors *colors;
+
+  colors = &screen->colors;
+  
+  colors->fg[META_STATE_NORMAL] = meta_default_normal_fg;
+  colors->fg[META_STATE_ACTIVE] = meta_default_active_fg;
+  colors->fg[META_STATE_PRELIGHT] = meta_default_prelight_fg;
+  colors->fg[META_STATE_SELECTED] = meta_default_selected_fg;
+  colors->fg[META_STATE_INSENSITIVE] = meta_default_insensitive_fg;
+  
+  colors->bg[META_STATE_NORMAL] = meta_default_normal_bg;
+  colors->bg[META_STATE_ACTIVE] = meta_default_active_bg;
+  colors->bg[META_STATE_PRELIGHT] = meta_default_prelight_bg;
+  colors->bg[META_STATE_SELECTED] = meta_default_selected_bg;
+  colors->bg[META_STATE_INSENSITIVE] = meta_default_insensitive_bg;
+  
+  for (i = 0; i < 4; i++)
+    {
+      colors->text[i] = colors->fg[i];
+      colors->base[i].red = G_MAXUSHORT;
+      colors->base[i].green = G_MAXUSHORT;
+      colors->base[i].blue = G_MAXUSHORT;
+    }
+
+  colors->base[META_STATE_SELECTED] = meta_default_selected_bg;
+  colors->base[META_STATE_INSENSITIVE] = meta_default_prelight_bg;
+  colors->text[META_STATE_INSENSITIVE] = meta_default_insensitive_fg;
+
+  for (i = 0; i < 5; i++)
+    {
+      style_shade (&colors->bg[i], &colors->light[i], LIGHTNESS_MULT);
+      style_shade (&colors->bg[i], &colors->dark[i], DARKNESS_MULT);
+      
+      colors->mid[i].red = (colors->light[i].red + colors->dark[i].red) / 2;
+      colors->mid[i].green = (colors->light[i].green + colors->dark[i].green) / 2;
+      colors->mid[i].blue = (colors->light[i].blue + colors->dark[i].blue) / 2;
+
+      colors->text_aa[i].red = (colors->text[i].red + colors->base[i].red) / 2;
+      colors->text_aa[i].green = (colors->text[i].green + colors->base[i].green) / 2;
+      colors->text_aa[i].blue = (colors->text[i].blue + colors->base[i].blue) / 2;
+    }
 }

src/colors.h

@@ -28,8 +28,13 @@
 
 #include "screen.h"
 #include "util.h"
+#include "api.h"
+gulong              meta_screen_get_x_pixel      (MetaScreen         *screen,
+                                                  const PangoColor   *color);
+void                meta_screen_init_visual_info (MetaScreen         *screen);
+void                meta_screen_set_ui_colors    (MetaScreen         *screen,
+                                                  const MetaUIColors *colors);
+void                meta_screen_init_ui_colors   (MetaScreen         *screen);
 
-gulong meta_screen_get_x_pixel (MetaScreen       *screen,
-                                const PangoColor *color);
 
 #endif

src/display.c

@@ -148,26 +148,56 @@ meta_display_open (const char *name)
 }
 
 static void
-free_window (gpointer key, gpointer value, gpointer data)
+listify_func (gpointer key, gpointer value, gpointer data)
 {
-  MetaWindow *window;
+  GSList **listp;
 
-  window = value;
+  listp = data;
+  *listp = g_slist_prepend (*listp, value);
+}
 
-  meta_window_free (window);
+static gint
+ptrcmp (gconstpointer a, gconstpointer b)
+{
+  if (a < b)
+    return -1;
+  else if (a > b)
+    return 1;
+  else
+    return 0;
 }
 
 void
 meta_display_close (MetaDisplay *display)
 {
+  GSList *winlist;
+  GSList *tmp;
+  
   if (display->error_traps)
     meta_bug ("Display closed with error traps pending\n");
-  
+
+  winlist = NULL;
   g_hash_table_foreach (display->window_ids,
-                        free_window,
+                        listify_func,
-                        NULL);
+                        &winlist);
   
   g_hash_table_destroy (display->window_ids);
+
+  winlist = g_slist_sort (winlist, ptrcmp);
+
+  tmp = winlist;
+  while (tmp != NULL)
+    {
+      /* If the next node doesn't contain this window
+       * a second time, delete the window.
+       */
+      if (tmp->next == NULL ||
+          (tmp->next && tmp->next->data != tmp->data))
+        meta_window_free (tmp->data);
+      
+      tmp = tmp->data;
+    }
+  g_slist_free (winlist);
   
   meta_event_queue_free (display->events);
   XCloseDisplay (display->xdisplay);

src/frame.c

@@ -22,6 +22,7 @@
 #include "frame.h"
 #include "errors.h"
 #include "uislave.h"
+#include "colors.h"
 
 static void
 meta_frame_init_info (MetaFrame     *frame,
@@ -36,6 +37,7 @@ meta_frame_init_info (MetaFrame     *frame,
   info->title = frame->window->title;
   info->width = frame->rect.width;
   info->height = frame->rect.height;
+  info->colors = &(frame->window->screen->colors);
 }
 
 static void
@@ -119,8 +121,9 @@ meta_frame_calc_geometry (MetaFrame *frame,
   geom.right_width = 0;
   geom.top_height = 0;
   geom.bottom_height = 0;
-  geom.background_pixel = BlackPixel (window->display->xdisplay,
+  geom.background_pixel =
-                                      window->screen->number);
+    meta_screen_get_x_pixel (frame->window->screen,
+                             &frame->window->screen->colors.bg[META_STATE_NORMAL]);
 
   geom.shape_mask = None;
 

src/run-metacity.sh

@@ -2,6 +2,13 @@
 if test -z "$SCREENS"; then
   SCREENS=2
 fi
+
+if test "$DEBUG" = none; then
+  DEBUG=
+elif test -z "$DEBUG"; then
+  DEBUG=gdb
+fi
+
 Xnest :1 -scrns $SCREENS -geometry 270x270 &
-METACITY_UISLAVE_DIR=./uislave DISPLAY=:1 unst libtool --mode=execute gdb ./metacity
+METACITY_UISLAVE_DIR=./uislave DISPLAY=:1 unst libtool --mode=execute $DEBUG ./metacity
 killall Xnest

src/screen.c

@@ -25,6 +25,7 @@
 #include "window.h"
 #include "colors.h"
 #include "uislave.h"
+#include "frame.h"
 
 #include <X11/cursorfont.h>
 #include <locale.h>
@@ -98,6 +99,9 @@ meta_screen_new (MetaDisplay *display,
   
   screen->engine = &meta_default_engine;
 
+  meta_screen_init_visual_info (screen);
+  meta_screen_init_ui_colors (screen);
+  
   screen->uislave = meta_ui_slave_new (screen->screen_name,
                                        ui_slave_func,
                                        screen);
@@ -332,3 +336,76 @@ get_screen_name (MetaDisplay *display,
 
   return scr;
 }
+
+static gint
+ptrcmp (gconstpointer a, gconstpointer b)
+{
+  if (a < b)
+    return -1;
+  else if (a > b)
+    return 1;
+  else
+    return 0;
+}
+
+static void
+listify_func (gpointer key, gpointer value, gpointer data)
+{
+  GSList **listp;
+  
+  listp = data;
+
+  *listp = g_slist_prepend (*listp, value);
+}
+
+void
+meta_screen_foreach_window (MetaScreen *screen,
+                            MetaScreenWindowFunc func,
+                            gpointer data)
+{
+  GSList *winlist;
+  GSList *tmp;
+
+  /* If we end up doing this often, just keeping a list
+   * of windows might be sensible.
+   */
+  
+  winlist = NULL;
+  g_hash_table_foreach (screen->display->window_ids,
+                        listify_func,
+                        &winlist);
+  
+  winlist = g_slist_sort (winlist, ptrcmp);
+  
+  tmp = winlist;
+  while (tmp != NULL)
+    {
+      /* If the next node doesn't contain this window
+       * a second time, delete the window.
+       */
+      if (tmp->next == NULL ||
+          (tmp->next && tmp->next->data != tmp->data))
+        {
+          MetaWindow *window = tmp->data;
+
+          if (window->screen == screen)
+            (* func) (screen, window, data);
+        }
+      
+      tmp = tmp->data;
+    }
+  g_slist_free (winlist);
+}
+
+static void
+queue_draw (MetaScreen *screen, MetaWindow *window, gpointer data)
+{
+  if (window->frame)
+    meta_frame_queue_draw (window->frame);
+}
+
+void
+meta_screen_queue_frame_redraws (MetaScreen *screen)
+{
+  meta_screen_foreach_window (screen, queue_draw, NULL);
+}

src/screen.h

@@ -24,6 +24,10 @@
 
 #include "display.h"
 #include "theme.h"
+#include <X11/Xutil.h>
+
+typedef void (* MetaScreenWindowFunc) (MetaScreen *screen, MetaWindow *window,
+                                       gpointer user_data);
 
 struct _MetaScreen
 {
@@ -32,10 +36,11 @@ struct _MetaScreen
   char *screen_name;
   Screen *xscreen;
   Window xroot;
-
   MetaThemeEngine *engine;
-
   MetaUISlave *uislave;
+
+  XVisualInfo visual_info;
+  MetaUIColors colors;
   
   /*< private >*/
 
@@ -45,15 +50,22 @@ struct _MetaScreen
   PangoContext *pango_context;
 };
 
-MetaScreen*   meta_screen_new                (MetaDisplay                *display,
+MetaScreen*   meta_screen_new                 (MetaDisplay                *display,
-                                              int                         number);
+                                               int                         number);
-void          meta_screen_free               (MetaScreen                 *screen);
+void          meta_screen_free                (MetaScreen                 *screen);
-void          meta_screen_manage_all_windows (MetaScreen                 *screen);
+void          meta_screen_manage_all_windows  (MetaScreen                 *screen);
-PangoContext* meta_screen_get_pango_context  (MetaScreen                 *screen,
+PangoContext* meta_screen_get_pango_context   (MetaScreen                 *screen,
-                                              const PangoFontDescription *desc,
+                                               const PangoFontDescription *desc,
-                                              PangoDirection              direction);
+                                               PangoDirection              direction);
+MetaScreen*   meta_screen_for_x_screen        (Screen                     *xscreen);
+void          meta_screen_foreach_window      (MetaScreen                 *screen,
+                                               MetaScreenWindowFunc        func,
+                                               gpointer                    data);
+void          meta_screen_queue_frame_redraws (MetaScreen                 *screen);
 
-MetaScreen*   meta_screen_for_x_screen       (Screen                     *xscreen);
 
 #endif
 
+
+
+

src/theme.c

@@ -23,22 +23,64 @@
 #include "api.h"
 
 typedef struct _DefaultFrameData DefaultFrameData;
+typedef struct _DefaultScreenData DefaultScreenData;
 
 struct _DefaultFrameData
 {
   PangoLayout *layout;
-  GC text_gc;
-  GC fg_gc;
   int title_height;
 };
 
+struct _DefaultScreenData
+{
+  GC text_gc;
+  GC fg_gc;
+  GC light_gc;
+  GC dark_gc;
+};
+
+/* FIXME store this on the screen */
+static DefaultScreenData *screen_data = NULL;
+
 static gpointer
 default_acquire_frame (MetaFrameInfo *info)
 {
   DefaultFrameData *d;
   PangoFontDescription *desc;
   XGCValues vals;
-  PangoColor color;
+  
+  if (screen_data == NULL)
+    {
+      screen_data = g_new (DefaultScreenData, 1);      
+
+      vals.foreground = meta_get_x_pixel (info->screen,
+                                          &info->colors->fg[META_STATE_NORMAL]);
+      /* FIXME memory-inefficient, could use the same one for all frames
+       * w/ the same root window
+       */
+      screen_data->text_gc = XCreateGC (info->display,
+                                        RootWindowOfScreen (info->screen),
+                                        GCForeground,
+                                        &vals);
+      screen_data->fg_gc = XCreateGC (info->display,
+                                      RootWindowOfScreen (info->screen),
+                                      GCForeground,
+                                      &vals);
+
+      vals.foreground = meta_get_x_pixel (info->screen,
+                                          &info->colors->light[META_STATE_NORMAL]);
+      screen_data->light_gc = XCreateGC (info->display,
+                                         RootWindowOfScreen (info->screen),
+                                         GCForeground,
+                                         &vals);
+
+      vals.foreground = meta_get_x_pixel (info->screen,
+                                          &info->colors->dark[META_STATE_NORMAL]);
+      screen_data->dark_gc = XCreateGC (info->display,
+                                        RootWindowOfScreen (info->screen),
+                                        GCForeground,
+                                        &vals);
+    }
   
   d = g_new (DefaultFrameData, 1);
 
@@ -46,27 +88,14 @@ default_acquire_frame (MetaFrameInfo *info)
   d->layout = pango_layout_new (meta_get_pango_context (info->screen,
                                                         desc,
                                                         info->frame));
-
+  pango_font_description_free (desc);
-  color.red = color.green = color.blue = 0xffff;
-  vals.foreground = meta_get_x_pixel (info->screen, &color);
-  /* FIXME memory-inefficient, could use the same one for all frames
-   * w/ the same root window
-   */
-  d->text_gc = XCreateGC (info->display,
-                          RootWindowOfScreen (info->screen),
-                          GCForeground,
-                          &vals);
-  d->fg_gc = XCreateGC (info->display,
-                        RootWindowOfScreen (info->screen),
-                        GCForeground,
-                        &vals);
   
   d->title_height = 0;
   
   return d;
 }
 
-void
+static void
 default_release_frame (MetaFrameInfo *info,
                        gpointer       frame_data)
 {
@@ -76,9 +105,6 @@ default_release_frame (MetaFrameInfo *info,
 
   if (d->layout)
     g_object_unref (G_OBJECT (d->layout));
-
-  XFreeGC (info->display, d->text_gc);
-  XFreeGC (info->display, d->fg_gc);
   
   g_free (d);
 }
@@ -87,14 +113,14 @@ default_release_frame (MetaFrameInfo *info,
 #define LEFT_WIDTH 15
 #define RIGHT_WIDTH 15
 #define BOTTOM_HEIGHT 20
-void
+#define SPACER_SPACING 3
+static void
 default_fill_frame_geometry (MetaFrameInfo *info,
                              MetaFrameGeometry *geom,
                              gpointer       frame_data)
 {
   DefaultFrameData *d;
   PangoRectangle rect;
-  PangoColor color;
   
   d = frame_data;
       
@@ -111,13 +137,46 @@ default_fill_frame_geometry (MetaFrameInfo *info,
   geom->left_width = LEFT_WIDTH;
   geom->right_width = RIGHT_WIDTH;
   geom->bottom_height = BOTTOM_HEIGHT;
-
-  color.red = color.blue = color.green = 0;
   
-  geom->background_pixel = meta_get_x_pixel (info->screen, &color);
+  geom->background_pixel = meta_get_x_pixel (info->screen,
+                                             &info->colors->bg[META_STATE_NORMAL]);
 }
 
-void
+static void
+draw_vline (MetaFrameInfo *info,
+            Drawable       drawable,
+            GC             light_gc,
+            GC             dark_gc,
+            int            y1,
+            int            y2,
+            int            x)
+{
+  int thickness_light;
+  int thickness_dark;
+  int i;
+  
+  thickness_light = 1;
+  thickness_dark = 1;  
+
+  for (i = 0; i < thickness_dark; i++)
+    {
+      XDrawLine (info->display, drawable, light_gc,
+                 x + i, y2 - i - 1, x + i, y2);
+      XDrawLine (info->display, drawable, dark_gc,
+                 x + i, y1, x + i, y2 - i - 1);
+    }
+  
+  x += thickness_dark;
+  for (i = 0; i < thickness_light; i++)
+    {
+      XDrawLine (info->display, drawable, dark_gc,
+                 x + i, y1, x + i, y1 + thickness_light - i);
+      XDrawLine (info->display, drawable, light_gc,
+                 x + i, y1 + thickness_light - i, x + i, y2);
+    }
+}
+
+static void
 default_expose_frame (MetaFrameInfo *info,
                       int x, int y,
                       int width, int height,
@@ -125,21 +184,28 @@ default_expose_frame (MetaFrameInfo *info,
 {
   DefaultFrameData *d;
   int close_size;
+  XGCValues vals;
   
   d = frame_data;
   
   pango_x_render_layout (info->display,
                          info->frame,
-                         d->text_gc,
+                         screen_data->text_gc,
                          d->layout,
                          LEFT_WIDTH,
                          VERTICAL_TEXT_PAD);
 
   close_size = d->title_height;
+
+  vals.line_width = 2;
+  XChangeGC (info->display,
+             screen_data->fg_gc,
+             GCLineWidth,
+             &vals);
   
   XDrawLine (info->display,
              info->frame,
-             d->fg_gc,
+             screen_data->fg_gc,
              info->width - RIGHT_WIDTH - close_size,
              VERTICAL_TEXT_PAD,
              info->width - RIGHT_WIDTH,
@@ -147,15 +213,28 @@ default_expose_frame (MetaFrameInfo *info,
 
   XDrawLine (info->display,
              info->frame,
-             d->fg_gc,
+             screen_data->fg_gc,
              info->width - RIGHT_WIDTH,
              VERTICAL_TEXT_PAD,
              info->width - RIGHT_WIDTH - close_size,
              d->title_height - VERTICAL_TEXT_PAD);
+
+  vals.line_width = 0;
+  XChangeGC (info->display,
+             screen_data->fg_gc,
+             GCLineWidth,
+             &vals);
+  
+  draw_vline (info, info->frame,
+              screen_data->light_gc,
+              screen_data->dark_gc,
+              VERTICAL_TEXT_PAD,
+              d->title_height - VERTICAL_TEXT_PAD,
+              info->width - RIGHT_WIDTH - close_size - SPACER_SPACING);
 }
 
 #define RESIZE_EXTENDS 10
-MetaFrameControl
+static MetaFrameControl
 default_get_control (MetaFrameInfo *info,
                      int x, int y,
                      gpointer frame_data)
@@ -180,6 +259,17 @@ default_get_control (MetaFrameInfo *info,
   return META_FRAME_CONTROL_NONE;
 }
 
+/* FIXME add this to engine vtable */
+static void
+default_release_screen (Screen *screen)
+{
+  if (screen_data)
+    {
+      XFreeGC (DisplayOfScreen (screen), screen_data->text_gc);
+      XFreeGC (DisplayOfScreen (screen), screen_data->fg_gc);
+    }
+}
+
 MetaThemeEngine meta_default_engine = {
   NULL,
   default_acquire_frame,

src/theme.h

@@ -27,6 +27,7 @@
  */
 #include <X11/Xlib.h>
 #include <glib.h>
+#include "api.h"
 
 typedef struct _MetaFrameInfo       MetaFrameInfo;
 typedef struct _MetaFrameGeometry   MetaFrameGeometry;
@@ -72,6 +73,8 @@ struct _MetaFrameInfo
 
   const char *title;  
 
+  const MetaUIColors *colors;
+  
   /* Equal to child size before fill_frame_geometry
    * has been called
    */

src/window.c

@@ -620,9 +620,8 @@ update_title (MetaWindow *window)
     {
       g_free (window->title);
       window->title = NULL;
-    }
+    }  
-  
+
-  /* FIXME How does memory management for text.value work? */
   XGetTextProperty (window->display->xdisplay,
                     window->xwindow,
                     &text,
@@ -638,6 +637,9 @@ update_title (MetaWindow *window)
       window->title = g_strdup (text.value);
     }
 
+  if (text.nitems > 0)
+    XFree (text.value);
+  
   if (window->title == NULL &&
       text.nitems > 0)
     meta_warning ("_NET_WM_NAME property for %s contained invalid UTF-8\n",
@@ -674,12 +676,15 @@ update_title (MetaWindow *window)
                           window->desc, text.value);
 
           window->title = str;
+
+          XFree (text.value);
         }
     }
   
   if (window->title == NULL)
     window->title = g_strdup ("");
-  
+
+  g_free (window->desc);
   window->desc = g_strdup_printf ("0x%lx (%.10s)", window->xwindow, window->title);
   
   return meta_error_trap_pop (window->display);