contiki-gtk/ctk/ctk-gtksim-service.c - contiki-1.x - Gitiles


 #include "ctk-draw-service.h"

 #include "ctk-gtksim-draw.h"

 #include "ctk-gtksim.h"

 #include <string.h>


 #define WINDOWBORDER_WIDTH  1
 #define WINDOWBORDER_HEIGHT 1
 #define WINDOWTITLE_HEIGHT  3
 #define MENU_HEIGHT         1
 #define MENUBAR_HEIGHT      12

 #define FONT_BASELINE 12

 #define MENUBAR_FONT_BASELINE 7

 #define RASTER_X 8
 #define RASTER_Y 14

 #define BUTTON_HEIGHT 12
 #define BUTTON_X_BORDER 4
 #define BUTTON_Y_BORDER 1

 #define TEXTENTRY_HEIGHT 12
 #define TEXTENTRY_X_BORDER 4
 #define TEXTENTRY_Y_BORDER 1

 static GdkGC *white, *lightgray, *midgray, *darkgray, *ddarkgray, *black,
   *blue;

 static GdkPixbuf *background, *windowborder, *menubar;

 static void
 draw_widget(struct ctk_widget *w,
 	    unsigned char winx,
 	    unsigned char winy,
 	    unsigned char clipx,
 	    unsigned char clipy,
 	    unsigned char clipy1,
 	    unsigned char clipy2,
 	    unsigned char focus);

 /*--------------------------------------------------------------------------*/
 static void
 s_ctk_draw_init(void)
 {
   GtkWidget *image;

   image = gtk_image_new_from_file("background.png");
   background = gtk_image_get_pixbuf(GTK_IMAGE(image));

   image = gtk_image_new_from_file("windowborder.png");
   windowborder = gtk_image_get_pixbuf(GTK_IMAGE(image));

   image = gtk_image_new_from_file("menubar.png");
   menubar = gtk_image_get_pixbuf(GTK_IMAGE(image));

   ctk_gtksim_init();
   ctk_gtksim_draw_init();


   blue = get_color(0, 0, 0xffff);
   white = get_color(0xffff, 0xffff, 0xffff);
   lightgray = get_color(0xefff, 0xefff, 0xefff);
   midgray = get_color(0xdfff, 0xdfff, 0xdfff);
   darkgray = get_color(0xcfff, 0xcfff, 0xcfff);
   ddarkgray = get_color(0xafff, 0xafff, 0xafff);
   black = get_color(0, 0, 0);


 }
 /*--------------------------------------------------------------------------*/
 static void
 s_ctk_draw_clear(unsigned char y1, unsigned char y2)
 {
   if(background == NULL) {
     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       darkgray,
 		       TRUE,
 		       0,
 		       y1 * RASTER_Y + MENUBAR_HEIGHT,
 		       CTK_GTKSIM_SCREEN_WIDTH,
 		       (y2 - y1) * RASTER_Y);
   } else {
     gdk_draw_pixbuf(ctk_gtksim_pixmap,
 		    darkgray,
 		    background,
 		    0,
 		    y1 * RASTER_Y,
 		    0,
 		    y1 * RASTER_Y + MENUBAR_HEIGHT,
 		    CTK_GTKSIM_SCREEN_WIDTH,
 		    (y2 - y1) * RASTER_Y,
 		    GDK_RGB_DITHER_NONE, 0, 0);
   }
 }
 /*--------------------------------------------------------------------------*/
 static void
 s_ctk_draw_clear_window(struct ctk_window *window,
 			unsigned char focus,
 			unsigned char clipy1,
 			unsigned char clipy2)
 {
   int x, y;

   x = window->x;
   y = window->y + MENU_HEIGHT;

   /* Clear window */
   if(focus & CTK_FOCUS_WINDOW) {
     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       white,
 		       TRUE,
 		       x * RASTER_X - 1,
 		       y * RASTER_Y - 1 + MENUBAR_HEIGHT,
 		       (window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X + 2,
 		       (window->h + WINDOWTITLE_HEIGHT +
 			            WINDOWBORDER_HEIGHT) * RASTER_Y + 2);
   } else {
     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       lightgray,
 		       TRUE,
 		       x * RASTER_X - 1,
 		       y * RASTER_Y - 1 + MENUBAR_HEIGHT,
 		       (window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X + 2,
 		       (window->h + WINDOWTITLE_HEIGHT +
 			            WINDOWBORDER_HEIGHT) * RASTER_Y + 2);
   }
 }
 /*--------------------------------------------------------------------------*/
 static void
 s_ctk_draw_window(struct ctk_window *window,
 		  unsigned char focus,
 		  unsigned char clipy1,
 		  unsigned char clipy2,
 		  unsigned char draw_borders)
 {
   struct ctk_widget *w;
   unsigned char wfocus;
   int x, y, x1, y1, x2, y2;

   x = window->x;
   y = window->y + MENU_HEIGHT;

   x1 = x + WINDOWBORDER_WIDTH;
   y1 = y + WINDOWTITLE_HEIGHT;
   x2 = x1 + window->w;
   y2 = y1 + window->h;

   /* Draw window border */
   gdk_draw_rectangle(ctk_gtksim_pixmap,
 		     darkgray,
 		     FALSE,
 		     x * RASTER_X,
 		     y * RASTER_Y + MENUBAR_HEIGHT,
 		     (window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
 		     (window->h + WINDOWTITLE_HEIGHT +
 		                  WINDOWBORDER_HEIGHT) * RASTER_Y);

   if(ctk_mode_get() == CTK_MODE_WINDOWMOVE) {
     if(focus & CTK_FOCUS_WINDOW) {
       gdk_draw_rectangle(ctk_gtksim_pixmap,
 			 white,
 			 TRUE,
 			 x * RASTER_X + 1,
 			 y * RASTER_Y + MENUBAR_HEIGHT + 1,
 			 (window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X - 2,
 			 (window->h + WINDOWTITLE_HEIGHT +
 			  WINDOWBORDER_HEIGHT) * RASTER_Y - 2);
     } else {
       gdk_draw_rectangle(ctk_gtksim_pixmap,
 			 midgray,
 			 TRUE,
 			 x * RASTER_X + 1,
 			 y * RASTER_Y + MENUBAR_HEIGHT + 1,
 			 (window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X - 2,
 			 (window->h + WINDOWTITLE_HEIGHT +
 			  WINDOWBORDER_HEIGHT) * RASTER_Y - 2);
     }
     return;
   }

   if(windowborder == NULL) {
     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       midgray,
 		       TRUE,
 		       x * RASTER_X,
 		       y * RASTER_Y + MENUBAR_HEIGHT,
 		       (window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
 		       WINDOWTITLE_HEIGHT * RASTER_Y);
   } else {
     gdk_draw_pixbuf(ctk_gtksim_pixmap,
 		    midgray,
 		    windowborder,
 		    0, 0,
 		    x * RASTER_X,
 		    y * RASTER_Y + MENUBAR_HEIGHT,
 		    (window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
 		    WINDOWTITLE_HEIGHT * RASTER_Y,
 		    GDK_RGB_DITHER_NONE, 0, 0);
   }


   gdk_draw_line(ctk_gtksim_pixmap,
 		darkgray,
 		x * RASTER_X,
 		(y + WINDOWTITLE_HEIGHT) * RASTER_Y - 1 + MENUBAR_HEIGHT,
 		(x + window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
 		(y + WINDOWTITLE_HEIGHT) * RASTER_Y - 1 + MENUBAR_HEIGHT);


   /* Draw inactive widgets. */
   for(w = window->inactive; w != NULL; w = w->next) {
     draw_widget(w, x1, y1, x2, y2,
 		clipy1, clipy2,
 		focus);
   }

   /* Draw active widgets. */
   for(w = window->active; w != NULL; w = w->next) {
     wfocus = focus;
     if(w == window->focused) {
       wfocus |= CTK_FOCUS_WIDGET;
     }

    draw_widget(w, x1, y1, x2, y2,
 	       clipy1, clipy2,
 	       wfocus);
   }

   ctk_gtksim_set_redrawflag();
 }
 /*--------------------------------------------------------------------------*/
 static void
 s_ctk_draw_dialog(struct ctk_window *window)
 {
   struct ctk_widget *w;
   unsigned char wfocus, focus;
   int x, y, x1, y1, x2, y2;

   focus = CTK_FOCUS_DIALOG;

   x = window->x;
   y = window->y + MENU_HEIGHT;

   x1 = x + WINDOWBORDER_WIDTH;
   y1 = y + WINDOWTITLE_HEIGHT;
   x2 = x1 + window->w;
   y2 = y1 + window->h;

   /* Draw window border */
   gdk_draw_rectangle(ctk_gtksim_pixmap,
 		     black,
 		     FALSE,
 		     x * RASTER_X,
 		     y * RASTER_Y + MENUBAR_HEIGHT,
 		     (window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
 		     (window->h + WINDOWTITLE_HEIGHT +
 		                  WINDOWBORDER_HEIGHT) * RASTER_Y);


   gdk_draw_rectangle(ctk_gtksim_pixmap,
 		     white,
 		     TRUE,
 		     x * RASTER_X + 1,
 		     y * RASTER_Y + 1 + MENUBAR_HEIGHT,
 		     (window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X - 2,
 		     (window->h + WINDOWTITLE_HEIGHT +
                                   WINDOWBORDER_HEIGHT) * RASTER_Y - 2);

   /* Draw inactive widgets. */
   for(w = window->inactive; w != NULL; w = w->next) {
     draw_widget(w, x1, y1, x2, y2,
 		y1, y2,
 		focus);
   }

   /* Draw active widgets. */
   for(w = window->active; w != NULL; w = w->next) {
     wfocus = focus;
     if(w == window->focused) {
       wfocus |= CTK_FOCUS_WIDGET;
     }

    draw_widget(w, x1, y1, x2, y2,
 	       y1, y2,
 	       wfocus);
   }

   ctk_gtksim_set_redrawflag();

 }
 /*--------------------------------------------------------------------------*/
 static void
 draw_widget(struct ctk_widget *w,
 	    unsigned char winx, unsigned char winy,
 	    unsigned char clipx,
 	    unsigned char clipy,
 	    unsigned char clipy1,
 	    unsigned char clipy2,
 	    unsigned char focus)
 {
   unsigned char text[1000];
   unsigned char x, y;
   int width, xpos;
   int i, j;
   GdkGC *bgcol, *buttoncol, *color, *inv_color;
   struct ctk_gtksim_draw_font *buttonfont, *textfont, *textfont_bold;
   int monospace;
   unsigned char *bitmap;

   x = winx + w->x;
   y = winy + w->y;

   if(focus & CTK_FOCUS_WINDOW) {
     bgcol = white;
   } else {
     bgcol = lightgray;
   }

   if(focus & CTK_FOCUS_WINDOW) {
     buttoncol = lightgray;
   } else {
     buttoncol = midgray;
   }

   monospace = w->flags & CTK_WIDGET_FLAG_MONOSPACE;
   if(monospace) {
     textfont = &ctk_gtksim_draw_font_monospace;
     textfont_bold = &ctk_gtksim_draw_font_monospace_bold;
   } else {
     textfont = &ctk_gtksim_draw_font_normal;
     textfont_bold = &ctk_gtksim_draw_font_bold;
   }

   switch(w->type) {
   case CTK_WIDGET_SEPARATOR:
     gdk_draw_line(ctk_gtksim_pixmap,
 		  darkgray,
 		  x * RASTER_X,
 		  y * RASTER_Y + RASTER_Y / 2 + MENUBAR_HEIGHT,
 		  (x + w->w) * RASTER_X,
 		  y * RASTER_Y + RASTER_Y / 2 + MENUBAR_HEIGHT);
     break;
   case CTK_WIDGET_LABEL:
     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       bgcol,
 		       TRUE,
 		       x * RASTER_X,
 		       y * RASTER_Y + MENUBAR_HEIGHT,
 		       w->w * RASTER_X,
 		       w->h * RASTER_Y);
     for(i = 0; i < w->h; ++i) {
       strncpy(text, &w->widget.label.text[i * w->w], w->w);
       for(j = 0; j < w->w; ++j) {
 	if(text[j] >= 0x80) {
 	  text[j] = text[j] & 0x7f;
 	}
 	if(text[j] == 0) {
 	  text[j] = ' ';
 	}
       }
       text[w->w] = 0;
       ctk_gtksim_draw_string(textfont,
 			     &ctk_gtksim_draw_color_black,
 			     RASTER_X * x,
 			     RASTER_Y * (y + i) + MENUBAR_HEIGHT,
 			     text, monospace);

       strncpy(text, &w->widget.label.text[i * w->w], w->w);
       for(j = 0; j < w->w; ++j) {
 	if(text[j] >= 0x80) {
 	  gdk_draw_rectangle(ctk_gtksim_pixmap,
 			     black,
 			     FALSE,
 			     (x + j) * RASTER_X - 2,
 			     y * RASTER_Y + MENUBAR_HEIGHT,
 			     RASTER_X + 2,
 			     BUTTON_HEIGHT + 1);
 	}
       }
     }

     break;
   case CTK_WIDGET_BUTTON:
     if(w == (struct ctk_widget *)&w->window->titlebutton) {
       buttonfont = &ctk_gtksim_draw_font_bold;
     } else {
       buttonfont = textfont;
     }

     ++x;

     width = ctk_gtksim_draw_string_width(buttonfont,
 					 w->widget.button.text,
 					 monospace);
     if(focus == (CTK_FOCUS_WIDGET|CTK_FOCUS_WINDOW) ||
        focus == (CTK_FOCUS_WIDGET|CTK_FOCUS_DIALOG)) {
       gdk_draw_rectangle(ctk_gtksim_pixmap,
 			 black,
 			 FALSE,
 			 x * RASTER_X - BUTTON_X_BORDER,
 			 y * RASTER_Y - BUTTON_Y_BORDER + MENUBAR_HEIGHT,
 			 w->w * RASTER_X + BUTTON_X_BORDER * 2,
 			 BUTTON_HEIGHT + BUTTON_Y_BORDER);
       /*      gdk_draw_rectangle(ctk_gtksim_pixmap,
 		    ctk_gtksim_drawing_area->style->black_gc,
 			 FALSE,
 			 x * RASTER_X - BUTTON_X_BORDER - 1,
 			 y * RASTER_Y - BUTTON_Y_BORDER - 1,
 			 w->w * RASTER_X + BUTTON_X_BORDER * 2 + 1,
 			 RASTER_Y + BUTTON_Y_BORDER * 2 + 1);*/
     } else {
       gdk_draw_rectangle(ctk_gtksim_pixmap,
 			 darkgray,
 			 FALSE,
 			 x * RASTER_X - BUTTON_X_BORDER,
 			 y * RASTER_Y - BUTTON_Y_BORDER + MENUBAR_HEIGHT,
 			 w->w * RASTER_X + BUTTON_X_BORDER * 2,
 			 BUTTON_HEIGHT + BUTTON_Y_BORDER);
     }
     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       buttoncol,
 		       TRUE,
 		       x * RASTER_X - BUTTON_X_BORDER + 1,
 		       y * RASTER_Y + MENUBAR_HEIGHT,
 		       w->w * RASTER_X + BUTTON_X_BORDER * 2 - 2,
 		       BUTTON_HEIGHT);

     gdk_draw_line(ctk_gtksim_pixmap,
 		  ddarkgray,
 		  x * RASTER_X - BUTTON_X_BORDER + 1,
 		  y * RASTER_Y + BUTTON_HEIGHT - 1 + MENUBAR_HEIGHT,
 		  x * RASTER_X + w->w * RASTER_X + BUTTON_X_BORDER - 1,
 		  y * RASTER_Y + BUTTON_HEIGHT - 1 + MENUBAR_HEIGHT);
     gdk_draw_line(ctk_gtksim_pixmap,
 		  ddarkgray,
 		  x * RASTER_X + w->w * RASTER_X + BUTTON_X_BORDER - 1,
 		  y * RASTER_Y + BUTTON_HEIGHT - 1 + MENUBAR_HEIGHT,
 		  x * RASTER_X + w->w * RASTER_X + BUTTON_X_BORDER - 1,
 		  y * RASTER_Y + MENUBAR_HEIGHT);

     if(w != &w->window->closebutton) {
       ctk_gtksim_draw_string(buttonfont,
 			     &ctk_gtksim_draw_color_black,
 			     RASTER_X * x +
 			     (w->w * RASTER_X) / 2 - width / 2,
 			     RASTER_Y * y + MENUBAR_HEIGHT,
 			     w->widget.button.text,
 			     monospace);
     }
     break;
   case CTK_WIDGET_HYPERLINK:
     strncpy(text, w->widget.hyperlink.text, w->w);
     text[w->w] = 0;
     width = ctk_gtksim_draw_string_width(textfont, text, monospace);
     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       bgcol,
 		       TRUE,
 		       x * RASTER_X,
 		       y * RASTER_Y + MENUBAR_HEIGHT,
 		       width,
 		       RASTER_Y);
     if(focus & CTK_FOCUS_WIDGET) {
       ctk_gtksim_draw_string(textfont_bold,
 			     &ctk_gtksim_draw_color_blue,
 			     RASTER_X * x,
 			     RASTER_Y * y + MENUBAR_HEIGHT,
 			     text, monospace);
     } else {
       ctk_gtksim_draw_string(textfont,
 			     &ctk_gtksim_draw_color_blue,
 			     RASTER_X * x,
 			     RASTER_Y * y + MENUBAR_HEIGHT,
 			     text, monospace);
     }
     gdk_draw_line(ctk_gtksim_pixmap,
 		  blue,
 		  x * RASTER_X,
 		  y * RASTER_Y + FONT_BASELINE + 1 + MENUBAR_HEIGHT,
 		  x * RASTER_X + width,
 		  y * RASTER_Y + FONT_BASELINE + 1 + MENUBAR_HEIGHT);

     break;
   case CTK_WIDGET_TEXTENTRY:
     strncpy(text, w->widget.textentry.text, sizeof(text));
     text[w->widget.textentry.xpos] = 0;
     width = ctk_gtksim_draw_string_width(textfont, text, monospace);
     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       darkgray,
 		       FALSE,
 		       x * RASTER_X - TEXTENTRY_X_BORDER + RASTER_X,
 		       y * RASTER_Y - TEXTENTRY_Y_BORDER + MENUBAR_HEIGHT,
 		       w->w * RASTER_X + TEXTENTRY_X_BORDER * 2 - 1,
 		       TEXTENTRY_HEIGHT + TEXTENTRY_Y_BORDER);
     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       bgcol,
 		       TRUE,
 		       x * RASTER_X + RASTER_X,
 		       y * RASTER_Y + MENUBAR_HEIGHT,
 		       w->w * RASTER_X,
 		       TEXTENTRY_HEIGHT);
     ctk_gtksim_draw_string(textfont,
 			   &ctk_gtksim_draw_color_black,
 			   RASTER_X * x + RASTER_X,
 			   RASTER_Y * y + MENUBAR_HEIGHT,
 			   w->widget.textentry.text,
 			   monospace);
     if(focus == (CTK_FOCUS_WIDGET|CTK_FOCUS_WINDOW) ||
        focus == (CTK_FOCUS_WIDGET|CTK_FOCUS_DIALOG)) {
       gdk_draw_line(ctk_gtksim_pixmap,
 		    black,
 		    x * RASTER_X + width + RASTER_X,
 		    y * RASTER_Y + MENUBAR_HEIGHT,
 		    x * RASTER_X + width + RASTER_X,
 		    y * RASTER_Y + TEXTENTRY_HEIGHT - 1 + MENUBAR_HEIGHT);
     }
     break;
   case CTK_WIDGET_ICON:
     width = ctk_gtksim_draw_string_width(&ctk_gtksim_draw_font_normal,
 					 w->widget.icon.title, monospace);

     if(x * RASTER_X + width >= CTK_GTKSIM_SCREEN_WIDTH - RASTER_X) {
       xpos = CTK_GTKSIM_SCREEN_WIDTH - width - RASTER_X;
     } else {
       xpos = x * RASTER_X;
     }

     if((focus & CTK_FOCUS_WIDGET) == 0) {
       color = black;
       inv_color = bgcol;
     } else {
       color = bgcol;
       inv_color = black;
     }

     bitmap = w->widget.icon.bitmap;
     if (bitmap != NULL) {
       int k, c;

       for (c = 0; c < 9; ++c) {
 	for (i = 0; i < 8; ++i) {
 	  unsigned char b = bitmap[i + c * 8];
 	  for (k = 0; k < 8; k++) {
 	    gdk_draw_rectangle(ctk_gtksim_pixmap,
 			       (b >> k) & 1 > 0 ? color : inv_color,
 			       TRUE,
 			       x * RASTER_X + 8 * (c % 3) + (8 - k),
 			       y * RASTER_Y + MENUBAR_HEIGHT +
 			       8 * (c / 3) + i,
 			       1, 1);
 	  }
 	}
       }
     } else {
       gdk_draw_rectangle(ctk_gtksim_pixmap,
 			 color,
 			 TRUE,
 			 x * RASTER_X,
 			 y * RASTER_Y + MENUBAR_HEIGHT,
 			 24, 24);
     }

     /*    if((focus & CTK_FOCUS_WIDGET) == 0) {
       gdk_draw_rectangle(ctk_gtksim_pixmap,
 			 bgcol,
 			 TRUE,
 			 x * RASTER_X,
 			 y * RASTER_Y + MENUBAR_HEIGHT,
 			 24, 24);
     } else {
       gdk_draw_rectangle(ctk_gtksim_pixmap,
 			 black,
 			 TRUE,
 			 x * RASTER_X,
 			 y * RASTER_Y + MENUBAR_HEIGHT,
 			 24, 24);
 			 }*/

     /*      gdk_draw_rectangle(ctk_gtksim_pixmap,
 	    white,
 	    TRUE,
 	    xpos,
 	    RASTER_Y * y + 24 + 1 + MENUBAR_HEIGHT,
 	    width,
 	    RASTER_Y);*/

     ctk_gtksim_draw_string(textfont,
 			   &ctk_gtksim_draw_color_black,
 			   xpos + 1,
 			   RASTER_Y * y + 24 + 1 + MENUBAR_HEIGHT,
 			   w->widget.icon.title,
 			   monospace);
     ctk_gtksim_draw_string(textfont,
 			   &ctk_gtksim_draw_color_white,
 			   xpos,
 			   RASTER_Y * y + 24 + MENUBAR_HEIGHT,
 			   w->widget.icon.title,
 			   monospace);


     break;
   default:
     break;
   }
 }

 /*--------------------------------------------------------------------------*/
 static void
 s_ctk_draw_widget(struct ctk_widget *w,
 		  unsigned char focus,
 		  unsigned char clipy1,
 		  unsigned char clipy2)
 {
   struct ctk_window *win = w->window;
   unsigned char posx, posy;

   posx = win->x + WINDOWBORDER_WIDTH;
   posy = win->y + WINDOWTITLE_HEIGHT + MENU_HEIGHT;

   if(w == win->focused) {
     focus |= CTK_FOCUS_WIDGET;
   }

   draw_widget(w, posx, posy,
 	      posx + win->w,
 	      posy + win->h,
 	      clipy1, clipy2,
 	      focus);

   ctk_gtksim_set_redrawflag();
 }
 /*--------------------------------------------------------------------------*/
 static void
 draw_menu(struct ctk_menu *m, int x, int open)
 {
   int i;
   int xpos;

   if(x >= CTK_GTKSIM_SCREEN_WIDTH / RASTER_X - 16) {
     xpos = CTK_GTKSIM_SCREEN_WIDTH / RASTER_X - 16;
   } else {
     xpos = x;
   }

   if(open) {

     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       black,
 		       TRUE,
 		       RASTER_X * x, 0,
 		       m->titlelen * RASTER_X,
 		       RASTER_Y + MENUBAR_HEIGHT);

     ctk_gtksim_draw_string(&ctk_gtksim_draw_font_menu,
 			   &ctk_gtksim_draw_color_white,
 			   RASTER_X * x + 2,
 			   MENUBAR_FONT_BASELINE,
 			   m->title, 0);

     gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       white,
 		       TRUE,
 		       xpos * RASTER_X,
 		       RASTER_Y * MENU_HEIGHT + MENUBAR_HEIGHT,
 		       (xpos + 16) * RASTER_X,
 		       (m->nitems) * RASTER_Y);

     for(i = 0; i < m->nitems; ++i) {
       if(i == m->active) {
 	gdk_draw_rectangle(ctk_gtksim_pixmap,
 			   black,
 			   TRUE,
 			   RASTER_X * xpos,
 			   (MENU_HEIGHT + i) * RASTER_Y + MENUBAR_HEIGHT,
 			   (xpos + 16) * RASTER_X,
 			   RASTER_Y);
 	ctk_gtksim_draw_string(&ctk_gtksim_draw_font_normal,
 			       &ctk_gtksim_draw_color_white,
 			       RASTER_X * xpos + 2,
 			       (MENU_HEIGHT + i) * RASTER_Y +
 			       MENUBAR_HEIGHT,
 			       m->items[i].title, 0);

       } else {
 	ctk_gtksim_draw_string(&ctk_gtksim_draw_font_normal,
 			       &ctk_gtksim_draw_color_black,
 			       RASTER_X * xpos + 2,
 			       (MENU_HEIGHT + i) * RASTER_Y + MENUBAR_HEIGHT,
 			       m->items[i].title, 0);
       }

     }
   } else {
     /*    gdk_draw_rectangle(ctk_gtksim_pixmap,
 		       white,
 		       TRUE,
 		       RASTER_X * x, 0,
 		       m->titlelen * RASTER_X, RASTER_Y);*/

     ctk_gtksim_draw_string(&ctk_gtksim_draw_font_menu,
 			   &ctk_gtksim_draw_color_black,
 			   RASTER_X * x, MENUBAR_FONT_BASELINE,
 			   m->title, 0);

   }
 }
 /*--------------------------------------------------------------------------*/
 static void
 s_ctk_draw_menus(struct ctk_menus *menus)
 {
   struct ctk_menu *m;
   int x;

   if(menubar != NULL) {
     gdk_draw_pixbuf(ctk_gtksim_pixmap,
 		    darkgray,
 		    menubar,
 		    0, 0,
 		    0, 0,
 		    CTK_GTKSIM_SCREEN_WIDTH,
 		    RASTER_Y + MENUBAR_HEIGHT,
 		    GDK_RGB_DITHER_NONE, 0, 0);
   }

   x = 1;
   for(m = menus->menus->next; m != NULL; m = m->next) {
     draw_menu(m, x, m == menus->open);
     x += strlen(m->title);
   }

   x = CTK_GTKSIM_SCREEN_WIDTH / RASTER_X - strlen(menus->menus->title);
   draw_menu(menus->menus, x, menus->menus == menus->open);


   /*  gdk_draw_line(ctk_gtksim_pixmap,
 		ctk_gtksim_drawing_area->style->black_gc,
 		0, RASTER_Y,
 		CTK_GTKSIM_SCREEN_WIDTH,
 		RASTER_Y);*/

   ctk_gtksim_set_redrawflag();
 }
 /*--------------------------------------------------------------------------*/
 static unsigned char
 s_ctk_draw_width(void)
 {
   return CTK_GTKSIM_SCREEN_WIDTH / RASTER_X;
 }
 /*--------------------------------------------------------------------------*/
 static unsigned char
 s_ctk_draw_height(void)
 {
   return CTK_GTKSIM_SCREEN_HEIGHT / RASTER_Y;
 }
 /*--------------------------------------------------------------------------*/
 static unsigned short
 s_ctk_mouse_xtoc(unsigned short x)
 {
   return x / RASTER_X;
 }
 /*--------------------------------------------------------------------------*/
 static unsigned short
 s_ctk_mouse_ytoc(unsigned short y)
 {
   if(y < MENUBAR_HEIGHT) {
     return 0;
   } else {
     return (y - MENUBAR_HEIGHT) / RASTER_Y;
   }
 }
 /*--------------------------------------------------------------------------*/
 static const struct ctk_draw_service_interface interface =
   {CTK_DRAW_SERVICE_VERSION,
    WINDOWBORDER_WIDTH,
    WINDOWBORDER_HEIGHT,
    WINDOWTITLE_HEIGHT,
    s_ctk_draw_init,
    s_ctk_draw_clear,
    s_ctk_draw_clear_window,
    s_ctk_draw_window,
    s_ctk_draw_dialog,
    s_ctk_draw_widget,
    s_ctk_draw_menus,
    s_ctk_draw_width,
    s_ctk_draw_height,
    s_ctk_mouse_xtoc,
    s_ctk_mouse_ytoc,
   };

 EK_POLLHANDLER(pollhandler);
 EK_EVENTHANDLER(eventhandler, ev, data);
 EK_PROCESS(proc, CTK_DRAW_SERVICE_NAME, EK_PRIO_NORMAL,
 	   eventhandler, pollhandler, (void *)&interface);

 /*--------------------------------------------------------------------------*/
 EK_PROCESS_INIT(ctk_gtksim_service_init, arg)
 {
   ek_service_start(CTK_DRAW_SERVICE_NAME, &proc);
 }
 /*--------------------------------------------------------------------------*/
 static GdkGC *
 get_color(unsigned short r, unsigned short g, unsigned short b)
 {
   GdkGCValues values;
   GdkColor color;

   color.pixel = 0;
   color.red = r;
   color.green = g;
   color.blue = b;

   if(gdk_colormap_alloc_color(gdk_colormap_get_system(),
 			      &color, FALSE, TRUE)) {
   }

   values.foreground = color;

   return gdk_gc_new_with_values(ctk_gtksim_drawing_area->window,
 				&values,
 				GDK_GC_FOREGROUND);
 }
 /*--------------------------------------------------------------------------*/
 EK_EVENTHANDLER(eventhandler, ev, data)
 {
   EK_EVENTHANDLER_ARGS(ev, data);

   switch(ev) {
   case EK_EVENT_INIT:
   case EK_EVENT_REPLACE:
     break;
   case EK_EVENT_REQUEST_REPLACE:
     ek_replace((struct ek_proc *)data, NULL);
     LOADER_UNLOAD();
     break;
   }
 }
 /*--------------------------------------------------------------------------*/
 EK_POLLHANDLER(pollhandler)
 {
   ctk_gtksim_redraw();
 }
 /*--------------------------------------------------------------------------*/

	#include "ctk-draw-service.h"

	#include "ctk-gtksim-draw.h"

	#include "ctk-gtksim.h"

	#include <string.h>


	#define WINDOWBORDER_WIDTH 1
	#define WINDOWBORDER_HEIGHT 1
	#define WINDOWTITLE_HEIGHT 3
	#define MENU_HEIGHT 1
	#define MENUBAR_HEIGHT 12

	#define FONT_BASELINE 12

	#define MENUBAR_FONT_BASELINE 7

	#define RASTER_X 8
	#define RASTER_Y 14

	#define BUTTON_HEIGHT 12
	#define BUTTON_X_BORDER 4
	#define BUTTON_Y_BORDER 1

	#define TEXTENTRY_HEIGHT 12
	#define TEXTENTRY_X_BORDER 4
	#define TEXTENTRY_Y_BORDER 1

	static GdkGC white, lightgray, midgray, darkgray, ddarkgray, black,
	*blue;

	static GdkPixbuf background, windowborder, *menubar;

	static void
	draw_widget(struct ctk_widget *w,
	unsigned char winx,
	unsigned char winy,
	unsigned char clipx,
	unsigned char clipy,
	unsigned char clipy1,
	unsigned char clipy2,
	unsigned char focus);

	/--------------------------------------------------------------------------/
	static void
	s_ctk_draw_init(void)
	{
	GtkWidget *image;

	image = gtk_image_new_from_file("background.png");
	background = gtk_image_get_pixbuf(GTK_IMAGE(image));

	image = gtk_image_new_from_file("windowborder.png");
	windowborder = gtk_image_get_pixbuf(GTK_IMAGE(image));

	image = gtk_image_new_from_file("menubar.png");
	menubar = gtk_image_get_pixbuf(GTK_IMAGE(image));

	ctk_gtksim_init();
	ctk_gtksim_draw_init();


	blue = get_color(0, 0, 0xffff);
	white = get_color(0xffff, 0xffff, 0xffff);
	lightgray = get_color(0xefff, 0xefff, 0xefff);
	midgray = get_color(0xdfff, 0xdfff, 0xdfff);
	darkgray = get_color(0xcfff, 0xcfff, 0xcfff);
	ddarkgray = get_color(0xafff, 0xafff, 0xafff);
	black = get_color(0, 0, 0);


	}
	/--------------------------------------------------------------------------/
	static void
	s_ctk_draw_clear(unsigned char y1, unsigned char y2)
	{
	if(background == NULL) {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	darkgray,
	TRUE,
	0,
	y1 * RASTER_Y + MENUBAR_HEIGHT,
	CTK_GTKSIM_SCREEN_WIDTH,
	(y2 - y1) * RASTER_Y);
	} else {
	gdk_draw_pixbuf(ctk_gtksim_pixmap,
	darkgray,
	background,
	0,
	y1 * RASTER_Y,
	0,
	y1 * RASTER_Y + MENUBAR_HEIGHT,
	CTK_GTKSIM_SCREEN_WIDTH,
	(y2 - y1) * RASTER_Y,
	GDK_RGB_DITHER_NONE, 0, 0);
	}
	}
	/--------------------------------------------------------------------------/
	static void
	s_ctk_draw_clear_window(struct ctk_window *window,
	unsigned char focus,
	unsigned char clipy1,
	unsigned char clipy2)
	{
	int x, y;

	x = window->x;
	y = window->y + MENU_HEIGHT;

	/* Clear window */
	if(focus & CTK_FOCUS_WINDOW) {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	white,
	TRUE,
	x * RASTER_X - 1,
	y * RASTER_Y - 1 + MENUBAR_HEIGHT,
	(window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X + 2,
	(window->h + WINDOWTITLE_HEIGHT +
	WINDOWBORDER_HEIGHT) * RASTER_Y + 2);
	} else {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	lightgray,
	TRUE,
	x * RASTER_X - 1,
	y * RASTER_Y - 1 + MENUBAR_HEIGHT,
	(window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X + 2,
	(window->h + WINDOWTITLE_HEIGHT +
	WINDOWBORDER_HEIGHT) * RASTER_Y + 2);
	}
	}
	/--------------------------------------------------------------------------/
	static void
	s_ctk_draw_window(struct ctk_window *window,
	unsigned char focus,
	unsigned char clipy1,
	unsigned char clipy2,
	unsigned char draw_borders)
	{
	struct ctk_widget *w;
	unsigned char wfocus;
	int x, y, x1, y1, x2, y2;

	x = window->x;
	y = window->y + MENU_HEIGHT;

	x1 = x + WINDOWBORDER_WIDTH;
	y1 = y + WINDOWTITLE_HEIGHT;
	x2 = x1 + window->w;
	y2 = y1 + window->h;

	/* Draw window border */
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	darkgray,
	FALSE,
	x * RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	(window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
	(window->h + WINDOWTITLE_HEIGHT +
	WINDOWBORDER_HEIGHT) * RASTER_Y);

	if(ctk_mode_get() == CTK_MODE_WINDOWMOVE) {
	if(focus & CTK_FOCUS_WINDOW) {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	white,
	TRUE,
	x * RASTER_X + 1,
	y * RASTER_Y + MENUBAR_HEIGHT + 1,
	(window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X - 2,
	(window->h + WINDOWTITLE_HEIGHT +
	WINDOWBORDER_HEIGHT) * RASTER_Y - 2);
	} else {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	midgray,
	TRUE,
	x * RASTER_X + 1,
	y * RASTER_Y + MENUBAR_HEIGHT + 1,
	(window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X - 2,
	(window->h + WINDOWTITLE_HEIGHT +
	WINDOWBORDER_HEIGHT) * RASTER_Y - 2);
	}
	return;
	}

	if(windowborder == NULL) {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	midgray,
	TRUE,
	x * RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	(window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
	WINDOWTITLE_HEIGHT * RASTER_Y);
	} else {
	gdk_draw_pixbuf(ctk_gtksim_pixmap,
	midgray,
	windowborder,
	0, 0,
	x * RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	(window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
	WINDOWTITLE_HEIGHT * RASTER_Y,
	GDK_RGB_DITHER_NONE, 0, 0);
	}


	gdk_draw_line(ctk_gtksim_pixmap,
	darkgray,
	x * RASTER_X,
	(y + WINDOWTITLE_HEIGHT) * RASTER_Y - 1 + MENUBAR_HEIGHT,
	(x + window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
	(y + WINDOWTITLE_HEIGHT) * RASTER_Y - 1 + MENUBAR_HEIGHT);


	/* Draw inactive widgets. */
	for(w = window->inactive; w != NULL; w = w->next) {
	draw_widget(w, x1, y1, x2, y2,
	clipy1, clipy2,
	focus);
	}

	/* Draw active widgets. */
	for(w = window->active; w != NULL; w = w->next) {
	wfocus = focus;
	if(w == window->focused) {
	wfocus \|= CTK_FOCUS_WIDGET;
	}

	draw_widget(w, x1, y1, x2, y2,
	clipy1, clipy2,
	wfocus);
	}

	ctk_gtksim_set_redrawflag();
	}
	/--------------------------------------------------------------------------/
	static void
	s_ctk_draw_dialog(struct ctk_window *window)
	{
	struct ctk_widget *w;
	unsigned char wfocus, focus;
	int x, y, x1, y1, x2, y2;

	focus = CTK_FOCUS_DIALOG;

	x = window->x;
	y = window->y + MENU_HEIGHT;

	x1 = x + WINDOWBORDER_WIDTH;
	y1 = y + WINDOWTITLE_HEIGHT;
	x2 = x1 + window->w;
	y2 = y1 + window->h;

	/* Draw window border */
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	black,
	FALSE,
	x * RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	(window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X,
	(window->h + WINDOWTITLE_HEIGHT +
	WINDOWBORDER_HEIGHT) * RASTER_Y);



	gdk_draw_rectangle(ctk_gtksim_pixmap,
	white,
	TRUE,
	x * RASTER_X + 1,
	y * RASTER_Y + 1 + MENUBAR_HEIGHT,
	(window->w + 2 * WINDOWBORDER_WIDTH) * RASTER_X - 2,
	(window->h + WINDOWTITLE_HEIGHT +
	WINDOWBORDER_HEIGHT) * RASTER_Y - 2);

	/* Draw inactive widgets. */
	for(w = window->inactive; w != NULL; w = w->next) {
	draw_widget(w, x1, y1, x2, y2,
	y1, y2,
	focus);
	}

	/* Draw active widgets. */
	for(w = window->active; w != NULL; w = w->next) {
	wfocus = focus;
	if(w == window->focused) {
	wfocus \|= CTK_FOCUS_WIDGET;
	}

	draw_widget(w, x1, y1, x2, y2,
	y1, y2,
	wfocus);
	}

	ctk_gtksim_set_redrawflag();

	}
	/--------------------------------------------------------------------------/
	static void
	draw_widget(struct ctk_widget *w,
	unsigned char winx, unsigned char winy,
	unsigned char clipx,
	unsigned char clipy,
	unsigned char clipy1,
	unsigned char clipy2,
	unsigned char focus)
	{
	unsigned char text[1000];
	unsigned char x, y;
	int width, xpos;
	int i, j;
	GdkGC bgcol, buttoncol, color, inv_color;
	struct ctk_gtksim_draw_font buttonfont, textfont, *textfont_bold;
	int monospace;
	unsigned char *bitmap;

	x = winx + w->x;
	y = winy + w->y;

	if(focus & CTK_FOCUS_WINDOW) {
	bgcol = white;
	} else {
	bgcol = lightgray;
	}

	if(focus & CTK_FOCUS_WINDOW) {
	buttoncol = lightgray;
	} else {
	buttoncol = midgray;
	}

	monospace = w->flags & CTK_WIDGET_FLAG_MONOSPACE;
	if(monospace) {
	textfont = &ctk_gtksim_draw_font_monospace;
	textfont_bold = &ctk_gtksim_draw_font_monospace_bold;
	} else {
	textfont = &ctk_gtksim_draw_font_normal;
	textfont_bold = &ctk_gtksim_draw_font_bold;
	}

	switch(w->type) {
	case CTK_WIDGET_SEPARATOR:
	gdk_draw_line(ctk_gtksim_pixmap,
	darkgray,
	x * RASTER_X,
	y * RASTER_Y + RASTER_Y / 2 + MENUBAR_HEIGHT,
	(x + w->w) * RASTER_X,
	y * RASTER_Y + RASTER_Y / 2 + MENUBAR_HEIGHT);
	break;
	case CTK_WIDGET_LABEL:
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	bgcol,
	TRUE,
	x * RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	w->w * RASTER_X,
	w->h * RASTER_Y);
	for(i = 0; i < w->h; ++i) {
	strncpy(text, &w->widget.label.text[i * w->w], w->w);
	for(j = 0; j < w->w; ++j) {
	if(text[j] >= 0x80) {
	text[j] = text[j] & 0x7f;
	}
	if(text[j] == 0) {
	text[j] = ' ';
	}
	}
	text[w->w] = 0;
	ctk_gtksim_draw_string(textfont,
	&ctk_gtksim_draw_color_black,
	RASTER_X * x,
	RASTER_Y * (y + i) + MENUBAR_HEIGHT,
	text, monospace);

	strncpy(text, &w->widget.label.text[i * w->w], w->w);
	for(j = 0; j < w->w; ++j) {
	if(text[j] >= 0x80) {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	black,
	FALSE,
	(x + j) * RASTER_X - 2,
	y * RASTER_Y + MENUBAR_HEIGHT,
	RASTER_X + 2,
	BUTTON_HEIGHT + 1);
	}
	}
	}

	break;
	case CTK_WIDGET_BUTTON:
	if(w == (struct ctk_widget *)&w->window->titlebutton) {
	buttonfont = &ctk_gtksim_draw_font_bold;
	} else {
	buttonfont = textfont;
	}

	++x;

	width = ctk_gtksim_draw_string_width(buttonfont,
	w->widget.button.text,
	monospace);
	if(focus == (CTK_FOCUS_WIDGET\|CTK_FOCUS_WINDOW) \|\|
	focus == (CTK_FOCUS_WIDGET\|CTK_FOCUS_DIALOG)) {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	black,
	FALSE,
	x * RASTER_X - BUTTON_X_BORDER,
	y * RASTER_Y - BUTTON_Y_BORDER + MENUBAR_HEIGHT,
	w->w * RASTER_X + BUTTON_X_BORDER * 2,
	BUTTON_HEIGHT + BUTTON_Y_BORDER);
	/* gdk_draw_rectangle(ctk_gtksim_pixmap,
	ctk_gtksim_drawing_area->style->black_gc,
	FALSE,
	x * RASTER_X - BUTTON_X_BORDER - 1,
	y * RASTER_Y - BUTTON_Y_BORDER - 1,
	w->w * RASTER_X + BUTTON_X_BORDER * 2 + 1,
	RASTER_Y + BUTTON_Y_BORDER * 2 + 1);*/
	} else {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	darkgray,
	FALSE,
	x * RASTER_X - BUTTON_X_BORDER,
	y * RASTER_Y - BUTTON_Y_BORDER + MENUBAR_HEIGHT,
	w->w * RASTER_X + BUTTON_X_BORDER * 2,
	BUTTON_HEIGHT + BUTTON_Y_BORDER);
	}
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	buttoncol,
	TRUE,
	x * RASTER_X - BUTTON_X_BORDER + 1,
	y * RASTER_Y + MENUBAR_HEIGHT,
	w->w * RASTER_X + BUTTON_X_BORDER * 2 - 2,
	BUTTON_HEIGHT);

	gdk_draw_line(ctk_gtksim_pixmap,
	ddarkgray,
	x * RASTER_X - BUTTON_X_BORDER + 1,
	y * RASTER_Y + BUTTON_HEIGHT - 1 + MENUBAR_HEIGHT,
	x * RASTER_X + w->w * RASTER_X + BUTTON_X_BORDER - 1,
	y * RASTER_Y + BUTTON_HEIGHT - 1 + MENUBAR_HEIGHT);
	gdk_draw_line(ctk_gtksim_pixmap,
	ddarkgray,
	x * RASTER_X + w->w * RASTER_X + BUTTON_X_BORDER - 1,
	y * RASTER_Y + BUTTON_HEIGHT - 1 + MENUBAR_HEIGHT,
	x * RASTER_X + w->w * RASTER_X + BUTTON_X_BORDER - 1,
	y * RASTER_Y + MENUBAR_HEIGHT);

	if(w != &w->window->closebutton) {
	ctk_gtksim_draw_string(buttonfont,
	&ctk_gtksim_draw_color_black,
	RASTER_X * x +
	(w->w * RASTER_X) / 2 - width / 2,
	RASTER_Y * y + MENUBAR_HEIGHT,
	w->widget.button.text,
	monospace);
	}
	break;
	case CTK_WIDGET_HYPERLINK:
	strncpy(text, w->widget.hyperlink.text, w->w);
	text[w->w] = 0;
	width = ctk_gtksim_draw_string_width(textfont, text, monospace);
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	bgcol,
	TRUE,
	x * RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	width,
	RASTER_Y);
	if(focus & CTK_FOCUS_WIDGET) {
	ctk_gtksim_draw_string(textfont_bold,
	&ctk_gtksim_draw_color_blue,
	RASTER_X * x,
	RASTER_Y * y + MENUBAR_HEIGHT,
	text, monospace);
	} else {
	ctk_gtksim_draw_string(textfont,
	&ctk_gtksim_draw_color_blue,
	RASTER_X * x,
	RASTER_Y * y + MENUBAR_HEIGHT,
	text, monospace);
	}
	gdk_draw_line(ctk_gtksim_pixmap,
	blue,
	x * RASTER_X,
	y * RASTER_Y + FONT_BASELINE + 1 + MENUBAR_HEIGHT,
	x * RASTER_X + width,
	y * RASTER_Y + FONT_BASELINE + 1 + MENUBAR_HEIGHT);

	break;
	case CTK_WIDGET_TEXTENTRY:
	strncpy(text, w->widget.textentry.text, sizeof(text));
	text[w->widget.textentry.xpos] = 0;
	width = ctk_gtksim_draw_string_width(textfont, text, monospace);
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	darkgray,
	FALSE,
	x * RASTER_X - TEXTENTRY_X_BORDER + RASTER_X,
	y * RASTER_Y - TEXTENTRY_Y_BORDER + MENUBAR_HEIGHT,
	w->w * RASTER_X + TEXTENTRY_X_BORDER * 2 - 1,
	TEXTENTRY_HEIGHT + TEXTENTRY_Y_BORDER);
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	bgcol,
	TRUE,
	x * RASTER_X + RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	w->w * RASTER_X,
	TEXTENTRY_HEIGHT);
	ctk_gtksim_draw_string(textfont,
	&ctk_gtksim_draw_color_black,
	RASTER_X * x + RASTER_X,
	RASTER_Y * y + MENUBAR_HEIGHT,
	w->widget.textentry.text,
	monospace);
	if(focus == (CTK_FOCUS_WIDGET\|CTK_FOCUS_WINDOW) \|\|
	focus == (CTK_FOCUS_WIDGET\|CTK_FOCUS_DIALOG)) {
	gdk_draw_line(ctk_gtksim_pixmap,
	black,
	x * RASTER_X + width + RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	x * RASTER_X + width + RASTER_X,
	y * RASTER_Y + TEXTENTRY_HEIGHT - 1 + MENUBAR_HEIGHT);
	}
	break;
	case CTK_WIDGET_ICON:
	width = ctk_gtksim_draw_string_width(&ctk_gtksim_draw_font_normal,
	w->widget.icon.title, monospace);

	if(x * RASTER_X + width >= CTK_GTKSIM_SCREEN_WIDTH - RASTER_X) {
	xpos = CTK_GTKSIM_SCREEN_WIDTH - width - RASTER_X;
	} else {
	xpos = x * RASTER_X;
	}

	if((focus & CTK_FOCUS_WIDGET) == 0) {
	color = black;
	inv_color = bgcol;
	} else {
	color = bgcol;
	inv_color = black;
	}

	bitmap = w->widget.icon.bitmap;
	if (bitmap != NULL) {
	int k, c;

	for (c = 0; c < 9; ++c) {
	for (i = 0; i < 8; ++i) {
	unsigned char b = bitmap[i + c * 8];
	for (k = 0; k < 8; k++) {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	(b >> k) & 1 > 0 ? color : inv_color,
	TRUE,
	x * RASTER_X + 8 * (c % 3) + (8 - k),
	y * RASTER_Y + MENUBAR_HEIGHT +
	8 * (c / 3) + i,
	1, 1);
	}
	}
	}
	} else {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	color,
	TRUE,
	x * RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	24, 24);
	}

	/* if((focus & CTK_FOCUS_WIDGET) == 0) {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	bgcol,
	TRUE,
	x * RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	24, 24);
	} else {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	black,
	TRUE,
	x * RASTER_X,
	y * RASTER_Y + MENUBAR_HEIGHT,
	24, 24);
	}*/

	/* gdk_draw_rectangle(ctk_gtksim_pixmap,
	white,
	TRUE,
	xpos,
	RASTER_Y * y + 24 + 1 + MENUBAR_HEIGHT,
	width,
	RASTER_Y);*/

	ctk_gtksim_draw_string(textfont,
	&ctk_gtksim_draw_color_black,
	xpos + 1,
	RASTER_Y * y + 24 + 1 + MENUBAR_HEIGHT,
	w->widget.icon.title,
	monospace);
	ctk_gtksim_draw_string(textfont,
	&ctk_gtksim_draw_color_white,
	xpos,
	RASTER_Y * y + 24 + MENUBAR_HEIGHT,
	w->widget.icon.title,
	monospace);


	break;
	default:
	break;
	}
	}

	/--------------------------------------------------------------------------/
	static void
	s_ctk_draw_widget(struct ctk_widget *w,
	unsigned char focus,
	unsigned char clipy1,
	unsigned char clipy2)
	{
	struct ctk_window *win = w->window;
	unsigned char posx, posy;

	posx = win->x + WINDOWBORDER_WIDTH;
	posy = win->y + WINDOWTITLE_HEIGHT + MENU_HEIGHT;

	if(w == win->focused) {
	focus \|= CTK_FOCUS_WIDGET;
	}

	draw_widget(w, posx, posy,
	posx + win->w,
	posy + win->h,
	clipy1, clipy2,
	focus);

	ctk_gtksim_set_redrawflag();
	}
	/--------------------------------------------------------------------------/
	static void
	draw_menu(struct ctk_menu *m, int x, int open)
	{
	int i;
	int xpos;

	if(x >= CTK_GTKSIM_SCREEN_WIDTH / RASTER_X - 16) {
	xpos = CTK_GTKSIM_SCREEN_WIDTH / RASTER_X - 16;
	} else {
	xpos = x;
	}

	if(open) {

	gdk_draw_rectangle(ctk_gtksim_pixmap,
	black,
	TRUE,
	RASTER_X * x, 0,
	m->titlelen * RASTER_X,
	RASTER_Y + MENUBAR_HEIGHT);

	ctk_gtksim_draw_string(&ctk_gtksim_draw_font_menu,
	&ctk_gtksim_draw_color_white,
	RASTER_X * x + 2,
	MENUBAR_FONT_BASELINE,
	m->title, 0);

	gdk_draw_rectangle(ctk_gtksim_pixmap,
	white,
	TRUE,
	xpos * RASTER_X,
	RASTER_Y * MENU_HEIGHT + MENUBAR_HEIGHT,
	(xpos + 16) * RASTER_X,
	(m->nitems) * RASTER_Y);

	for(i = 0; i < m->nitems; ++i) {
	if(i == m->active) {
	gdk_draw_rectangle(ctk_gtksim_pixmap,
	black,
	TRUE,
	RASTER_X * xpos,
	(MENU_HEIGHT + i) * RASTER_Y + MENUBAR_HEIGHT,
	(xpos + 16) * RASTER_X,
	RASTER_Y);
	ctk_gtksim_draw_string(&ctk_gtksim_draw_font_normal,
	&ctk_gtksim_draw_color_white,
	RASTER_X * xpos + 2,
	(MENU_HEIGHT + i) * RASTER_Y +
	MENUBAR_HEIGHT,
	m->items[i].title, 0);

	} else {
	ctk_gtksim_draw_string(&ctk_gtksim_draw_font_normal,
	&ctk_gtksim_draw_color_black,
	RASTER_X * xpos + 2,
	(MENU_HEIGHT + i) * RASTER_Y + MENUBAR_HEIGHT,
	m->items[i].title, 0);
	}

	}
	} else {
	/* gdk_draw_rectangle(ctk_gtksim_pixmap,
	white,
	TRUE,
	RASTER_X * x, 0,
	m->titlelen * RASTER_X, RASTER_Y);*/

	ctk_gtksim_draw_string(&ctk_gtksim_draw_font_menu,
	&ctk_gtksim_draw_color_black,
	RASTER_X * x, MENUBAR_FONT_BASELINE,
	m->title, 0);

	}
	}
	/--------------------------------------------------------------------------/
	static void
	s_ctk_draw_menus(struct ctk_menus *menus)
	{
	struct ctk_menu *m;
	int x;

	if(menubar != NULL) {
	gdk_draw_pixbuf(ctk_gtksim_pixmap,
	darkgray,
	menubar,
	0, 0,
	0, 0,
	CTK_GTKSIM_SCREEN_WIDTH,
	RASTER_Y + MENUBAR_HEIGHT,
	GDK_RGB_DITHER_NONE, 0, 0);
	}

	x = 1;
	for(m = menus->menus->next; m != NULL; m = m->next) {
	draw_menu(m, x, m == menus->open);
	x += strlen(m->title);
	}

	x = CTK_GTKSIM_SCREEN_WIDTH / RASTER_X - strlen(menus->menus->title);
	draw_menu(menus->menus, x, menus->menus == menus->open);



	/* gdk_draw_line(ctk_gtksim_pixmap,
	ctk_gtksim_drawing_area->style->black_gc,
	0, RASTER_Y,
	CTK_GTKSIM_SCREEN_WIDTH,
	RASTER_Y);*/

	ctk_gtksim_set_redrawflag();
	}
	/--------------------------------------------------------------------------/
	static unsigned char
	s_ctk_draw_width(void)
	{
	return CTK_GTKSIM_SCREEN_WIDTH / RASTER_X;
	}
	/--------------------------------------------------------------------------/
	static unsigned char
	s_ctk_draw_height(void)
	{
	return CTK_GTKSIM_SCREEN_HEIGHT / RASTER_Y;
	}
	/--------------------------------------------------------------------------/
	static unsigned short
	s_ctk_mouse_xtoc(unsigned short x)
	{
	return x / RASTER_X;
	}
	/--------------------------------------------------------------------------/
	static unsigned short
	s_ctk_mouse_ytoc(unsigned short y)
	{
	if(y < MENUBAR_HEIGHT) {
	return 0;
	} else {
	return (y - MENUBAR_HEIGHT) / RASTER_Y;
	}
	}
	/--------------------------------------------------------------------------/
	static const struct ctk_draw_service_interface interface =
	{CTK_DRAW_SERVICE_VERSION,
	WINDOWBORDER_WIDTH,
	WINDOWBORDER_HEIGHT,
	WINDOWTITLE_HEIGHT,
	s_ctk_draw_init,
	s_ctk_draw_clear,
	s_ctk_draw_clear_window,
	s_ctk_draw_window,
	s_ctk_draw_dialog,
	s_ctk_draw_widget,
	s_ctk_draw_menus,
	s_ctk_draw_width,
	s_ctk_draw_height,
	s_ctk_mouse_xtoc,
	s_ctk_mouse_ytoc,
	};

	EK_POLLHANDLER(pollhandler);
	EK_EVENTHANDLER(eventhandler, ev, data);
	EK_PROCESS(proc, CTK_DRAW_SERVICE_NAME, EK_PRIO_NORMAL,
	eventhandler, pollhandler, (void *)&interface);

	/--------------------------------------------------------------------------/
	EK_PROCESS_INIT(ctk_gtksim_service_init, arg)
	{
	ek_service_start(CTK_DRAW_SERVICE_NAME, &proc);
	}
	/--------------------------------------------------------------------------/
	static GdkGC *
	get_color(unsigned short r, unsigned short g, unsigned short b)
	{
	GdkGCValues values;
	GdkColor color;

	color.pixel = 0;
	color.red = r;
	color.green = g;
	color.blue = b;

	if(gdk_colormap_alloc_color(gdk_colormap_get_system(),
	&color, FALSE, TRUE)) {
	}

	values.foreground = color;

	return gdk_gc_new_with_values(ctk_gtksim_drawing_area->window,
	&values,
	GDK_GC_FOREGROUND);
	}
	/--------------------------------------------------------------------------/
	EK_EVENTHANDLER(eventhandler, ev, data)
	{
	EK_EVENTHANDLER_ARGS(ev, data);

	switch(ev) {
	case EK_EVENT_INIT:
	case EK_EVENT_REPLACE:
	break;
	case EK_EVENT_REQUEST_REPLACE:
	ek_replace((struct ek_proc *)data, NULL);
	LOADER_UNLOAD();
	break;
	}
	}
	/--------------------------------------------------------------------------/
	EK_POLLHANDLER(pollhandler)
	{
	ctk_gtksim_redraw();
	}
	/--------------------------------------------------------------------------/