Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/uidemo/uidemo.c

    ref4d684 rdb3895d  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2021 Jiri Svoboda
    33 * All rights reserved.
    44 *
     
    4040#include <str.h>
    4141#include <ui/entry.h>
    42 #include <ui/filedialog.h>
    4342#include <ui/fixed.h>
    4443#include <ui/image.h>
    4544#include <ui/label.h>
    46 #include <ui/list.h>
     45#include <ui/menubar.h>
     46#include <ui/menuentry.h>
    4747#include <ui/menu.h>
    48 #include <ui/menubar.h>
    49 #include <ui/menudd.h>
    50 #include <ui/menuentry.h>
    5148#include <ui/msgdialog.h>
    5249#include <ui/pbutton.h>
    53 #include <ui/promptdialog.h>
    5450#include <ui/resource.h>
    55 #include <ui/selectdialog.h>
    56 #include <ui/tab.h>
    57 #include <ui/tabset.h>
    5851#include <ui/ui.h>
    5952#include <ui/window.h>
     
    9285};
    9386
    94 static void scrollbar_up(ui_scrollbar_t *, void *);
    95 static void scrollbar_down(ui_scrollbar_t *, void *);
    96 static void scrollbar_page_up(ui_scrollbar_t *, void *);
    97 static void scrollbar_page_down(ui_scrollbar_t *, void *);
    98 static void scrollbar_moved(ui_scrollbar_t *, void *, gfx_coord_t);
    99 
    100 static ui_scrollbar_cb_t scrollbar_cb = {
    101         .up = scrollbar_up,
    102         .down = scrollbar_down,
    103         .page_up = scrollbar_page_up,
    104         .page_down = scrollbar_page_down,
    105         .moved = scrollbar_moved
    106 };
    107 
    108 static void uidemo_file_load(ui_menu_entry_t *, void *);
    10987static void uidemo_file_message(ui_menu_entry_t *, void *);
    11088static void uidemo_file_exit(ui_menu_entry_t *, void *);
    111 static void uidemo_edit_modify(ui_menu_entry_t *, void *);
    112 static void uidemo_edit_insert_character(ui_menu_entry_t *, void *);
    113 
    114 static void file_dialog_bok(ui_file_dialog_t *, void *, const char *);
    115 static void file_dialog_bcancel(ui_file_dialog_t *, void *);
    116 static void file_dialog_close(ui_file_dialog_t *, void *);
    117 
    118 static ui_file_dialog_cb_t file_dialog_cb = {
    119         .bok = file_dialog_bok,
    120         .bcancel = file_dialog_bcancel,
    121         .close = file_dialog_close
    122 };
    123 
    124 static void prompt_dialog_bok(ui_prompt_dialog_t *, void *, const char *);
    125 static void prompt_dialog_bcancel(ui_prompt_dialog_t *, void *);
    126 static void prompt_dialog_close(ui_prompt_dialog_t *, void *);
    127 
    128 static ui_prompt_dialog_cb_t prompt_dialog_cb = {
    129         .bok = prompt_dialog_bok,
    130         .bcancel = prompt_dialog_bcancel,
    131         .close = prompt_dialog_close
    132 };
    133 
    134 static void select_dialog_bok(ui_select_dialog_t *, void *, void *);
    135 static void select_dialog_bcancel(ui_select_dialog_t *, void *);
    136 static void select_dialog_close(ui_select_dialog_t *, void *);
    137 
    138 static ui_select_dialog_cb_t select_dialog_cb = {
    139         .bok = select_dialog_bok,
    140         .bcancel = select_dialog_bcancel,
    141         .close = select_dialog_close
    142 };
    14389
    14490static void msg_dialog_button(ui_msg_dialog_t *, void *, unsigned);
     
    15096};
    15197
    152 /** Horizontal alignment selected by each radio button */
    153 static const gfx_halign_t uidemo_halign[3] = {
    154         gfx_halign_left,
    155         gfx_halign_center,
    156         gfx_halign_right
    157 };
    158 
    15998/** Window close button was clicked.
    16099 *
     
    183122                if (rc != EOK)
    184123                        printf("Error changing entry text.\n");
     124                (void) ui_entry_paint(demo->entry);
    185125        } else {
    186126                rc = ui_entry_set_text(demo->entry, "Cancel pressed");
    187127                if (rc != EOK)
    188128                        printf("Error changing entry text.\n");
     129                (void) ui_entry_paint(demo->entry);
    189130        }
    190131}
     
    198139{
    199140        ui_demo_t *demo = (ui_demo_t *) arg;
    200 
    201         ui_entry_set_read_only(demo->entry, enable);
     141        errno_t rc;
     142
     143        if (enable) {
     144                rc = ui_entry_set_text(demo->entry, "Checked");
     145                if (rc != EOK)
     146                        printf("Error changing entry text.\n");
     147                (void) ui_entry_paint(demo->entry);
     148        } else {
     149                rc = ui_entry_set_text(demo->entry, "Unchecked");
     150                if (rc != EOK)
     151                        printf("Error changing entry text.\n");
     152                (void) ui_entry_paint(demo->entry);
     153        }
    202154}
    203155
     
    211163{
    212164        ui_demo_t *demo = (ui_demo_t *) garg;
    213         gfx_halign_t halign = *(gfx_halign_t *) barg;
    214 
    215         ui_entry_set_halign(demo->entry, halign);
     165        const char *text = (const char *) barg;
     166        errno_t rc;
     167
     168        rc = ui_entry_set_text(demo->entry, text);
     169        if (rc != EOK)
     170                printf("Error changing entry text.\n");
    216171        (void) ui_entry_paint(demo->entry);
    217172}
     
    245200}
    246201
    247 /** Scrollbar up button pressed.
    248  *
    249  * @param scrollbar Scrollbar
    250  * @param arg Argument (demo)
    251  */
    252 static void scrollbar_up(ui_scrollbar_t *scrollbar, void *arg)
    253 {
    254         gfx_coord_t pos;
    255 
    256         pos = ui_scrollbar_get_pos(scrollbar);
    257         ui_scrollbar_set_pos(scrollbar, pos - 1);
    258 
    259         pos = ui_scrollbar_get_pos(scrollbar);
    260         scrollbar_moved(scrollbar, arg, pos);
    261 }
    262 
    263 /** Scrollbar down button pressed.
    264  *
    265  * @param scrollbar Scrollbar
    266  * @param arg Argument (demo)
    267  */
    268 static void scrollbar_down(ui_scrollbar_t *scrollbar, void *arg)
    269 {
    270         gfx_coord_t pos;
    271 
    272         pos = ui_scrollbar_get_pos(scrollbar);
    273         ui_scrollbar_set_pos(scrollbar, pos + 1);
    274 
    275         pos = ui_scrollbar_get_pos(scrollbar);
    276         scrollbar_moved(scrollbar, arg, pos);
    277 }
    278 
    279 /** Scrollbar page up event.
    280  *
    281  * @param scrollbar Scrollbar
    282  * @param arg Argument (demo)
    283  */
    284 static void scrollbar_page_up(ui_scrollbar_t *scrollbar, void *arg)
    285 {
    286         gfx_coord_t pos;
    287 
    288         pos = ui_scrollbar_get_pos(scrollbar);
    289         ui_scrollbar_set_pos(scrollbar, pos -
    290             ui_scrollbar_trough_length(scrollbar) / 4);
    291 
    292         pos = ui_scrollbar_get_pos(scrollbar);
    293         scrollbar_moved(scrollbar, arg, pos);
    294 }
    295 
    296 /** Scrollbar page down event.
    297  *
    298  * @param scrollbar Scrollbar
    299  * @param arg Argument (demo)
    300  */
    301 static void scrollbar_page_down(ui_scrollbar_t *scrollbar, void *arg)
    302 {
    303         gfx_coord_t pos;
    304 
    305         pos = ui_scrollbar_get_pos(scrollbar);
    306         ui_scrollbar_set_pos(scrollbar, pos +
    307             ui_scrollbar_trough_length(scrollbar) / 4);
    308 
    309         pos = ui_scrollbar_get_pos(scrollbar);
    310         scrollbar_moved(scrollbar, arg, pos);
    311 }
    312 
    313 /** Scrollbar was moved.
    314  *
    315  * @param scrollbar Scrollbar
    316  * @param arg Argument (demo)
    317  * @param pos Position
    318  */
    319 static void scrollbar_moved(ui_scrollbar_t *scrollbar, void *arg,
    320     gfx_coord_t pos)
    321 {
    322         ui_demo_t *demo = (ui_demo_t *) arg;
    323         char *str;
    324         errno_t rc;
    325         int rv;
    326 
    327         rv = asprintf(&str, "Scrollbar: %d of %d", (int) pos,
    328             ui_scrollbar_move_length(scrollbar));
    329         if (rv < 0) {
    330                 printf("Out of memory.\n");
    331                 return;
    332         }
    333 
    334         rc = ui_entry_set_text(demo->entry, str);
    335         if (rc != EOK)
    336                 printf("Error changing entry text.\n");
    337         (void) ui_entry_paint(demo->entry);
    338 
    339         free(str);
    340 }
    341 
    342 /** Display a message window.
    343  *
    344  * @param demo UI demo
    345  * @param caption Window caption
    346  * @param text Message text
    347  */
    348 static void uidemo_show_message(ui_demo_t *demo, const char *caption,
    349     const char *text)
    350 {
    351         ui_msg_dialog_params_t mdparams;
    352         ui_msg_dialog_t *dialog;
    353         errno_t rc;
    354 
    355         ui_msg_dialog_params_init(&mdparams);
    356         mdparams.caption = caption;
    357         mdparams.text = text;
    358 
    359         rc = ui_msg_dialog_create(demo->ui, &mdparams, &dialog);
    360         if (rc != EOK) {
    361                 printf("Error creating message dialog.\n");
    362                 return;
    363         }
    364 
    365         ui_msg_dialog_set_cb(dialog, &msg_dialog_cb, &demo);
    366 }
    367 
    368 /** File / Load menu entry selected.
    369  *
    370  * @param mentry Menu entry
    371  * @param arg Argument (demo)
    372  */
    373 static void uidemo_file_load(ui_menu_entry_t *mentry, void *arg)
    374 {
    375         ui_demo_t *demo = (ui_demo_t *) arg;
    376         ui_file_dialog_params_t fdparams;
    377         ui_file_dialog_t *dialog;
    378         errno_t rc;
    379 
    380         ui_file_dialog_params_init(&fdparams);
    381         fdparams.caption = "Load File";
    382 
    383         rc = ui_file_dialog_create(demo->ui, &fdparams, &dialog);
    384         if (rc != EOK) {
    385                 printf("Error creating message dialog.\n");
    386                 return;
    387         }
    388 
    389         ui_file_dialog_set_cb(dialog, &file_dialog_cb, demo);
    390 }
    391 
    392 /** File / Message menu entry selected.
     202/** File/message menu entry selected.
    393203 *
    394204 * @param mentry Menu entry
     
    413223
    414224        ui_msg_dialog_set_cb(dialog, &msg_dialog_cb, &demo);
    415 }
    416 
    417 /** File / Exit menu entry selected.
     225
     226}
     227
     228/** File/exit menu entry selected.
    418229 *
    419230 * @param mentry Menu entry
     
    425236
    426237        ui_quit(demo->ui);
    427 }
    428 
    429 /** Edit / Modify menu entry selected.
    430  *
    431  * @param mentry Menu entry
    432  * @param arg Argument (demo)
    433  */
    434 static void uidemo_edit_modify(ui_menu_entry_t *mentry, void *arg)
    435 {
    436         ui_demo_t *demo = (ui_demo_t *) arg;
    437         ui_prompt_dialog_params_t pdparams;
    438         ui_prompt_dialog_t *dialog;
    439         errno_t rc;
    440 
    441         ui_prompt_dialog_params_init(&pdparams);
    442         pdparams.caption = "Modify Entry Text";
    443         pdparams.prompt = "Enter New Text";
    444 
    445         rc = ui_prompt_dialog_create(demo->ui, &pdparams, &dialog);
    446         if (rc != EOK) {
    447                 printf("Error creating prompt dialog.\n");
    448                 return;
    449         }
    450 
    451         ui_prompt_dialog_set_cb(dialog, &prompt_dialog_cb, demo);
    452 }
    453 
    454 /** Edit / Insert Character menu entry selected.
    455  *
    456  * @param mentry Menu entry
    457  * @param arg Argument (demo)
    458  */
    459 static void uidemo_edit_insert_character(ui_menu_entry_t *mentry, void *arg)
    460 {
    461         ui_demo_t *demo = (ui_demo_t *) arg;
    462         ui_select_dialog_params_t sdparams;
    463         ui_select_dialog_t *dialog;
    464         ui_list_entry_attr_t attr;
    465         errno_t rc;
    466 
    467         ui_select_dialog_params_init(&sdparams);
    468         sdparams.caption = "Insert Character";
    469         sdparams.prompt = "Select character to insert";
    470 
    471         rc = ui_select_dialog_create(demo->ui, &sdparams, &dialog);
    472         if (rc != EOK) {
    473                 printf("Error creating select dialog.\n");
    474                 return;
    475         }
    476 
    477         ui_list_entry_attr_init(&attr);
    478         attr.caption = "Dollar sign ($)";
    479         attr.arg = (void *)'$';
    480         rc = ui_select_dialog_append(dialog, &attr);
    481         if (rc != EOK) {
    482                 printf("Error appending entry to list.\n");
    483                 return;
    484         }
    485 
    486         ui_list_entry_attr_init(&attr);
    487         attr.caption = "Hash sign (#)";
    488         attr.arg = (void *)'#';
    489         rc = ui_select_dialog_append(dialog, &attr);
    490         if (rc != EOK) {
    491                 printf("Error appending entry to list.\n");
    492                 return;
    493         }
    494 
    495         ui_list_entry_attr_init(&attr);
    496         attr.caption = "Question mark (?)";
    497         attr.arg = (void *)'?';
    498         rc = ui_select_dialog_append(dialog, &attr);
    499         if (rc != EOK) {
    500                 printf("Error appending entry to list.\n");
    501                 return;
    502         }
    503 
    504         ui_select_dialog_set_cb(dialog, &select_dialog_cb, demo);
    505 
    506         (void) ui_select_dialog_paint(dialog);
    507 }
    508 
    509 /** File dialog OK button press.
    510  *
    511  * @param dialog File dialog
    512  * @param arg Argument (ui_demo_t *)
    513  * @param fname File name
    514  */
    515 static void file_dialog_bok(ui_file_dialog_t *dialog, void *arg,
    516     const char *fname)
    517 {
    518         ui_demo_t *demo = (ui_demo_t *) arg;
    519         char buf[128];
    520         char *p;
    521         FILE *f;
    522 
    523         ui_file_dialog_destroy(dialog);
    524 
    525         f = fopen(fname, "rt");
    526         if (f == NULL) {
    527                 uidemo_show_message(demo, "Error", "Error opening file.");
    528                 return;
    529         }
    530 
    531         p = fgets(buf, sizeof(buf), f);
    532         if (p == NULL) {
    533                 uidemo_show_message(demo, "Error", "Error reading file.");
    534                 fclose(f);
    535                 return;
    536         }
    537 
    538         /* Cut string off at the first non-printable character */
    539         p = buf;
    540         while (*p != '\0') {
    541                 if (*p < ' ') {
    542                         *p = '\0';
    543                         break;
    544                 }
    545                 ++p;
    546         }
    547 
    548         ui_entry_set_text(demo->entry, buf);
    549         fclose(f);
    550 }
    551 
    552 /** File dialog cancel button press.
    553  *
    554  * @param dialog File dialog
    555  * @param arg Argument (ui_demo_t *)
    556  */
    557 static void file_dialog_bcancel(ui_file_dialog_t *dialog, void *arg)
    558 {
    559         ui_demo_t *demo = (ui_demo_t *) arg;
    560 
    561         (void) demo;
    562         ui_file_dialog_destroy(dialog);
    563 }
    564 
    565 /** File dialog close request.
    566  *
    567  * @param dialog File dialog
    568  * @param arg Argument (ui_demo_t *)
    569  */
    570 static void file_dialog_close(ui_file_dialog_t *dialog, void *arg)
    571 {
    572         ui_demo_t *demo = (ui_demo_t *) arg;
    573 
    574         (void) demo;
    575         ui_file_dialog_destroy(dialog);
    576 }
    577 
    578 /** Prompt dialog OK button press.
    579  *
    580  * @param dialog Prompt dialog
    581  * @param arg Argument (ui_demo_t *)
    582  * @param text Submitted text
    583  */
    584 static void prompt_dialog_bok(ui_prompt_dialog_t *dialog, void *arg,
    585     const char *text)
    586 {
    587         ui_demo_t *demo = (ui_demo_t *) arg;
    588 
    589         ui_prompt_dialog_destroy(dialog);
    590         ui_entry_set_text(demo->entry, text);
    591 }
    592 
    593 /** Prompt dialog cancel button press.
    594  *
    595  * @param dialog Prompt dialog
    596  * @param arg Argument (ui_demo_t *)
    597  */
    598 static void prompt_dialog_bcancel(ui_prompt_dialog_t *dialog, void *arg)
    599 {
    600         ui_demo_t *demo = (ui_demo_t *) arg;
    601 
    602         (void) demo;
    603         ui_prompt_dialog_destroy(dialog);
    604 }
    605 
    606 /** Prompt dialog close request.
    607  *
    608  * @param dialog Prompt dialog
    609  * @param arg Argument (ui_demo_t *)
    610  */
    611 static void prompt_dialog_close(ui_prompt_dialog_t *dialog, void *arg)
    612 {
    613         ui_demo_t *demo = (ui_demo_t *) arg;
    614 
    615         (void) demo;
    616         ui_prompt_dialog_destroy(dialog);
    617 }
    618 
    619 /** Select dialog OK button press.
    620  *
    621  * @param dialog Select dialog
    622  * @param arg Argument (ui_demo_t *)
    623  * @param text Submitted text
    624  */
    625 static void select_dialog_bok(ui_select_dialog_t *dialog, void *arg,
    626     void *earg)
    627 {
    628         ui_demo_t *demo = (ui_demo_t *) arg;
    629         char str[2];
    630 
    631         ui_select_dialog_destroy(dialog);
    632         str[0] = (char)(intptr_t)earg;
    633         str[1] = '\0';
    634         (void) ui_entry_insert_str(demo->entry, str);
    635 }
    636 
    637 /** Select dialog cancel button press.
    638  *
    639  * @param dialog Select dialog
    640  * @param arg Argument (ui_demo_t *)
    641  */
    642 static void select_dialog_bcancel(ui_select_dialog_t *dialog, void *arg)
    643 {
    644         ui_demo_t *demo = (ui_demo_t *) arg;
    645 
    646         (void) demo;
    647         ui_select_dialog_destroy(dialog);
    648 }
    649 
    650 /** Select dialog close request.
    651  *
    652  * @param dialog Select dialog
    653  * @param arg Argument (ui_demo_t *)
    654  */
    655 static void select_dialog_close(ui_select_dialog_t *dialog, void *arg)
    656 {
    657         ui_demo_t *demo = (ui_demo_t *) arg;
    658 
    659         (void) demo;
    660         ui_select_dialog_destroy(dialog);
    661238}
    662239
     
    703280        gfx_coord2_t off;
    704281        ui_menu_entry_t *mmsg;
    705         ui_menu_entry_t *mload;
    706282        ui_menu_entry_t *mfoo;
    707283        ui_menu_entry_t *mbar;
    708284        ui_menu_entry_t *mfoobar;
    709         ui_menu_entry_t *msep;
    710285        ui_menu_entry_t *mexit;
    711         ui_menu_entry_t *mmodify;
    712         ui_menu_entry_t *minsert_char;
    713286        ui_menu_entry_t *mabout;
    714         ui_list_entry_attr_t eattr;
    715287        errno_t rc;
    716288
     
    726298        ui_wnd_params_init(&params);
    727299        params.caption = "UI Demo";
    728         params.style |= ui_wds_maximize_btn | ui_wds_resizable;
     300        params.style |= ui_wds_resizable;
    729301
    730302        /* FIXME: Auto layout */
     
    732304                params.rect.p0.x = 0;
    733305                params.rect.p0.y = 0;
    734                 params.rect.p1.x = 46;
     306                params.rect.p1.x = 80;
    735307                params.rect.p1.y = 25;
    736308        } else {
    737309                params.rect.p0.x = 0;
    738310                params.rect.p0.y = 0;
    739                 params.rect.p1.x = 255;
    740                 params.rect.p1.y = 410;
     311                params.rect.p1.x = 220;
     312                params.rect.p1.y = 350;
    741313        }
    742314
     
    765337        }
    766338
    767         rc = ui_menu_dd_create(demo.mbar, "~F~ile", NULL, &demo.mfile);
    768         if (rc != EOK) {
    769                 printf("Error creating menu.\n");
    770                 return rc;
    771         }
    772 
    773         rc = ui_menu_entry_create(demo.mfile, "~M~essage", "", &mmsg);
     339        rc = ui_menu_create(demo.mbar, "File", &demo.mfile);
     340        if (rc != EOK) {
     341                printf("Error creating menu.\n");
     342                return rc;
     343        }
     344
     345        rc = ui_menu_entry_create(demo.mfile, "Message", "", &mmsg);
    774346        if (rc != EOK) {
    775347                printf("Error creating menu.\n");
     
    779351        ui_menu_entry_set_cb(mmsg, uidemo_file_message, (void *) &demo);
    780352
    781         rc = ui_menu_entry_create(demo.mfile, "~L~oad", "", &mload);
    782         if (rc != EOK) {
    783                 printf("Error creating menu.\n");
    784                 return rc;
    785         }
    786 
    787         ui_menu_entry_set_cb(mload, uidemo_file_load, (void *) &demo);
    788 
    789         rc = ui_menu_entry_create(demo.mfile, "~F~oo", "Ctrl-Alt-Del", &mfoo);
    790         if (rc != EOK) {
    791                 printf("Error creating menu.\n");
    792                 return rc;
    793         }
    794 
    795         rc = ui_menu_entry_create(demo.mfile, "~B~ar", "", &mbar);
    796         if (rc != EOK) {
    797                 printf("Error creating menu.\n");
    798                 return rc;
    799         }
    800 
    801         rc = ui_menu_entry_create(demo.mfile, "F~o~obar", "", &mfoobar);
    802         if (rc != EOK) {
    803                 printf("Error creating menu.\n");
    804                 return rc;
    805         }
    806 
    807         ui_menu_entry_set_disabled(mfoobar, true);
    808 
    809         rc = ui_menu_entry_sep_create(demo.mfile, &msep);
    810         if (rc != EOK) {
    811                 printf("Error creating menu.\n");
    812                 return rc;
    813         }
    814 
    815         rc = ui_menu_entry_create(demo.mfile, "E~x~it", "Alt-F4", &mexit);
     353        rc = ui_menu_entry_create(demo.mfile, "Foo", "Ctrl-Alt-Del", &mfoo);
     354        if (rc != EOK) {
     355                printf("Error creating menu.\n");
     356                return rc;
     357        }
     358
     359        rc = ui_menu_entry_create(demo.mfile, "Bar", "", &mbar);
     360        if (rc != EOK) {
     361                printf("Error creating menu.\n");
     362                return rc;
     363        }
     364
     365        rc = ui_menu_entry_create(demo.mfile, "Foobar", "", &mfoobar);
     366        if (rc != EOK) {
     367                printf("Error creating menu.\n");
     368                return rc;
     369        }
     370
     371        rc = ui_menu_entry_sep_create(demo.mfile, &mexit);
     372        if (rc != EOK) {
     373                printf("Error creating menu.\n");
     374                return rc;
     375        }
     376
     377        rc = ui_menu_entry_create(demo.mfile, "Exit", "Alt-F4", &mexit);
    816378        if (rc != EOK) {
    817379                printf("Error creating menu.\n");
     
    821383        ui_menu_entry_set_cb(mexit, uidemo_file_exit, (void *) &demo);
    822384
    823         rc = ui_menu_dd_create(demo.mbar, "~E~dit", NULL, &demo.medit);
    824         if (rc != EOK) {
    825                 printf("Error creating menu.\n");
    826                 return rc;
    827         }
    828 
    829         rc = ui_menu_entry_create(demo.medit, "~M~odify", "", &mmodify);
    830         if (rc != EOK) {
    831                 printf("Error creating menu.\n");
    832                 return rc;
    833         }
    834 
    835         ui_menu_entry_set_cb(mmodify, uidemo_edit_modify, (void *) &demo);
    836 
    837         rc = ui_menu_entry_create(demo.medit, "~I~nsert Character",
    838             "", &minsert_char);
    839         if (rc != EOK) {
    840                 printf("Error creating menu.\n");
    841                 return rc;
    842         }
    843 
    844         ui_menu_entry_set_cb(minsert_char, uidemo_edit_insert_character,
    845             (void *) &demo);
    846 
    847         rc = ui_menu_dd_create(demo.mbar, "~P~references", NULL,
    848             &demo.mpreferences);
    849         if (rc != EOK) {
    850                 printf("Error creating menu.\n");
    851                 return rc;
    852         }
    853 
    854         rc = ui_menu_dd_create(demo.mbar, "~H~elp", NULL, &demo.mhelp);
    855         if (rc != EOK) {
    856                 printf("Error creating menu.\n");
    857                 return rc;
    858         }
    859 
    860         rc = ui_menu_entry_create(demo.mhelp, "~A~bout", "Ctrl-H, F1", &mabout);
     385        rc = ui_menu_create(demo.mbar, "Edit", &demo.medit);
     386        if (rc != EOK) {
     387                printf("Error creating menu.\n");
     388                return rc;
     389        }
     390
     391        rc = ui_menu_create(demo.mbar, "Preferences", &demo.mpreferences);
     392        if (rc != EOK) {
     393                printf("Error creating menu.\n");
     394                return rc;
     395        }
     396
     397        rc = ui_menu_create(demo.mbar, "Help", &demo.mhelp);
     398        if (rc != EOK) {
     399                printf("Error creating menu.\n");
     400                return rc;
     401        }
     402
     403        rc = ui_menu_entry_create(demo.mhelp, "About", "Ctrl-H, F1", &mabout);
    861404        if (rc != EOK) {
    862405                printf("Error creating menu.\n");
     
    867410        if (ui_is_textmode(ui)) {
    868411                rect.p0.x = 1;
    869                 rect.p0.y = 1;
    870                 rect.p1.x = 43;
    871                 rect.p1.y = 2;
     412                rect.p0.y = 2;
     413                rect.p1.x = 79;
     414                rect.p1.y = 3;
    872415        } else {
    873416                rect.p0.x = 4;
    874417                rect.p0.y = 30;
    875                 rect.p1.x = 251;
     418                rect.p1.x = 216;
    876419                rect.p1.y = 52;
    877420        }
    878 
    879421        ui_menu_bar_set_rect(demo.mbar, &rect);
    880422
     
    885427        }
    886428
    887         rc = ui_tab_set_create(ui_res, &demo.tabset);
    888         if (rc != EOK) {
    889                 printf("Error creating tab set.\n");
    890                 return rc;
    891         }
    892 
    893         /* FIXME: Auto layout */
    894         if (ui_is_textmode(ui)) {
    895                 rect.p0.x = 2;
    896                 rect.p0.y = 2;
    897                 rect.p1.x = 44;
    898                 rect.p1.y = 24;
    899         } else {
    900                 rect.p0.x = 8;
    901                 rect.p0.y = 53;
    902                 rect.p1.x = 250;
    903                 rect.p1.y = 405;
    904         }
    905 
    906         ui_tab_set_set_rect(demo.tabset, &rect);
    907 
    908         rc = ui_tab_create(demo.tabset, "Basic", &demo.tbasic);
    909         if (rc != EOK) {
    910                 printf("Error creating tab.\n");
    911                 return rc;
    912         }
    913 
    914         rc = ui_tab_create(demo.tabset, "Lists", &demo.tlists);
    915         if (rc != EOK) {
    916                 printf("Error creating tab.\n");
    917                 return rc;
    918         }
    919 
    920         rc = ui_fixed_add(demo.fixed, ui_tab_set_ctl(demo.tabset));
    921         if (rc != EOK) {
    922                 printf("Error adding control to layout.\n");
    923                 return rc;
    924         }
    925 
    926         rc = ui_fixed_create(&demo.bfixed);
    927         if (rc != EOK) {
    928                 printf("Error creating fixed layout.\n");
    929                 return rc;
    930         }
    931 
    932429        rc = ui_entry_create(window, "", &demo.entry);
    933430        if (rc != EOK) {
     
    936433        }
    937434
    938         /* FIXME: Auto layout */
    939         if (ui_is_textmode(ui)) {
    940                 rect.p0.x = 4;
    941                 rect.p0.y = 5;
    942                 rect.p1.x = 41;
    943                 rect.p1.y = 6;
    944         } else {
    945                 rect.p0.x = 15;
    946                 rect.p0.y = 88;
    947                 rect.p1.x = 205;
    948                 rect.p1.y = 113;
    949         }
    950 
     435        rect.p0.x = 15;
     436        rect.p0.y = 53;
     437        rect.p1.x = 205;
     438        rect.p1.y = 78;
    951439        ui_entry_set_rect(demo.entry, &rect);
    952440        ui_entry_set_halign(demo.entry, gfx_halign_center);
    953441
    954         rc = ui_fixed_add(demo.bfixed, ui_entry_ctl(demo.entry));
     442        rc = ui_fixed_add(demo.fixed, ui_entry_ctl(demo.entry));
    955443        if (rc != EOK) {
    956444                printf("Error adding control to layout.\n");
     
    964452        }
    965453
    966         /* FIXME: Auto layout */
    967         if (ui_is_textmode(ui)) {
    968                 rect.p0.x = 4;
    969                 rect.p0.y = 7;
    970                 rect.p1.x = 41;
    971                 rect.p1.y = 8;
    972         } else {
    973                 rect.p0.x = 60;
    974                 rect.p0.y = 123;
    975                 rect.p1.x = 160;
    976                 rect.p1.y = 136;
    977         }
    978 
     454        rect.p0.x = 60;
     455        rect.p0.y = 88;
     456        rect.p1.x = 160;
     457        rect.p1.y = 101;
    979458        ui_label_set_rect(demo.label, &rect);
    980459        ui_label_set_halign(demo.label, gfx_halign_center);
    981460
    982         rc = ui_fixed_add(demo.bfixed, ui_label_ctl(demo.label));
     461        rc = ui_fixed_add(demo.fixed, ui_label_ctl(demo.label));
    983462        if (rc != EOK) {
    984463                printf("Error adding control to layout.\n");
     
    994473        ui_pbutton_set_cb(demo.pb1, &pbutton_cb, (void *) &demo);
    995474
    996         /* FIXME: Auto layout */
    997         if (ui_is_textmode(ui)) {
    998                 rect.p0.x = 4;
    999                 rect.p0.y = 9;
    1000                 rect.p1.x = 15;
    1001                 rect.p1.y = 10;
    1002         } else {
    1003                 rect.p0.x = 15;
    1004                 rect.p0.y = 146;
    1005                 rect.p1.x = 105;
    1006                 rect.p1.y = 174;
    1007         }
    1008 
     475        rect.p0.x = 15;
     476        rect.p0.y = 111;
     477        rect.p1.x = 105;
     478        rect.p1.y = 139;
    1009479        ui_pbutton_set_rect(demo.pb1, &rect);
    1010480
    1011481        ui_pbutton_set_default(demo.pb1, true);
    1012482
    1013         rc = ui_fixed_add(demo.bfixed, ui_pbutton_ctl(demo.pb1));
     483        rc = ui_fixed_add(demo.fixed, ui_pbutton_ctl(demo.pb1));
    1014484        if (rc != EOK) {
    1015485                printf("Error adding control to layout.\n");
     
    1025495        ui_pbutton_set_cb(demo.pb2, &pbutton_cb, (void *) &demo);
    1026496
    1027         if (ui_is_textmode(ui)) {
    1028                 rect.p0.x = 30;
    1029                 rect.p0.y = 9;
    1030                 rect.p1.x = 41;
    1031                 rect.p1.y = 10;
    1032         } else {
    1033                 rect.p0.x = 115;
    1034                 rect.p0.y = 146;
    1035                 rect.p1.x = 205;
    1036                 rect.p1.y = 174;
    1037         }
    1038 
     497        rect.p0.x = 115;
     498        rect.p0.y = 111;
     499        rect.p1.x = 205;
     500        rect.p1.y = 139;
    1039501        ui_pbutton_set_rect(demo.pb2, &rect);
    1040502
    1041         rc = ui_fixed_add(demo.bfixed, ui_pbutton_ctl(demo.pb2));
     503        rc = ui_fixed_add(demo.fixed, ui_pbutton_ctl(demo.pb2));
    1042504        if (rc != EOK) {
    1043505                printf("Error adding control to layout.\n");
     
    1046508
    1047509        gfx_bitmap_params_init(&bparams);
    1048         if (ui_is_textmode(ui)) {
    1049                 bparams.rect.p0.x = 0;
    1050                 bparams.rect.p0.y = 0;
    1051                 bparams.rect.p1.x = 37;
    1052                 bparams.rect.p1.y = 2;
    1053         } else {
    1054                 bparams.rect.p0.x = 0;
    1055                 bparams.rect.p0.y = 0;
    1056                 bparams.rect.p1.x = 188;
    1057                 bparams.rect.p1.y = 24;
    1058         }
     510        bparams.rect.p0.x = 0;
     511        bparams.rect.p0.y = 0;
     512        bparams.rect.p1.x = 188;
     513        bparams.rect.p1.y = 24;
    1059514
    1060515        rc = gfx_bitmap_create(gc, &bparams, NULL, &bitmap);
     
    1072527        }
    1073528
    1074         if (ui_is_textmode(ui)) {
    1075                 off.x = 4;
    1076                 off.y = 11;
    1077         } else {
    1078                 off.x = 15;
    1079                 off.y = 190;
    1080         }
    1081 
     529        off.x = 15;
     530        off.y = 155;
    1082531        gfx_rect_translate(&off, &bparams.rect, &rect);
    1083532
    1084533        /* Adjust for frame width (2 x 1 pixel) */
    1085         if (!ui_is_textmode(ui)) {
    1086                 ui_image_set_flags(demo.image, ui_imgf_frame);
    1087                 rect.p1.x += 2;
    1088                 rect.p1.y += 2;
    1089         }
    1090 
     534        rect.p1.x += 2;
     535        rect.p1.y += 2;
    1091536        ui_image_set_rect(demo.image, &rect);
    1092 
    1093         rc = ui_fixed_add(demo.bfixed, ui_image_ctl(demo.image));
    1094         if (rc != EOK) {
    1095                 printf("Error adding control to layout.\n");
    1096                 return rc;
    1097         }
    1098 
    1099         rc = ui_checkbox_create(ui_res, "Read only", &demo.checkbox);
     537        ui_image_set_flags(demo.image, ui_imgf_frame);
     538
     539        rc = ui_fixed_add(demo.fixed, ui_image_ctl(demo.image));
     540        if (rc != EOK) {
     541                printf("Error adding control to layout.\n");
     542                return rc;
     543        }
     544
     545        rc = ui_checkbox_create(ui_res, "Check me", &demo.checkbox);
    1100546        if (rc != EOK) {
    1101547                printf("Error creating check box.\n");
     
    1105551        ui_checkbox_set_cb(demo.checkbox, &checkbox_cb, (void *) &demo);
    1106552
    1107         /* FIXME: Auto layout */
    1108         if (ui_is_textmode(ui)) {
    1109                 rect.p0.x = 4;
    1110                 rect.p0.y = 14;
    1111                 rect.p1.x = 14;
    1112                 rect.p1.y = 15;
    1113         } else {
    1114                 rect.p0.x = 15;
    1115                 rect.p0.y = 225;
    1116                 rect.p1.x = 140;
    1117                 rect.p1.y = 245;
    1118         }
    1119 
     553        rect.p0.x = 15;
     554        rect.p0.y = 190;
     555        rect.p1.x = 140;
     556        rect.p1.y = 210;
    1120557        ui_checkbox_set_rect(demo.checkbox, &rect);
    1121558
    1122         rc = ui_fixed_add(demo.bfixed, ui_checkbox_ctl(demo.checkbox));
     559        rc = ui_fixed_add(demo.fixed, ui_checkbox_ctl(demo.checkbox));
    1123560        if (rc != EOK) {
    1124561                printf("Error adding control to layout.\n");
     
    1132569        }
    1133570
    1134         rc = ui_rbutton_create(demo.rbgroup, "Left", (void *) &uidemo_halign[0],
    1135             &demo.rbleft);
     571        rc = ui_rbutton_create(demo.rbgroup, "Option 1", (void *) "First",
     572            &demo.rb1);
    1136573        if (rc != EOK) {
    1137574                printf("Error creating radio button.\n");
     
    1142579            (void *) &demo);
    1143580
    1144         /* FIXME: Auto layout */
    1145         if (ui_is_textmode(ui)) {
    1146                 rect.p0.x = 4;
    1147                 rect.p0.y = 16;
    1148                 rect.p1.x = 14;
    1149                 rect.p1.y = 17;
    1150         } else {
    1151                 rect.p0.x = 15;
    1152                 rect.p0.y = 255;
    1153                 rect.p1.x = 140;
    1154                 rect.p1.y = 275;
    1155         }
    1156         ui_rbutton_set_rect(demo.rbleft, &rect);
    1157 
    1158         rc = ui_fixed_add(demo.bfixed, ui_rbutton_ctl(demo.rbleft));
    1159         if (rc != EOK) {
    1160                 printf("Error adding control to layout.\n");
    1161                 return rc;
    1162         }
    1163 
    1164         rc = ui_rbutton_create(demo.rbgroup, "Center", (void *) &uidemo_halign[1],
    1165             &demo.rbcenter);
     581        rect.p0.x = 15;
     582        rect.p0.y = 220;
     583        rect.p1.x = 140;
     584        rect.p1.y = 240;
     585        ui_rbutton_set_rect(demo.rb1, &rect);
     586
     587        rc = ui_fixed_add(demo.fixed, ui_rbutton_ctl(demo.rb1));
     588        if (rc != EOK) {
     589                printf("Error adding control to layout.\n");
     590                return rc;
     591        }
     592
     593        rc = ui_rbutton_create(demo.rbgroup, "Option 2", (void *) "Second",
     594            &demo.rb2);
    1166595        if (rc != EOK) {
    1167596                printf("Error creating radio button.\n");
     
    1169598        }
    1170599
    1171         /* FIXME: Auto layout */
    1172         if (ui_is_textmode(ui)) {
    1173                 rect.p0.x = 4;
    1174                 rect.p0.y = 17;
    1175                 rect.p1.x = 14;
    1176                 rect.p1.y = 18;
    1177         } else {
    1178                 rect.p0.x = 15;
    1179                 rect.p0.y = 285;
    1180                 rect.p1.x = 140;
    1181                 rect.p1.y = 305;
    1182         }
    1183         ui_rbutton_set_rect(demo.rbcenter, &rect);
    1184         ui_rbutton_select(demo.rbcenter);
    1185 
    1186         rc = ui_fixed_add(demo.bfixed, ui_rbutton_ctl(demo.rbcenter));
    1187         if (rc != EOK) {
    1188                 printf("Error adding control to layout.\n");
    1189                 return rc;
    1190         }
    1191 
    1192         rc = ui_rbutton_create(demo.rbgroup, "Right", (void *) &uidemo_halign[2],
    1193             &demo.rbright);
     600        rect.p0.x = 15;
     601        rect.p0.y = 250;
     602        rect.p1.x = 140;
     603        rect.p1.y = 270;
     604        ui_rbutton_set_rect(demo.rb2, &rect);
     605
     606        rc = ui_fixed_add(demo.fixed, ui_rbutton_ctl(demo.rb2));
     607        if (rc != EOK) {
     608                printf("Error adding control to layout.\n");
     609                return rc;
     610        }
     611
     612        rc = ui_rbutton_create(demo.rbgroup, "Option 3", (void *) "Third",
     613            &demo.rb3);
    1194614        if (rc != EOK) {
    1195615                printf("Error creating radio button.\n");
     
    1197617        }
    1198618
    1199         /* FIXME: Auto layout */
    1200         if (ui_is_textmode(ui)) {
    1201                 rect.p0.x = 4;
    1202                 rect.p0.y = 18;
    1203                 rect.p1.x = 14;
    1204                 rect.p1.y = 19;
    1205         } else {
    1206                 rect.p0.x = 15;
    1207                 rect.p0.y = 315;
    1208                 rect.p1.x = 140;
    1209                 rect.p1.y = 335;
    1210         }
    1211         ui_rbutton_set_rect(demo.rbright, &rect);
    1212 
    1213         rc = ui_fixed_add(demo.bfixed, ui_rbutton_ctl(demo.rbright));
    1214         if (rc != EOK) {
    1215                 printf("Error adding control to layout.\n");
    1216                 return rc;
    1217         }
    1218 
    1219         rc = ui_slider_create(ui_res, &demo.slider);
     619        rect.p0.x = 15;
     620        rect.p0.y = 280;
     621        rect.p1.x = 140;
     622        rect.p1.y = 300;
     623        ui_rbutton_set_rect(demo.rb3, &rect);
     624
     625        rc = ui_fixed_add(demo.fixed, ui_rbutton_ctl(demo.rb3));
     626        if (rc != EOK) {
     627                printf("Error adding control to layout.\n");
     628                return rc;
     629        }
     630
     631        rc = ui_slider_create(ui_res, "Slide!", &demo.slider);
    1220632        if (rc != EOK) {
    1221633                printf("Error creating button.\n");
     
    1225637        ui_slider_set_cb(demo.slider, &slider_cb, (void *) &demo);
    1226638
    1227         /* FIXME: Auto layout */
    1228         if (ui_is_textmode(ui)) {
    1229                 rect.p0.x = 4;
    1230                 rect.p0.y = 20;
    1231                 rect.p1.x = 32;
    1232                 rect.p1.y = 21;
    1233         } else {
    1234                 rect.p0.x = 15;
    1235                 rect.p0.y = 345;
    1236                 rect.p1.x = 130;
    1237                 rect.p1.y = 365;
    1238         }
    1239 
     639        rect.p0.x = 15;
     640        rect.p0.y = 310;
     641        rect.p1.x = 130;
     642        rect.p1.y = 330;
    1240643        ui_slider_set_rect(demo.slider, &rect);
    1241644
    1242         rc = ui_fixed_add(demo.bfixed, ui_slider_ctl(demo.slider));
    1243         if (rc != EOK) {
    1244                 printf("Error adding control to layout.\n");
    1245                 return rc;
    1246         }
    1247 
    1248         rc = ui_scrollbar_create(ui, window, ui_sbd_horiz, &demo.hscrollbar);
    1249         if (rc != EOK) {
    1250                 printf("Error creating scrollbar.\n");
    1251                 return rc;
    1252         }
    1253 
    1254         ui_scrollbar_set_cb(demo.hscrollbar, &scrollbar_cb, (void *) &demo);
    1255 
    1256         /* FIXME: Auto layout */
    1257         if (ui_is_textmode(ui)) {
    1258                 rect.p0.x = 4;
    1259                 rect.p0.y = 22;
    1260                 rect.p1.x = 42;
    1261                 rect.p1.y = 23;
    1262         } else {
    1263                 rect.p0.x = 15;
    1264                 rect.p0.y = 375;
    1265                 rect.p1.x = 220;
    1266                 rect.p1.y = 398;
    1267         }
    1268 
    1269         ui_scrollbar_set_rect(demo.hscrollbar, &rect);
    1270 
    1271         ui_scrollbar_set_thumb_length(demo.hscrollbar,
    1272             ui_scrollbar_trough_length(demo.hscrollbar) / 4);
    1273 
    1274         rc = ui_fixed_add(demo.bfixed, ui_scrollbar_ctl(demo.hscrollbar));
    1275         if (rc != EOK) {
    1276                 printf("Error adding control to layout.\n");
    1277                 return rc;
    1278         }
    1279 
    1280         rc = ui_scrollbar_create(ui, window, ui_sbd_vert, &demo.vscrollbar);
    1281         if (rc != EOK) {
    1282                 printf("Error creating button.\n");
    1283                 return rc;
    1284         }
    1285 
    1286         ui_scrollbar_set_cb(demo.vscrollbar, &scrollbar_cb, (void *) &demo);
    1287 
    1288         /* FIXME: Auto layout */
    1289         if (ui_is_textmode(ui)) {
    1290                 rect.p0.x = 42;
    1291                 rect.p0.y = 5;
    1292                 rect.p1.x = 43;
    1293                 rect.p1.y = 22;
    1294         } else {
    1295                 rect.p0.x = 220;
    1296                 rect.p0.y = 88;
    1297                 rect.p1.x = 243;
    1298                 rect.p1.y = 375;
    1299         }
    1300 
    1301         ui_scrollbar_set_rect(demo.vscrollbar, &rect);
    1302 
    1303         ui_scrollbar_set_thumb_length(demo.vscrollbar,
    1304             ui_scrollbar_trough_length(demo.vscrollbar) / 4);
    1305 
    1306         rc = ui_fixed_add(demo.bfixed, ui_scrollbar_ctl(demo.vscrollbar));
    1307         if (rc != EOK) {
    1308                 printf("Error adding control to layout.\n");
    1309                 return rc;
    1310         }
    1311 
    1312         ui_tab_add(demo.tbasic, ui_fixed_ctl(demo.bfixed));
    1313 
    1314         rc = ui_fixed_create(&demo.lfixed);
    1315         if (rc != EOK) {
    1316                 printf("Error creating fixed layout.\n");
    1317                 return rc;
    1318         }
    1319 
    1320         rc = ui_list_create(window, false, &demo.list);
    1321         if (rc != EOK) {
    1322                 printf("Error creating list.\n");
    1323                 return rc;
    1324         }
    1325 
    1326         ui_list_entry_attr_init(&eattr);
    1327 
    1328         eattr.caption = "One";
    1329         rc = ui_list_entry_append(demo.list, &eattr, NULL);
    1330         if (rc != EOK) {
    1331                 printf("Error adding list entry.\n");
    1332                 return rc;
    1333         }
    1334 
    1335         eattr.caption = "Two";
    1336         rc = ui_list_entry_append(demo.list, &eattr, NULL);
    1337         if (rc != EOK) {
    1338                 printf("Error adding list entry.\n");
    1339                 return rc;
    1340         }
    1341 
    1342         eattr.caption = "Three";
    1343         rc = ui_list_entry_append(demo.list, &eattr, NULL);
    1344         if (rc != EOK) {
    1345                 printf("Error adding list entry.\n");
    1346                 return rc;
    1347         }
    1348 
    1349         eattr.caption = "Four";
    1350         rc = ui_list_entry_append(demo.list, &eattr, NULL);
    1351         if (rc != EOK) {
    1352                 printf("Error adding list entry.\n");
    1353                 return rc;
    1354         }
    1355 
    1356         eattr.caption = "Five";
    1357         rc = ui_list_entry_append(demo.list, &eattr, NULL);
    1358         if (rc != EOK) {
    1359                 printf("Error adding list entry.\n");
    1360                 return rc;
    1361         }
    1362 
    1363         eattr.caption = "Six";
    1364         rc = ui_list_entry_append(demo.list, &eattr, NULL);
    1365         if (rc != EOK) {
    1366                 printf("Error adding list entry.\n");
    1367                 return rc;
    1368         }
    1369 
    1370         /* FIXME: Auto layout */
    1371         if (ui_is_textmode(ui)) {
    1372                 rect.p0.x = 4;
    1373                 rect.p0.y = 5;
    1374                 rect.p1.x = 41;
    1375                 rect.p1.y = 10;
    1376         } else {
    1377                 rect.p0.x = 15;
    1378                 rect.p0.y = 88;
    1379                 rect.p1.x = 245;
    1380                 rect.p1.y = 173;
    1381         }
    1382 
    1383         ui_list_set_rect(demo.list, &rect);
    1384 
    1385         rc = ui_fixed_add(demo.lfixed, ui_list_ctl(demo.list));
    1386         if (rc != EOK) {
    1387                 printf("Error adding control to layout.\n");
    1388                 return rc;
    1389         }
    1390 
    1391         ui_tab_add(demo.tlists, ui_fixed_ctl(demo.lfixed));
     645        rc = ui_fixed_add(demo.fixed, ui_slider_ctl(demo.slider));
     646        if (rc != EOK) {
     647                printf("Error adding control to layout.\n");
     648                return rc;
     649        }
    1392650
    1393651        ui_window_add(window, ui_fixed_ctl(demo.fixed));
     
    1435693                        k = i * i + j * j;
    1436694                        pixelmap_put_pixel(&pixelmap, i, j,
    1437                             PIXEL(0, k, k, 255 - k));
     695                            PIXEL(255, k, k, 255 - k));
    1438696                }
    1439697        }
     
    1449707int main(int argc, char *argv[])
    1450708{
    1451         const char *display_spec = UI_ANY_DEFAULT;
     709        const char *display_spec = UI_DISPLAY_DEFAULT;
    1452710        errno_t rc;
    1453711        int i;
Note: See TracChangeset for help on using the changeset viewer.