git.ozlabs.org Git - petitboot/blob - petitboot.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <stdlib.h>
   4 #include <signal.h>
   5 #include <unistd.h>
   6 #include <syscall.h>
   7 #include <assert.h>
   8
   9 #include <linux/input.h>
  10
  11 #undef _USE_X11
  12
  13 #include <libtwin/twin.h>
  14 #include <libtwin/twin_linux_mouse.h>
  15 #include <libtwin/twin_png.h>
  16
  17 #include "petitboot.h"
  18 #include "petitboot-paths.h"
  19
  20 #ifdef _USE_X11
  21 #include <libtwin/twin_x11.h>
  22 static twin_x11_t *pboot_x11;
  23 #else
  24 #include <libtwin/twin_fbdev.h>
  25 static twin_fbdev_t *pboot_fbdev;
  26 #endif
  27
  28 static twin_screen_t *pboot_screen;
  29
  30 #define PBOOT_LEFT_PANE_SIZE            200
  31 #define PBOOT_LEFT_PANE_COLOR           0x80000000
  32 #define PBOOT_LEFT_LINE_COLOR           0xff000000
  33
  34 #define PBOOT_LEFT_FOCUS_WIDTH          80
  35 #define PBOOT_LEFT_FOCUS_HEIGHT         80
  36 #define PBOOT_LEFT_FOCUS_XOFF           60
  37 #define PBOOT_LEFT_FOCUS_YOFF           60
  38 #define PBOOT_LEFT_FOCUS_XRAD           (6 * TWIN_FIXED_ONE)
  39 #define PBOOT_LEFT_FOCUS_YRAD           (6 * TWIN_FIXED_ONE)
  40
  41 #define PBOOT_RIGHT_FOCUS_XOFF          20
  42 #define PBOOT_RIGHT_FOCUS_YOFF          60
  43 #define PBOOT_RIGHT_FOCUS_HEIGHT        80
  44 #define PBOOT_RIGHT_FOCUS_XRAD          (6 * TWIN_FIXED_ONE)
  45 #define PBOOT_RIGHT_FOCUS_YRAD          (6 * TWIN_FIXED_ONE)
  46
  47 #define PBOOT_LEFT_ICON_WIDTH           64
  48 #define PBOOT_LEFT_ICON_HEIGHT          64
  49 #define PBOOT_LEFT_ICON_XOFF            70
  50 #define PBOOT_LEFT_ICON_YOFF            70
  51 #define PBOOT_LEFT_ICON_STRIDE          100
  52
  53 #define PBOOT_RIGHT_OPTION_LMARGIN      30
  54 #define PBOOT_RIGHT_OPTION_RMARGIN      30
  55 #define PBOOT_RIGHT_OPTION_TMARGIN      70
  56 #define PBOOT_RIGHT_OPTION_HEIGHT       64
  57 #define PBOOT_RIGHT_OPTION_STRIDE       100
  58 #define PBOOT_RIGHT_TITLE_TEXT_SIZE     (30 * TWIN_FIXED_ONE)
  59 #define PBOOT_RIGHT_SUBTITLE_TEXT_SIZE  (18 * TWIN_FIXED_ONE)
  60 #define PBOOT_RIGHT_TITLE_XOFFSET       80
  61 #define PBOOT_RIGHT_TITLE_YOFFSET       30
  62 #define PBOOT_RIGHT_SUBTITLE_XOFFSET    200
  63 #define PBOOT_RIGHT_SUBTITLE_YOFFSET    50
  64 #define PBOOT_RIGHT_BADGE_XOFFSET       2
  65 #define PBOOT_RIGHT_BADGE_YOFFSET       0
  66
  67
  68 #define PBOOT_RIGHT_TITLE_COLOR         0xff000000
  69 #define PBOOT_RIGHT_SUBTITLE_COLOR      0xff400000
  70
  71 #define PBOOT_FOCUS_COLOR               0x10404040
  72
  73
  74 typedef struct _pboot_option pboot_option_t;
  75 typedef struct _pboot_device pboot_device_t;
  76
  77 struct _pboot_option
  78 {
  79         char            *title;
  80         char            *subtitle;
  81         twin_pixmap_t   *badge;
  82         twin_pixmap_t   *cache;
  83         twin_rect_t     box;
  84         void            *data;
  85 };
  86
  87 struct _pboot_device
  88 {
  89         char                    *id;
  90         twin_pixmap_t           *badge;
  91         twin_rect_t             box;
  92         int                     option_count;
  93         pboot_option_t          options[PBOOT_MAX_OPTION];
  94 };
  95
  96 static twin_pixmap_t    *pboot_cursor;
  97 static int              pboot_cursor_hx;
  98 static int              pboot_cursor_hy;
  99
 100 static pboot_device_t   *pboot_devices[PBOOT_MAX_DEV];
 101 static int              pboot_dev_count;
 102 static int              pboot_dev_sel = -1;
 103 static int              pboot_focus_lpane = 1;
 104
 105 typedef struct _pboot_lpane {
 106         twin_window_t   *window;
 107         twin_rect_t     focus_box;
 108         int             focus_start;
 109         int             focus_target;
 110         int             focus_curindex;
 111         int             mouse_target;
 112 } pboot_lpane_t;
 113
 114 typedef struct _pboot_rpane {
 115         twin_window_t   *window;
 116         twin_rect_t     focus_box;
 117         int             focus_start;
 118         int             focus_target;
 119         int             focus_curindex;
 120         int             mouse_target;
 121 } pboot_rpane_t;
 122
 123 static pboot_lpane_t    *pboot_lpane;
 124 static pboot_rpane_t    *pboot_rpane;
 125
 126 /* XXX move to twin */
 127 static inline twin_bool_t twin_rect_intersect(twin_rect_t r1,
 128                                               twin_rect_t r2)
 129 {
 130         return !(r1.left > r2.right ||
 131                  r1.right < r2.left ||
 132                  r1.top > r2.bottom ||
 133                  r1.bottom < r2.top);
 134 }
 135
 136 static void pboot_draw_option_cache(pboot_device_t *dev, pboot_option_t *opt,
 137                                     int index)
 138 {
 139         twin_pixmap_t   *px;
 140         twin_path_t     *path;
 141         twin_fixed_t    tx, ty;
 142
 143         /* Create pixmap */
 144         px = twin_pixmap_create(TWIN_ARGB32, opt->box.right - opt->box.left,
 145                                  opt->box.bottom - opt->box.top);
 146         assert(px);
 147         opt->cache = px;
 148
 149         /* Fill background */
 150         twin_fill(px, 0x00000000, TWIN_SOURCE, 0, 0, px->width, px->height);
 151
 152         /* Allocate a path for drawing */
 153         path = twin_path_create();
 154         assert(path);
 155
 156 #if 0
 157         /* TEST - Bounding rectangle */
 158         twin_path_rectangle(path, 0, 0,
 159                             twin_int_to_fixed(px->width),
 160                             twin_int_to_fixed(px->height));
 161         twin_paint_path(px, PBOOT_RIGHT_TITLE_COLOR, path);
 162         twin_path_empty(path);
 163         twin_fill(px, 0x00000000, TWIN_SOURCE, 2, 2,
 164                   px->width - 3, px->height - 3);
 165 #endif
 166
 167         /* Draw texts */
 168         twin_path_set_font_size(path, PBOOT_RIGHT_TITLE_TEXT_SIZE);
 169         twin_path_set_font_style(path, TWIN_TEXT_UNHINTED);
 170         tx = twin_int_to_fixed(PBOOT_RIGHT_TITLE_XOFFSET);
 171         ty = twin_int_to_fixed(PBOOT_RIGHT_TITLE_YOFFSET);
 172         twin_path_move (path, tx, ty);
 173         twin_path_utf8 (path, opt->title);
 174         twin_paint_path (px, PBOOT_RIGHT_TITLE_COLOR, path);
 175         twin_path_empty (path);
 176
 177         if (opt->subtitle) {
 178                 twin_path_set_font_size(path, PBOOT_RIGHT_SUBTITLE_TEXT_SIZE);
 179                 twin_path_set_font_style(path, TWIN_TEXT_UNHINTED);
 180                 tx = twin_int_to_fixed(PBOOT_RIGHT_SUBTITLE_XOFFSET);
 181                 ty = twin_int_to_fixed(PBOOT_RIGHT_SUBTITLE_YOFFSET);
 182                 twin_path_move (path, tx, ty);
 183                 twin_path_utf8 (path, opt->subtitle);
 184                 twin_paint_path (px, PBOOT_RIGHT_SUBTITLE_COLOR, path);
 185                 twin_path_empty (path);
 186         }
 187
 188         if (opt->badge) {
 189                 twin_operand_t  src;
 190
 191                 src.source_kind = TWIN_PIXMAP;
 192                 src.u.pixmap = opt->badge;
 193
 194                 twin_composite(px, PBOOT_RIGHT_BADGE_XOFFSET,
 195                                PBOOT_RIGHT_BADGE_YOFFSET,
 196                                &src, 0, 0, NULL, 0, 0, TWIN_OVER,
 197                                opt->badge->width, opt->badge->height);
 198         }
 199
 200
 201         /* Destroy path */
 202         twin_path_destroy(path);
 203 }
 204
 205 static void pboot_rpane_draw(twin_window_t *window)
 206 {
 207         twin_pixmap_t   *px = window->pixmap;
 208         pboot_rpane_t   *rpane = window->client_data;
 209         pboot_device_t  *dev;
 210         twin_path_t     *path;
 211         twin_fixed_t    x, y, w, h;
 212         int             i;
 213
 214         /* Fill background */
 215         twin_fill(px, 0x00000000, TWIN_SOURCE, 0, 0, px->width, px->height);
 216
 217         /* Nothing to draw, return */
 218         if (pboot_dev_sel < 0)
 219                 return;
 220
 221         /* Create a path for use later */
 222         path = twin_path_create();
 223         assert(path);
 224
 225         /* Draw focus box */
 226         if (rpane->focus_curindex >= 0 &&
 227             twin_rect_intersect(rpane->focus_box, px->clip)) {
 228                 x = twin_int_to_fixed(rpane->focus_box.left + 2);
 229                 y = twin_int_to_fixed(rpane->focus_box.top + 2);
 230                 w = twin_int_to_fixed(rpane->focus_box.right -
 231                                       rpane->focus_box.left - 4);
 232                 h = twin_int_to_fixed(rpane->focus_box.bottom -
 233                                       rpane->focus_box.top - 4);
 234                 twin_path_rounded_rectangle(path, x, y, w, h,
 235                                             PBOOT_RIGHT_FOCUS_XRAD,
 236                                             PBOOT_RIGHT_FOCUS_YRAD);
 237                 if (!pboot_focus_lpane)
 238                         twin_paint_path(px, PBOOT_FOCUS_COLOR, path);
 239                 else
 240                         twin_paint_stroke(px, PBOOT_FOCUS_COLOR, path,
 241                                           4 * TWIN_FIXED_ONE);
 242         }
 243
 244         /* Get device and iterate through options */
 245         dev = pboot_devices[pboot_dev_sel];
 246         for (i = 0; i < dev->option_count; i++) {
 247                 pboot_option_t  *opt = &dev->options[i];
 248                 twin_operand_t  src;
 249
 250                 if (opt->title == NULL)
 251                         continue;
 252                 if (!twin_rect_intersect(opt->box, px->clip))
 253                         continue;
 254                 if (opt->cache == NULL)
 255                         pboot_draw_option_cache(dev, opt, i);
 256
 257                 src.source_kind = TWIN_PIXMAP;
 258                 src.u.pixmap = opt->cache;
 259
 260                 twin_composite(px, opt->box.left, opt->box.top,
 261                                &src, 0, 0, NULL, 0, 0, TWIN_OVER,
 262                                opt->box.right - opt->box.left,
 263                                opt->box.bottom - opt->box.top);
 264         }
 265
 266         /* Destroy path */
 267         twin_path_destroy(path);
 268 }
 269
 270 static twin_time_t pboot_rfocus_timeout (twin_time_t now, void *closure)
 271 {
 272         int dir = 1, dist, pos;
 273         const int accel[11] = { 7, 4, 2, 1, 1, 1, 1, 2, 3, 4, 5 };
 274
 275         dist = abs(pboot_rpane->focus_target - pboot_rpane->focus_start);
 276         dir = dist > 5 ? 5 : dist;
 277         pos = pboot_rpane->focus_target - (int)pboot_rpane->focus_box.top;
 278         if (pos == 0) {
 279                 return -1;
 280         }
 281         if (pos < 0) {
 282                 dir = -dir;
 283                 pos = -pos;
 284         }
 285         twin_window_damage(pboot_rpane->window,
 286                            pboot_rpane->focus_box.left,
 287                            pboot_rpane->focus_box.top,
 288                            pboot_rpane->focus_box.right,
 289                            pboot_rpane->focus_box.bottom);
 290
 291         pboot_rpane->focus_box.top += dir;
 292         pboot_rpane->focus_box.bottom += dir;
 293
 294         twin_window_damage(pboot_rpane->window,
 295                            pboot_rpane->focus_box.left,
 296                            pboot_rpane->focus_box.top,
 297                            pboot_rpane->focus_box.right,
 298                            pboot_rpane->focus_box.bottom);
 299
 300         twin_window_queue_paint(pboot_rpane->window);
 301
 302         return accel[(pos * 10) / dist];
 303 }
 304
 305 static void pboot_set_rfocus(int index)
 306 {
 307         pboot_device_t  *dev;
 308
 309         if (pboot_dev_sel < 0 || pboot_dev_sel >= pboot_dev_count)
 310                 return;
 311         dev = pboot_devices[pboot_dev_sel];
 312         if (index < 0 || index >= dev->option_count)
 313                 return;
 314
 315         pboot_rpane->focus_start = pboot_rpane->focus_box.top;
 316         pboot_rpane->focus_target = PBOOT_RIGHT_FOCUS_YOFF +
 317                 PBOOT_RIGHT_OPTION_STRIDE * index;
 318         pboot_rpane->focus_curindex = index;
 319
 320         twin_set_timeout(pboot_rfocus_timeout, 0, NULL);
 321 }
 322
 323 static void pboot_select_rpane(void)
 324 {
 325         if (pboot_focus_lpane == 0)
 326                 return;
 327         pboot_focus_lpane = 0;
 328
 329         twin_screen_set_active(pboot_screen, pboot_rpane->window->pixmap);
 330
 331         twin_window_damage(pboot_lpane->window,
 332                            pboot_lpane->focus_box.left,
 333                            pboot_lpane->focus_box.top,
 334                            pboot_lpane->focus_box.right,
 335                            pboot_lpane->focus_box.bottom);
 336
 337         twin_window_damage(pboot_rpane->window,
 338                            pboot_rpane->focus_box.left,
 339                            pboot_rpane->focus_box.top,
 340                            pboot_rpane->focus_box.right,
 341                            pboot_rpane->focus_box.bottom);
 342
 343         twin_window_queue_paint(pboot_lpane->window);
 344         twin_window_queue_paint(pboot_rpane->window);
 345
 346         pboot_set_rfocus(0);
 347 }
 348
 349 static void pboot_select_lpane(void)
 350 {
 351         if (pboot_focus_lpane == 1)
 352                 return;
 353         pboot_focus_lpane = 1;
 354
 355         twin_screen_set_active(pboot_screen, pboot_lpane->window->pixmap);
 356
 357         twin_window_damage(pboot_lpane->window,
 358                            pboot_lpane->focus_box.left,
 359                            pboot_lpane->focus_box.top,
 360                            pboot_lpane->focus_box.right,
 361                            pboot_lpane->focus_box.bottom);
 362
 363         twin_window_damage(pboot_rpane->window,
 364                            pboot_rpane->focus_box.left,
 365                            pboot_rpane->focus_box.top,
 366                            pboot_rpane->focus_box.right,
 367                            pboot_rpane->focus_box.bottom);
 368
 369         twin_window_queue_paint(pboot_lpane->window);
 370         twin_window_queue_paint(pboot_rpane->window);
 371 }
 372
 373 static void pboot_rpane_mousetrack(twin_coord_t x, twin_coord_t y)
 374 {
 375         pboot_device_t  *dev;
 376         pboot_option_t  *opt;
 377         int             candidate = -1;
 378
 379         if (pboot_dev_sel < 0 || pboot_dev_sel >= pboot_dev_count)
 380                 return;
 381         dev = pboot_devices[pboot_dev_sel];
 382
 383         if (y < PBOOT_RIGHT_OPTION_TMARGIN)
 384                 goto miss;
 385         candidate = (y - PBOOT_RIGHT_OPTION_TMARGIN) /
 386                 PBOOT_RIGHT_OPTION_STRIDE;
 387         if (candidate >= dev->option_count) {
 388                 candidate = -1;
 389                 goto miss;
 390         }
 391         if (candidate == pboot_rpane->mouse_target)
 392                 return;
 393         opt = &dev->options[candidate];
 394         if (x < opt->box.left || x > opt->box.right ||
 395             y < opt->box.top || y > opt->box.bottom) {
 396                 candidate = -1;
 397                 goto miss;
 398         }
 399
 400         /* Ok, so now, we know the mouse hit an icon that wasn't the same
 401          * as the previous one, we trigger a focus change
 402          */
 403         pboot_set_rfocus(candidate);
 404
 405  miss:
 406         pboot_rpane->mouse_target = candidate;
 407 }
 408
 409 static void pboot_choose_option(void)
 410 {
 411         pboot_device_t *dev = pboot_devices[pboot_dev_sel];
 412         pboot_option_t *opt = &dev->options[pboot_rpane->focus_curindex];
 413
 414         LOG("Selected device %s\n", opt->title);
 415
 416         /* Give user feedback, make sure errors and panics will be seen */
 417         pboot_exec_option(opt->data);
 418 }
 419
 420 static twin_bool_t pboot_rpane_event (twin_window_t         *window,
 421                                       twin_event_t          *event)
 422 {
 423         /* filter out all mouse events */
 424         switch(event->kind) {
 425         case TwinEventEnter:
 426         case TwinEventMotion:
 427         case TwinEventLeave:
 428                 pboot_select_rpane();
 429                 pboot_rpane_mousetrack(event->u.pointer.x, event->u.pointer.y);
 430                 return TWIN_TRUE;
 431         case TwinEventButtonDown:
 432                 pboot_select_rpane();
 433                 pboot_rpane_mousetrack(event->u.pointer.x, event->u.pointer.y);
 434                 pboot_choose_option();
 435         case TwinEventButtonUp:
 436                 return TWIN_TRUE;
 437         case TwinEventKeyDown:
 438                 switch(event->u.key.key) {
 439                 case KEY_UP:
 440                         pboot_set_rfocus(pboot_rpane->focus_curindex - 1);
 441                         return TWIN_TRUE;
 442                 case KEY_DOWN:
 443                         pboot_set_rfocus(pboot_rpane->focus_curindex + 1);
 444                         return TWIN_TRUE;
 445                 case KEY_LEFT:
 446                         pboot_select_lpane();
 447                         return TWIN_TRUE;
 448                 case KEY_ENTER:
 449                         pboot_choose_option();
 450                 default:
 451                         break;
 452                 }
 453                 break;
 454         default:
 455                 break;
 456         }
 457         return TWIN_FALSE;
 458 }
 459
 460
 461 int pboot_add_option(int devindex, const char *title,
 462                      const char *subtitle, twin_pixmap_t *badge, void *data)
 463 {
 464         pboot_device_t  *dev;
 465         pboot_option_t  *opt;
 466         twin_coord_t    width;
 467         int             index;
 468
 469         if (devindex < 0 || devindex >= pboot_dev_count)
 470                 return -1;
 471         dev = pboot_devices[devindex];
 472
 473         if (dev->option_count >= PBOOT_MAX_OPTION)
 474                 return -1;
 475         index = dev->option_count++;
 476         opt = &dev->options[index];
 477
 478         opt->title = malloc(strlen(title) + 1);
 479         strcpy(opt->title, title);
 480
 481         if (subtitle) {
 482                 opt->subtitle = malloc(strlen(subtitle) + 1);
 483                 strcpy(opt->subtitle, subtitle);
 484         } else
 485                 opt->subtitle = NULL;
 486
 487         opt->badge = badge;
 488         opt->cache = NULL;
 489
 490         width = pboot_rpane->window->pixmap->width -
 491                 (PBOOT_RIGHT_OPTION_LMARGIN + PBOOT_RIGHT_OPTION_RMARGIN);
 492
 493         opt->box.left = PBOOT_RIGHT_OPTION_LMARGIN;
 494         opt->box.right = opt->box.left + width;
 495         opt->box.top = PBOOT_RIGHT_OPTION_TMARGIN +
 496                 index * PBOOT_RIGHT_OPTION_STRIDE;
 497         opt->box.bottom = opt->box.top + PBOOT_RIGHT_OPTION_HEIGHT;
 498
 499         opt->data = data;
 500         return index;
 501 }
 502
 503
 504 static void pboot_set_device_select(int sel)
 505 {
 506         LOG("%s: %d -> %d\n", __FUNCTION__, pboot_dev_sel, sel);
 507         if (sel == pboot_dev_sel || sel >= pboot_dev_count)
 508                 return;
 509         pboot_dev_sel = sel;
 510         pboot_rpane->focus_curindex = -1;
 511         pboot_rpane->mouse_target = -1;
 512         pboot_rpane->focus_box.top = -2*PBOOT_RIGHT_FOCUS_HEIGHT;
 513         pboot_rpane->focus_box.bottom = pboot_rpane->focus_box.top +
 514                 PBOOT_RIGHT_FOCUS_HEIGHT;
 515         twin_window_damage(pboot_rpane->window, 0, 0,
 516                            pboot_rpane->window->pixmap->width,
 517                            pboot_rpane->window->pixmap->height);
 518         twin_window_queue_paint(pboot_rpane->window);
 519 }
 520
 521 static twin_time_t pboot_lfocus_timeout (twin_time_t now, void *closure)
 522 {
 523         int dir = 1, dist, pos;
 524         const int accel[11] = { 7, 4, 2, 1, 1, 1, 1, 2, 3, 4, 5 };
 525
 526         dist = abs(pboot_lpane->focus_target - pboot_lpane->focus_start);
 527         pos = pboot_lpane->focus_target - (int)pboot_lpane->focus_box.top;
 528         if (pos == 0) {
 529                 pboot_set_device_select(pboot_lpane->focus_curindex);
 530                 return -1;
 531         }
 532         if (pos < 0) {
 533                 dir = -1;
 534                 pos = -pos;
 535         }
 536         twin_window_damage(pboot_lpane->window,
 537                            pboot_lpane->focus_box.left,
 538                            pboot_lpane->focus_box.top,
 539                            pboot_lpane->focus_box.right,
 540                            pboot_lpane->focus_box.bottom);
 541
 542         pboot_lpane->focus_box.top += dir;
 543         pboot_lpane->focus_box.bottom += dir;
 544
 545         twin_window_damage(pboot_lpane->window,
 546                            pboot_lpane->focus_box.left,
 547                            pboot_lpane->focus_box.top,
 548                            pboot_lpane->focus_box.right,
 549                            pboot_lpane->focus_box.bottom);
 550
 551         twin_window_queue_paint(pboot_lpane->window);
 552
 553         return accel[(pos * 10) / dist];
 554 }
 555
 556 static void pboot_set_lfocus(int index)
 557 {
 558         if (index >= pboot_dev_count)
 559                 return;
 560
 561         pboot_lpane->focus_start = pboot_lpane->focus_box.top;
 562
 563         if (index < 0)
 564                 pboot_lpane->focus_target = 0 - PBOOT_LEFT_FOCUS_HEIGHT;
 565         else
 566                 pboot_lpane->focus_target = PBOOT_LEFT_FOCUS_YOFF +
 567                         PBOOT_LEFT_ICON_STRIDE * index;
 568
 569         pboot_lpane->focus_curindex = index;
 570
 571         twin_set_timeout(pboot_lfocus_timeout, 0, NULL);
 572 }
 573
 574 static void pboot_lpane_mousetrack(twin_coord_t x, twin_coord_t y)
 575 {
 576         int candidate = -1;
 577         twin_coord_t icon_top;
 578
 579         if (x < PBOOT_LEFT_ICON_XOFF ||
 580             x > (PBOOT_LEFT_ICON_XOFF + PBOOT_LEFT_ICON_WIDTH))
 581                 goto miss;
 582         if (y < PBOOT_LEFT_ICON_YOFF)
 583                 goto miss;
 584         candidate = (y - PBOOT_LEFT_ICON_YOFF) / PBOOT_LEFT_ICON_STRIDE;
 585         if (candidate >= pboot_dev_count) {
 586                 candidate = -1;
 587                 goto miss;
 588         }
 589         if (candidate == pboot_lpane->mouse_target)
 590                 return;
 591         icon_top = PBOOT_LEFT_ICON_YOFF +
 592                 candidate * PBOOT_LEFT_ICON_STRIDE;
 593         if (y > (icon_top + PBOOT_LEFT_ICON_HEIGHT)) {
 594                 candidate = -1;
 595                 goto miss;
 596         }
 597
 598         /* Ok, so now, we know the mouse hit an icon that wasn't the same
 599          * as the previous one, we trigger a focus change
 600          */
 601         pboot_set_lfocus(candidate);
 602
 603  miss:
 604         pboot_lpane->mouse_target = candidate;
 605 }
 606
 607 static twin_bool_t pboot_lpane_event (twin_window_t         *window,
 608                                       twin_event_t          *event)
 609 {
 610         /* filter out all mouse events */
 611         switch(event->kind) {
 612         case TwinEventEnter:
 613         case TwinEventMotion:
 614         case TwinEventLeave:
 615                 pboot_select_lpane();
 616                 pboot_lpane_mousetrack(event->u.pointer.x, event->u.pointer.y);
 617                 return TWIN_TRUE;
 618         case TwinEventButtonDown:
 619         case TwinEventButtonUp:
 620                 return TWIN_TRUE;
 621         case TwinEventKeyDown:
 622                 switch(event->u.key.key) {
 623                 case KEY_UP:
 624                         if (pboot_lpane->focus_curindex > 0)
 625                                 pboot_set_lfocus(
 626                                         pboot_lpane->focus_curindex - 1);
 627                         return TWIN_TRUE;
 628                 case KEY_DOWN:
 629                         pboot_set_lfocus(pboot_lpane->focus_curindex + 1);
 630                         return TWIN_TRUE;
 631                 case KEY_RIGHT:
 632                         pboot_select_rpane();
 633                         return TWIN_TRUE;
 634                 default:
 635                         break;
 636                 }
 637                 break;
 638         default:
 639                 break;
 640         }
 641         return TWIN_FALSE;
 642 }
 643
 644 twin_bool_t pboot_event_filter(twin_screen_t        *screen,
 645                                twin_event_t         *event)
 646 {
 647         switch(event->kind) {
 648         case TwinEventEnter:
 649         case TwinEventMotion:
 650         case TwinEventLeave:
 651         case TwinEventButtonDown:
 652         case TwinEventButtonUp:
 653                 if (pboot_cursor != NULL)
 654                         twin_screen_set_cursor(pboot_screen, pboot_cursor,
 655                                                pboot_cursor_hx,
 656                                                pboot_cursor_hy);
 657                 break;
 658         case TwinEventKeyDown:
 659         case TwinEventKeyUp:
 660                 twin_screen_set_cursor(pboot_screen, NULL, 0, 0);
 661                 break;
 662         default:
 663                 break;
 664         }
 665         return TWIN_FALSE;
 666 }
 667
 668 static void pboot_lpane_draw(twin_window_t *window)
 669 {
 670         twin_pixmap_t   *px = window->pixmap;
 671         pboot_lpane_t   *lpane = window->client_data;
 672         twin_path_t     *path;
 673         twin_fixed_t    x, y, w, h;
 674         int             i;
 675
 676         /* Fill background */
 677         twin_fill(px, PBOOT_LEFT_PANE_COLOR, TWIN_SOURCE,
 678                   0, 0, px->width, px->height);
 679
 680         /* Create a path for use later */
 681         path = twin_path_create();
 682         assert(path);
 683
 684         /* Draw right line if needed */
 685         if (px->clip.right > (PBOOT_LEFT_PANE_SIZE - 4)) {
 686                 x = twin_int_to_fixed(PBOOT_LEFT_PANE_SIZE - 4);
 687                 y = twin_int_to_fixed(px->height);
 688                 twin_path_rectangle(path, x, 0, 0x40000, y);
 689                 twin_paint_path(px, PBOOT_LEFT_LINE_COLOR, path);
 690                 twin_path_empty(path);
 691         }
 692
 693         /* Draw focus box */
 694         if (lpane->focus_curindex >= 0 &&
 695             twin_rect_intersect(lpane->focus_box, px->clip)) {
 696                 x = twin_int_to_fixed(lpane->focus_box.left + 2);
 697                 y = twin_int_to_fixed(lpane->focus_box.top + 2);
 698                 w = twin_int_to_fixed(lpane->focus_box.right -
 699                                       lpane->focus_box.left - 4);
 700                 h = twin_int_to_fixed(lpane->focus_box.bottom -
 701                                       lpane->focus_box.top - 4);
 702                 twin_path_rounded_rectangle(path, x, y, w, h,
 703                                             PBOOT_LEFT_FOCUS_XRAD,
 704                                             PBOOT_LEFT_FOCUS_YRAD);
 705                 if (pboot_focus_lpane)
 706                         twin_paint_path(px, PBOOT_FOCUS_COLOR, path);
 707                 else
 708                         twin_paint_stroke(px, PBOOT_FOCUS_COLOR, path,
 709                                           4 * TWIN_FIXED_ONE);
 710         }
 711
 712         /* Draw icons */
 713         for (i = 0; i < pboot_dev_count; i++) {
 714                 pboot_device_t  *dev = pboot_devices[i];
 715                 twin_operand_t  src;
 716
 717                 if (!twin_rect_intersect(dev->box, px->clip))
 718                         continue;
 719
 720                 src.source_kind = TWIN_PIXMAP;
 721                 src.u.pixmap = dev->badge;
 722
 723                 twin_composite(px, dev->box.left, dev->box.top,
 724                                &src, 0, 0, NULL, 0, 0, TWIN_OVER,
 725                                dev->box.right - dev->box.left,
 726                                dev->box.bottom - dev->box.top);
 727
 728         }
 729
 730         /* Destroy path */
 731         twin_path_destroy(path);
 732 }
 733
 734 static void pboot_create_panels(void)
 735 {
 736         /* left pane */
 737         pboot_lpane = calloc(1, sizeof(pboot_lpane_t));
 738         assert(pboot_lpane);
 739
 740         pboot_lpane->window = twin_window_create(pboot_screen, TWIN_ARGB32,
 741                                                  TwinWindowPlain,
 742                                                  0, 0, PBOOT_LEFT_PANE_SIZE,
 743                                                  pboot_screen->height);
 744         assert(pboot_lpane->window);
 745
 746         pboot_lpane->window->draw = pboot_lpane_draw;
 747         pboot_lpane->window->event = pboot_lpane_event;
 748         pboot_lpane->window->client_data = pboot_lpane;
 749         pboot_lpane->focus_curindex = -1;
 750         pboot_lpane->focus_box.left = PBOOT_LEFT_FOCUS_XOFF;
 751         pboot_lpane->focus_box.top = -2*PBOOT_LEFT_FOCUS_HEIGHT;
 752         pboot_lpane->focus_box.right = pboot_lpane->focus_box.left +
 753                 PBOOT_LEFT_FOCUS_WIDTH;
 754         pboot_lpane->focus_box.bottom = pboot_lpane->focus_box.top +
 755                 PBOOT_LEFT_FOCUS_HEIGHT;
 756         pboot_lpane->mouse_target = -1;
 757         twin_window_show(pboot_lpane->window);
 758
 759         /* right pane */
 760         pboot_rpane = calloc(1, sizeof(pboot_rpane_t));
 761         assert(pboot_rpane);
 762
 763         pboot_rpane->window = twin_window_create(pboot_screen, TWIN_ARGB32,
 764                                                  TwinWindowPlain,
 765                                                  PBOOT_LEFT_PANE_SIZE, 0,
 766                                                  pboot_screen->width -
 767                                                    PBOOT_LEFT_PANE_SIZE,
 768                                                  pboot_screen->height);
 769         assert(pboot_rpane->window);
 770
 771         pboot_rpane->window->draw = pboot_rpane_draw;
 772         pboot_rpane->window->event = pboot_rpane_event;
 773         pboot_rpane->window->client_data = pboot_rpane;
 774
 775         pboot_rpane->focus_curindex = -1;
 776         pboot_rpane->focus_box.left = PBOOT_RIGHT_FOCUS_XOFF;
 777         pboot_rpane->focus_box.top = -2*PBOOT_RIGHT_FOCUS_HEIGHT;
 778         pboot_rpane->focus_box.right = pboot_rpane->window->pixmap->width -
 779                 2 * PBOOT_RIGHT_FOCUS_XOFF;
 780         pboot_rpane->focus_box.bottom = pboot_rpane->focus_box.top +
 781                 PBOOT_RIGHT_FOCUS_HEIGHT;
 782         pboot_rpane->mouse_target = -1;
 783         twin_window_show(pboot_rpane->window);
 784 }
 785
 786 int pboot_add_device(const char *dev_id, const char *name,
 787                 twin_pixmap_t *pixmap)
 788 {
 789         int             index;
 790         pboot_device_t  *dev;
 791
 792         if (pboot_dev_count >= PBOOT_MAX_DEV)
 793                 return -1;
 794
 795         index = pboot_dev_count++;
 796
 797         dev = malloc(sizeof(*dev));
 798         memset(dev, 0, sizeof(*dev));
 799         dev->id = malloc(strlen(dev_id) + 1);
 800         strcpy(dev->id, dev_id);
 801         dev->badge = pixmap;
 802         dev->box.left = PBOOT_LEFT_ICON_XOFF;
 803         dev->box.right = dev->box.left + PBOOT_LEFT_ICON_WIDTH;
 804         dev->box.top = PBOOT_LEFT_ICON_YOFF +
 805                 PBOOT_LEFT_ICON_STRIDE * index;
 806         dev->box.bottom = dev->box.top + PBOOT_LEFT_ICON_HEIGHT;
 807
 808         pboot_devices[index] = dev;
 809
 810         twin_window_damage(pboot_lpane->window,
 811                            dev->box.left, dev->box.top,
 812                            dev->box.right, dev->box.bottom);
 813         twin_window_queue_paint(pboot_lpane->window);
 814
 815         return index;
 816 }
 817
 818 int pboot_remove_device(const char *dev_id)
 819 {
 820         int             i, new_dev_index;
 821         pboot_device_t  *dev = NULL;
 822
 823         /* find the matching device */
 824         for (i = 0; i < pboot_dev_count; i++) {
 825                 if (!strcmp(pboot_devices[i]->id, dev_id)) {
 826                         dev = pboot_devices[i];
 827                         break;
 828                 }
 829         }
 830
 831         if (!dev)
 832                 return TWIN_FALSE;
 833
 834         /* select the newly-focussed device */
 835         if (i == pboot_dev_count - 1)
 836                 new_dev_index = i - 1;
 837         else
 838                 new_dev_index = i + 1;
 839
 840         memmove(pboot_devices + i, pboot_devices + i + 1,
 841                         sizeof(*pboot_devices) * (pboot_dev_count + i - 1));
 842
 843         pboot_devices[--pboot_dev_count] = NULL;
 844
 845         pboot_set_device_select(new_dev_index);
 846         twin_window_damage(pboot_lpane->window,
 847                            dev->box.left, dev->box.top,
 848                            dev->box.right, dev->box.bottom);
 849         twin_window_queue_paint(pboot_lpane->window);
 850
 851         /* todo: free device & options */
 852
 853         return TWIN_TRUE;
 854 }
 855
 856 static void exitfunc(void)
 857 {
 858 #ifndef _USE_X11
 859         if (pboot_fbdev)
 860                 twin_fbdev_destroy(pboot_fbdev);
 861         pboot_fbdev = NULL;
 862 #endif
 863 }
 864
 865 static void sigint(int sig)
 866 {
 867         exitfunc();
 868         syscall(__NR_exit);
 869 }
 870
 871 int main(int argc, char **argv)
 872 {
 873         twin_pixmap_t *pic;
 874         const char *background_path;
 875
 876         atexit(exitfunc);
 877         signal(SIGINT, sigint);
 878
 879 #ifdef _USE_X11
 880         pboot_x11 = twin_x11_create(XOpenDisplay(0), 1024, 768);
 881         if (pboot_x11 == NULL) {
 882                 perror("failed to create x11 screen !\n");
 883                 return 1;
 884         }
 885         pboot_screen = pboot_x11->screen;
 886 #else
 887         /* Create screen and mouse drivers */
 888         pboot_fbdev = twin_fbdev_create(-1, SIGUSR1);
 889         if (pboot_fbdev == NULL) {
 890                 perror("failed to create fbdev screen !\n");
 891                 return 1;
 892         }
 893         pboot_screen = pboot_fbdev->screen;
 894         twin_linux_mouse_create(NULL, pboot_screen);
 895
 896         if (pboot_fbdev != NULL) {
 897                 char *cursor_path = artwork_pathname("cursor");
 898                 pboot_cursor = twin_load_X_cursor(cursor_path, 2,
 899                                                   &pboot_cursor_hx,
 900                                                   &pboot_cursor_hy);
 901                 if (pboot_cursor == NULL)
 902                         pboot_cursor =
 903                                 twin_get_default_cursor(&pboot_cursor_hx,
 904                                                         &pboot_cursor_hy);
 905         }
 906 #endif
 907
 908         /* Set background pixmap */
 909         background_path = artwork_pathname("background.png");
 910         LOG("loading background: %s...", background_path);
 911         pic = twin_png_to_pixmap(background_path, TWIN_ARGB32);
 912         LOG("%s\n", pic ? "ok" : "failed");
 913         if (pic)
 914                 twin_screen_set_background(pboot_screen, pic);
 915
 916         /* Init more stuffs */
 917         pboot_create_panels();
 918         twin_window_queue_paint(pboot_lpane->window);
 919         twin_window_queue_paint(pboot_rpane->window);
 920
 921         if (!pboot_start_device_discovery()) {
 922                 LOG("Couldn't start device discovery!\n");
 923                 return 1;
 924         }
 925
 926         pboot_set_lfocus(0);
 927         twin_screen_set_active(pboot_screen, pboot_lpane->window->pixmap);
 928         pboot_screen->event_filter = pboot_event_filter;
 929
 930         /* Console switch */
 931 #ifndef _USE_X11
 932         if (pboot_fbdev)
 933                 twin_fbdev_activate(pboot_fbdev);
 934 #endif
 935
 936         /* Process events */
 937         twin_dispatch ();
 938
 939         return 0;
 940 }