src/server/widget.c

   1 #include "widget.h"
   2 #include "../lib/xdock.h"
   3 #include "square.xpm"
   4 #include "font.h"
   5
   6 #include <Imlib.h>
   7 #include <stdio.h>
   8
   9 Display* display;
  10 int n_clients;
  11 ImlibData* imlib_data;
  12 int screen_w, screen_h;
  13 int white;
  14
  15 Pixmap load_xpm(char** xpm)
  16 {
  17         ImlibImage* image = Imlib_create_image_from_xpm_data(
  18                         imlib_data, xpm);
  19         Imlib_render(imlib_data, image, image->rgb_width, image->rgb_height);
  20         return Imlib_copy_image(imlib_data, image);
  21 }
  22
  23 static void add_color(client_t* client, int n, const char* c)
  24 {
  25         XParseColor(display, client->colormap, c, &client->color[n]);
  26         XAllocColor(display, client->colormap, &client->color[n]);
  27 }
  28
  29 static void initialize_colormap(client_t* client)
  30 {
  31         client->colormap = DefaultColormap(display, 0);
  32         add_color(client, XD_BLACK,   "#000000");
  33         add_color(client, XD_GRAY_10, "#191919");
  34         add_color(client, XD_GRAY_20, "#333333");
  35         add_color(client, XD_GRAY_30, "#4C4C4C");
  36         add_color(client, XD_GRAY_40, "#656565");
  37         add_color(client, XD_GRAY_50, "#7F7F7F");
  38         add_color(client, XD_GRAY_60, "#989898");
  39         add_color(client, XD_GRAY_70, "#B1B1B1");
  40         add_color(client, XD_GRAY_80, "#CACACA");
  41         add_color(client, XD_GRAY_90, "#E3E3E3");
  42         add_color(client, XD_WHITE,   "#FFFFFF");
  43
  44         add_color(client, XD_LED_BG,      "#1B1B1B");
  45         add_color(client, XD_LED_UNLIT_1, "#004840");
  46         add_color(client, XD_LED_UNLIT_2, "#007C70");
  47         add_color(client, XD_LED_LIT_1,   "#188880");
  48         add_color(client, XD_LED_LIT_2,   "#20B0A8");
  49         add_color(client, XD_LED_GLOW,    "#00E800");
  50 }
  51
  52 int create_window()
  53 {
  54         XInitThreads();
  55
  56         display = XOpenDisplay(NULL);
  57         if(!display)
  58         {
  59                 fprintf(stderr, "Could not open display.\n");
  60                 return 0;
  61         }
  62
  63         imlib_data = Imlib_init(display);
  64
  65         white = WhitePixel(display, DefaultScreen(display));
  66
  67         screen_w = XDisplayWidth(display, DefaultScreen(display));
  68         screen_h = XDisplayHeight(display, DefaultScreen(display));
  69
  70         return 1;
  71 }
  72
  73 int draw_new_client(client_t* client)
  74 {
  75         Atom atoms[2] = { None, None };
  76         Atom strut;
  77         unsigned long struts[12] = { 0, };
  78
  79         client->window = XCreateSimpleWindow(
  80                         display,
  81                         DefaultRootWindow(display),
  82                         screen_w - 64, 0, // position
  83                         64, 1,
  84                         0,
  85                         white, white);
  86
  87         // XSelectInput(display, client->window, StructureNotifyMask);
  88
  89         XMapWindow(display, client->window);
  90
  91         atoms[0] = XInternAtom(display, "_NET_WM_WINDOW_TYPE_DOCK", False);
  92         XChangeProperty(display, client->window,
  93                         XInternAtom(display, "_NET_WM_WINDOW_TYPE", False),
  94                         XA_ATOM, 32, PropModeReplace,
  95                         (unsigned char*) atoms,
  96                         1);
  97
  98         strut = XInternAtom(display, "_NET_WM_STRUT", False);
  99         struts[1] = 64;
 100         XChangeProperty(display, client->window, strut, XA_CARDINAL, 32, PropModeReplace,
 101                         (unsigned char*)&struts, 4);
 102
 103         // XMoveWindow(display, client->window, screen_w - 64, 0);
 104         XResizeWindow(display, client->window, 64, 64);
 105
 106         client->gc = XCreateGC(display, client->window, 0, NULL);
 107
 108         initialize_colormap(client);
 109
 110         n_clients = 0;
 111
 112         client->pixmap = load_xpm(square_xpm);
 113
 114         XSelectInput(display, client->window, ExposureMask | StructureNotifyMask);
 115
 116         return -1;
 117 }
 118
 119 void undraw_client(client_t* client)
 120 {
 121         XUnmapWindow(display, client->window);
 122         XDestroyWindow(display, client->window);
 123 }
 124
 125 void do_events()
 126 {
 127         XEvent event;
 128
 129         while(1)
 130         {
 131                 XNextEvent(display, &event);
 132                 switch(event.type)
 133                 {
 134                         case Expose:
 135                                 {
 136                                         client_t* current = first_client;
 137                                         while(current)
 138                                         {
 139                                                 if(current->window == event.xexpose.window)
 140                                                 {
 141                                                         draw_update(current);
 142                                                         break;
 143                                                 }
 144                                                 current = current->next;
 145                                         }
 146                                 }
 147
 148                         case MapNotify:
 149                                 break;
 150                 }
 151         }
 152 }
 153
 154 int draw_update(client_t* client)
 155 {
 156         if(client)
 157                 XCopyArea(display, client->pixmap, client->window, client->gc, 0, 0, 64, 64, 0, 0);
 158         XFlush(display);
 159         return -1;
 160 }
 161
 162 int draw_pixel(client_t* client, int cl, int x, int y)
 163 {
 164         // TODO check if color validated
 165         XSetForeground(display, client->gc, client->color[cl].pixel);
 166         XDrawPoint(display, client->pixmap, client->gc, x, y);
 167
 168         return -1;
 169 }
 170
 171 int draw_line(client_t* client, int cl, int x1, int y1, int x2, int y2)
 172 {
 173         // TODO check if color validated
 174         XSetForeground(display, client->gc, client->color[cl].pixel);
 175         XDrawLine(display, client->pixmap, client->gc, x1, y1, x2, y2);
 176
 177         return -1;
 178 }
 179
 180 int write_text(client_t* client, int f, int x, int y, unsigned char *text)
 181 {
 182         int i = 0;
 183         unsigned int w, h;
 184         Window tmpw;
 185         int t;
 186         unsigned int ut;
 187
 188         // printf("write_text -> %s\n", text);
 189
 190         while(i < strlen((char*)text))
 191         {
 192                 if(font[f][text[i]])
 193                 {
 194                         XGetGeometry(display, font[f][text[i]], &tmpw, &t, &t,
 195                                         &w, &h, &ut, &ut);
 196                         if(x > 0 && (x+w) < 64 && y > 0 && (y+h) < 64)
 197                                 XCopyArea(display, font[f][text[i]], client->pixmap, client->gc,
 198                                                 0, 0, w, h, x, y);
 199                         x += w;
 200                 }
 201                 i++;
 202         }
 203
 204         return -1;
 205 }
 206
 207 int move_box(client_t* client, int x, int y, int w, int h, int direction, int s, int bg_color)
 208 {
 209         XSetForeground(display, client->gc, client->color[bg_color].pixel);
 210
 211         switch(direction)
 212         {
 213                 case XD_LEFT:
 214                         XCopyArea(display, client->pixmap, client->pixmap, client->gc,
 215                                         x+s, y, w-1, h, x, y);
 216                         XDrawLine(display, client->pixmap, client->gc, x+w-s, y, x+w-s, y+h-s);
 217                         break;
 218                 case XD_RIGHT:
 219                         XCopyArea(display, client->pixmap, client->pixmap, client->gc,
 220                                         x, y, w-s, h, x+s, y);
 221                         XDrawLine(display, client->pixmap, client->gc, x, y, x, y+h-s);
 222                         break;
 223                 case XD_DOWN:
 224                         XCopyArea(display, client->pixmap, client->pixmap, client->gc,
 225                                         x, y, w, h-s, x, y+s);
 226                         XDrawLine(display, client->pixmap, client->gc, x, y, x+w-s, y);
 227                         break;
 228                 case XD_UP:
 229                         XCopyArea(display, client->pixmap, client->pixmap, client->gc,
 230                                         x, y+s, w, h-s, x, y);
 231                         XDrawLine(display, client->pixmap, client->gc, x, y+h-s, x+w-s, y+h-s);
 232                         break;
 233                 default:
 234                         return 0;
 235         }
 236
 237         return 1;
 238 }
 239
 240 int new_pixmap(client_t* client, int number, int bytes, unsigned char* xpm)
 241 {
 242         char** xpm_pixmap;
 243         int c, j, i = 0, n = 0, nulls = 0;
 244
 245         // allocate memory
 246         for(j=0; j<bytes; j++)
 247                 if(xpm[j] == 0x0)
 248                         nulls++;
 249         xpm_pixmap = malloc((nulls + 1) * sizeof(char*));
 250
 251         // copy memory
 252         while(i<bytes)
 253         {
 254                 // find number of characters
 255                 c = 0;
 256                 while(xpm[c+i])
 257                         c++;
 258                 xpm_pixmap[n] = malloc(c+1);
 259                 memcpy(xpm_pixmap[n], &xpm[i], c+1);
 260
 261                 i += c + 1;
 262                 n++;
 263         }
 264         xpm_pixmap[n] = NULL;
 265
 266         // add image
 267         client->image = realloc(client->image, sizeof(image_t) * client->n_images);
 268         client->image[client->n_images].n = number;
 269         client->image[client->n_images].pixmap = load_xpm(xpm_pixmap);
 270         client->n_images++;
 271
 272         free(xpm_pixmap);
 273
 274         return -1;
 275 }
 276
 277 int draw_image(client_t* client, int n, int x, int y)
 278 {
 279         int i;
 280         Pixmap pixmap = 0;
 281         Window tmpw;
 282         int t;
 283         unsigned int w, h, ut;
 284
 285         // get image
 286         int found = 0;
 287         for(i=0; i<client->n_images; i++)
 288                 if(client->image[i].n == n)
 289                 {
 290                         found = 1;
 291                         pixmap = client->image[i].pixmap;
 292                 }
 293         if(!found)
 294                 return 0;
 295
 296         // draw image
 297         XGetGeometry(display, pixmap, &tmpw, &t, &t,
 298                         &w, &h, &ut, &ut);
 299         XCopyArea(display, pixmap, client->pixmap, client->gc,
 300                         0, 0, w, h, x, y);
 301
 302         return -1;
 303 }
 304
 305 int draw_led_panel(client_t* client, int x, int y, int w, int h)
 306 {
 307         XSetForeground(display, client->gc, client->color[XD_GRAY_90].pixel);
 308         XSetBackground(display, client->gc, client->color[XD_GRAY_90].pixel);
 309         XFillRectangle(display, client->pixmap, client->gc, x, y, w, h);
 310
 311         XSetForeground(display, client->gc, client->color[XD_BLACK].pixel);
 312         XSetBackground(display, client->gc, client->color[XD_BLACK].pixel);
 313         XFillRectangle(display, client->pixmap, client->gc, x, y, w-1, h-1);
 314
 315         XSetForeground(display, client->gc, client->color[XD_LED_BG].pixel);
 316         XSetBackground(display, client->gc, client->color[XD_LED_BG].pixel);
 317         XFillRectangle(display, client->pixmap, client->gc, x+1, y+1, w-2, h-2);
 318
 319         return -1;
 320 }