Subversion Repositories Kolibri OS

Rev

Rev 2693 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. #include "system.h"
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <math.h>
  6. #include "winlib.h"
  7.  
  8. extern int res_level[];
  9. extern int res_slider[];
  10. extern int res_vol_slider[];
  11. extern int res_progress_bar[];
  12. extern int res_prg_level[];
  13.  
  14. extern ctrl_t  *mouse_capture;
  15. uint32_t main_cursor;
  16.  
  17. static int button_proc(ctrl_t *btn, uint32_t msg, uint32_t arg1, uint32_t arg2);
  18. static int spinbtn_proc(ctrl_t *btn, uint32_t msg, uint32_t arg1, uint32_t arg2);
  19.  
  20. ctrl_t *create_control(size_t size, int id, int x, int y,
  21.                          int w, int h, ctrl_t *parent)
  22. {
  23.  
  24.     ctrl_t  *ctrl;
  25.  
  26.     if( !parent )
  27.         return NULL;
  28.  
  29.     ctrl = (ctrl_t*)malloc(size);
  30.  
  31.     link_initialize(&ctrl->link);
  32.     list_initialize(&ctrl->child);
  33.  
  34.     ctrl->parent  = parent;
  35.  
  36.     ctrl->ctx     = parent->ctx;
  37.     ctrl->id      = id;
  38.  
  39.     ctrl->rc.l    = x;
  40.     ctrl->rc.t    = y ;
  41.  
  42.     ctrl->rc.r    = x + w;
  43.     ctrl->rc.b    = y + h;
  44.  
  45.     ctrl->w       = w;
  46.     ctrl->h       = h;
  47.  
  48.     list_append(&ctrl->link, &parent->child);
  49.  
  50.     return ctrl;
  51. };
  52.  
  53.  
  54. button_t *create_button(char *caption, int id, int x, int y,
  55.                         int w, int h, ctrl_t *parent)
  56. {
  57.     button_t  *btn;
  58.     int        len;
  59.  
  60.     if( !parent )
  61.         return NULL;
  62.  
  63.     btn = (button_t*)create_control(sizeof(button_t), id, x, y, w, h, parent);
  64.     btn->ctrl.handler = button_proc;
  65.     btn->state = 0;
  66.     btn->caption = caption;
  67.  
  68.     if( !caption )
  69.         btn->capt_len = 0;
  70.     else
  71.     {
  72.         len = strlen(caption);
  73.         btn->capt_len = len;
  74.         if( len )
  75.             btn->caption = strdup(caption);
  76.         else
  77.             btn->caption = NULL;
  78.     }
  79.  
  80.     btn->img_default = NULL;
  81.     btn->img_hilite  = NULL;
  82.     btn->img_pressed = NULL;
  83.  
  84.     return btn;
  85. };
  86.  
  87. #if 0
  88. int draw_button(button_t *btn)
  89. {
  90.     void *bitmap;
  91.  
  92.     bitmap = btn->img_default;
  93.  
  94.     if(btn->state & bPressed)
  95.         bitmap = btn->img_pressed;
  96.     else if(btn->state & bHighlight)
  97.         bitmap = btn->img_hilite;
  98.  
  99.     if( bitmap )
  100.         draw_bitmap(bitmap, btn->rc.l, btn->rc.t, btn->w, btn->h);
  101.  
  102.     if( btn->caption && btn->capt_len)
  103.     {
  104.         int txt_w;
  105.         int txt_x, txt_y;
  106.         txt_w = btn->capt_len*8-2;
  107.  
  108.         txt_x = btn->rc.l + 1 + (btn->w - txt_w)/2;
  109.         txt_y = btn->rc.t + 9;
  110.  
  111.         if(btn->state & bPressed){
  112.             txt_x++;
  113.             txt_y++;
  114.         };
  115.         draw_text(btn->caption, txt_x, txt_y, btn->capt_len, 0x10000000);
  116.     };
  117.     return 0;
  118. };
  119. #endif
  120.  
  121. int draw_button_cairo(button_t *btn)
  122. {
  123.     int *pixmap, *src;
  124.     ctx_t *ctx;
  125.     int i, j;
  126.     int x, y;
  127.  
  128.     ctx = btn->ctrl.ctx;
  129.  
  130.     x = btn->ctrl.rc.l - ctx->offset_x;
  131.     y = btn->ctrl.rc.t - ctx->offset_y;
  132.  
  133.     pixmap = ctx->pixmap;
  134.  
  135.     pixmap+=  y*ctx->stride/4 + x;
  136.  
  137.     src = btn->img_default;
  138.  
  139.     if(btn->state & bPressed)
  140.         src = btn->img_pressed;
  141.     else if(btn->state & bHighlight)
  142.         src = btn->img_hilite;
  143.  
  144.     for(i=0; i < btn->ctrl.h ;i++)
  145.     {
  146.         for(j = 0; j < btn->ctrl.w; j++)
  147.             pixmap[j] = src[j];
  148.         pixmap+= ctx->stride/4;
  149.         src+= btn->ctrl.w;
  150.     };
  151.  
  152.     return 0;
  153. };
  154.  
  155.  
  156. int draw_spin_cairo(button_t *btn)
  157. {
  158.     void *ctx;
  159.  
  160.     return 0;
  161. };
  162.  
  163.  
  164. int button_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
  165. {
  166.     int  x, y;
  167.     int  state;
  168.     int  old_state;
  169.     int  action=0;
  170.  
  171.     button_t *btn = (button_t*)ctrl;
  172.  
  173.     switch( msg )
  174.     {
  175.         case MSG_PAINT:
  176.             draw_button_cairo(btn);
  177.             update_rect((ctrl_t*)btn);
  178.             break;
  179.  
  180.         case MSG_MOUSEENTER:
  181. //            printf("mouse enter\n");
  182.             btn->state|= bHighlight;
  183.             send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  184.             break;
  185.  
  186.         case MSG_MOUSELEAVE:
  187. //            printf("mouse leave\n");
  188.             if( (ctrl_t*)btn != mouse_capture) {
  189.                 btn->state &= ~bHighlight;
  190.                 send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  191.             };
  192.             break;
  193.  
  194.         case MSG_LBTNDOWN:
  195.         case MSG_LBTNDBLCLK:
  196. //            printf("push button\n");
  197.             capture_mouse((ctrl_t*)btn);
  198.             btn->state|= bPressed;
  199.             send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  200.             break;
  201.  
  202.         case MSG_LBTNUP:
  203.  
  204.  //           printf("button action\n");
  205.             if(btn->state & bPressed)
  206.                 action = MSG_COMMAND;
  207.  
  208.             release_mouse();
  209.  
  210.             x = ((pos_t)arg2).x;
  211.             y = ((pos_t)arg2).y;
  212.  
  213.             if( pt_in_rect( &btn->ctrl.rc, x, y) )
  214.                 state = bHighlight;
  215.             else
  216.                 state = 0;
  217.  
  218.             if(action)
  219.                 send_message(btn->ctrl.parent,MSG_COMMAND,btn->ctrl.id,(int)btn);
  220.  
  221.             btn->state = state;
  222.             send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  223.             break;
  224.  
  225.         case MSG_MOUSEMOVE:
  226.  
  227.             if(main_cursor != 0)
  228.             {
  229.                 set_cursor(0);
  230.                 main_cursor = 0;
  231.             }
  232.  
  233.             if( ! (btn->state & bHighlight))
  234.             {
  235.                 btn->state|= bHighlight;
  236.                 send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  237.             };
  238.  
  239.             if( (ctrl_t*)btn != mouse_capture)
  240.                 return 0;
  241.  
  242.             x = ((pos_t)arg2).x;
  243.             y = ((pos_t)arg2).y;
  244.  
  245.             old_state = btn->state;
  246.  
  247.             if( pt_in_rect(&btn->ctrl.rc, x, y) )
  248.                 btn->state |= bPressed;
  249.             else
  250.                 btn->state &= ~bPressed;
  251.  
  252.             if( old_state ^ btn->state)
  253.                 send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  254.     }
  255.     return 0;
  256. };
  257.  
  258.  
  259. int draw_progress(progress_t *prg, int background)
  260. {
  261.     int *pixmap, *src;
  262.     ctx_t *ctx;
  263.     int i, j;
  264.     int x, y;
  265.  
  266.     int len = prg->ctrl.w;
  267.  
  268.     ctx = prg->ctrl.ctx;
  269.  
  270.     x = prg->ctrl.rc.l - ctx->offset_x;
  271.     y = prg->ctrl.rc.t - ctx->offset_y;
  272.  
  273.     if( background )
  274.     {
  275.         src = res_progress_bar;
  276.  
  277.         pixmap = ctx->pixmap;
  278.         pixmap+= y * ctx->stride/4 + x;
  279.  
  280.         for(i=0; i < 10; i++)
  281.         {
  282.             for(j = 0; j < len; j++)
  283.                 pixmap[j] = *src;
  284.  
  285.             pixmap+= ctx->stride/4;
  286.             src++;
  287.         };
  288.     };
  289.  
  290.  
  291.     len = prg->current*prg->ctrl.w/(prg->max - prg->min);
  292.  
  293.     src = res_prg_level;
  294.  
  295.     pixmap = ctx->pixmap;
  296.     pixmap+= y*ctx->stride/4 + x;
  297.  
  298.     for(i=0; i < prg->ctrl.h ;i++)
  299.     {
  300.         for(j=0; j < len; j++)
  301.             pixmap[j] = *src;
  302.         pixmap+= ctx->stride/4;
  303.         src++;
  304.     };
  305.  
  306.     return 0;
  307. };
  308.  
  309.  
  310. int prg_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
  311. {
  312.     progress_t *prg = (progress_t*)ctrl;
  313.     int pos;
  314.  
  315.     switch( msg )
  316.     {
  317.         case MSG_PAINT:
  318.             draw_progress(prg, 1);
  319.             update_rect(ctrl);
  320.             break;
  321.  
  322.         case MSG_LBTNDOWN:
  323.             prg->pos = ((pos_t)arg2).x - ctrl->rc.l;
  324.             send_message(ctrl->parent,MSG_COMMAND,ctrl->id,(int)ctrl);
  325.             break;
  326.  
  327.         case PRG_PROGRESS:
  328.             draw_progress(prg, 0);
  329.             update_rect(ctrl);
  330.             break;
  331.  
  332.         default:
  333.             break;
  334.     }
  335.     return 0;
  336. };
  337.  
  338.  
  339. progress_t *create_progress(char *caption, int id, int x, int y,
  340.                         int w, int h, ctrl_t *parent)
  341. {
  342.     progress_t  *prg;
  343.     int        len;
  344.  
  345.     if( !parent )
  346.         return NULL;
  347.  
  348.     prg = (progress_t*)create_control(sizeof(progress_t), id, x, y, w, h, parent);
  349.  
  350.     prg->ctrl.handler = prg_proc;
  351.  
  352.     prg->min        = 0;
  353.     prg->max        = 1;
  354.     prg->current    = 0;
  355.     prg->pos        = 0;
  356.  
  357.     return prg;
  358. };
  359.  
  360. int draw_level(level_t *lvl)
  361. {
  362.     int *pixmap, *src;
  363.     ctx_t *ctx;
  364.     int i, j;
  365.     int x, y;
  366.  
  367.     int len;
  368.     double level;
  369.  
  370.     ctx = lvl->ctrl.ctx;
  371.  
  372.     x = lvl->ctrl.rc.l - ctx->offset_x;
  373.     y = lvl->ctrl.rc.t - ctx->offset_y;
  374.  
  375.     level = (log2(lvl->current+1)-7)*12 + lvl->vol/50 ;
  376.  
  377.     len = level;
  378.  
  379.     if(len < 0)
  380.         len = 0;
  381.     if(len > 96)
  382.         len = 96;
  383.  
  384.     pixmap = ctx->pixmap;
  385.  
  386.     pixmap+=  y*ctx->stride/4 + x;
  387.  
  388. //    for(i=0; i < prg->ctrl.h ;i++)
  389. //    {
  390. //        for(j=0; j < len; j++)
  391. //            pixmap[j] = src;
  392. //        pixmap+= ctx->stride/4;
  393. //    };
  394.  
  395.     src = lvl->img_level;
  396.  
  397.     for(i=0; i < 10; i++)
  398.     {
  399.         for(j = 0; j < 96; j++)
  400.            pixmap[j] = 0xFF1C1C1C;
  401.            pixmap+= ctx->stride/4;
  402.     };
  403.  
  404.     pixmap = ctx->pixmap;
  405.     pixmap+= y*ctx->stride/4 + x;
  406.  
  407.     for(i=0; i < 10; i++)
  408.     {
  409.         for(j = 0; j < len; j++)
  410.             pixmap[j] = src[j];
  411.         pixmap+= ctx->stride/4;
  412.         src+= 96;
  413.     };
  414.  
  415.     return 0;
  416. };
  417.  
  418.  
  419. int lvl_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
  420. {
  421.     level_t *lvl = (level_t*)ctrl;
  422. //    int pos;
  423.  
  424.     switch( msg )
  425.     {
  426.         case MSG_PAINT:
  427.             if(lvl->visible)
  428.             {
  429.                 draw_level(lvl);
  430.                 update_rect(ctrl);
  431.             };
  432.             break;
  433.  
  434. //        case MSG_LBTNDOWN:
  435. //            prg->pos = ((pos_t)arg2).x - ctrl->rc.l;
  436. //            send_message(ctrl->parent,MSG_COMMAND,ctrl->id,(int)ctrl);
  437. //            break;
  438.  
  439.         default:
  440.             break;
  441.     }
  442.     return 0;
  443. };
  444.  
  445. level_t    *create_level(char *caption, int id, int x, int y,
  446.                          int w, int h, ctrl_t *parent)
  447. {
  448.     level_t  *lvl;
  449.  
  450.     if( !parent )
  451.         return NULL;
  452.  
  453.     lvl = (level_t*)create_control(sizeof(level_t), id, x, y, w, h, parent);
  454.     lvl->ctrl.handler = lvl_proc;
  455.  
  456.     lvl->min          = 0;
  457.     lvl->max          = 1;
  458.     lvl->current      = 0;
  459.     lvl->pos          = 0;
  460.     lvl->visible      = 0;
  461.     lvl->img_level    = res_level;
  462.  
  463.     return lvl;
  464. };
  465.  
  466.  
  467. int draw_slider(slider_t *sld)
  468. {
  469.     int *pixmap, *src;
  470.     ctx_t *ctx;
  471.     int i, j;
  472.     int x, y;
  473.  
  474.     int32_t len;
  475.     double level;
  476.  
  477.     ctx = sld->ctrl.ctx;
  478.  
  479.     x = sld->ctrl.rc.l - ctx->offset_x;
  480.     y = sld->ctrl.rc.t - ctx->offset_y;
  481.  
  482.  
  483.     len = 96 + 12;
  484.  
  485.     pixmap = ctx->pixmap;
  486.     pixmap+=  y*ctx->stride/4 + x;
  487.  
  488.     for(i=0; i < 11; i++)
  489.     {
  490.         for(j = 0; j < len; j++)
  491.            pixmap[j] = 0xFF1C1C1C;
  492.            pixmap+= ctx->stride/4;
  493.     };
  494.  
  495.     pixmap = ctx->pixmap;
  496.     pixmap+=  (y+4)*ctx->stride/4 + x + 6;
  497.  
  498.     src = sld->img_vol_slider;
  499.  
  500.     for(i = 0; i < 4; i++)
  501.     {
  502.         for(j = 0; j < 96; j++)
  503.             pixmap[j] = src[j];
  504.         pixmap+= ctx->stride/4;
  505.         src+= 96;
  506.     };
  507.  
  508.     pixmap = ctx->pixmap;
  509.     pixmap+=  y*ctx->stride/4 + x + sld->pos;
  510.  
  511.     src = res_slider;
  512.  
  513.     for(i = 0; i < 11; i++)
  514.     {
  515.         for(j = 0; j < 12; j++)
  516.             pixmap[j] = src[j];
  517.         pixmap+= ctx->stride/4;
  518.         src+= 12;
  519.     };
  520.  
  521.     return 0;
  522. };
  523.  
  524.  
  525. int sld_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
  526. {
  527.     slider_t *sld = (slider_t*)ctrl;
  528.     int pos;
  529.  
  530.     switch( msg )
  531.     {
  532.         case MSG_PAINT:
  533.             draw_slider(sld);
  534.             update_rect(ctrl);
  535.             break;
  536.  
  537.         case MSG_LBTNDOWN:
  538.             capture_mouse(ctrl);
  539.             sld->mode = 1;
  540.  
  541.             pos = ((pos_t)arg2).x - ctrl->rc.l - 6;
  542.             if( pos < 0 )
  543.                 pos = 0;
  544.             else if(pos > 96)
  545.                 pos = 96;
  546.             if( sld->pos != pos)
  547.             {
  548.                 sld->pos = pos;
  549.                 send_message(ctrl->parent,MSG_COMMAND,ctrl->id,(int)ctrl);
  550.             };
  551.            break;
  552.  
  553.         case MSG_LBTNUP:
  554.             if(sld->mode)
  555.             {
  556.                 release_mouse();
  557.                 sld->mode = 0;
  558.             };
  559.             break;
  560.  
  561.         case MSG_MOUSEMOVE:
  562.             if(sld->mode)
  563.             {
  564.                 pos = ((pos_t)arg2).x - ctrl->rc.l - 6;
  565.                 if( pos < 0 )
  566.                     pos = 0;
  567.                 else if(pos > 96)
  568.                     pos = 96;
  569.                 if( sld->pos != pos)
  570.                 {
  571.                     sld->pos = pos;
  572. //                printf("slider pos %d\n", sld->pos);
  573.                     send_message(ctrl->parent,MSG_COMMAND,ctrl->id,(int)ctrl);
  574.                 }
  575.             };
  576.             break;
  577.  
  578.         case MSG_MOUSEENTER:
  579.             panel_set_layout(ctrl->parent, 1);
  580. //            printf("level on\n");
  581.             break;
  582.  
  583.         case MSG_MOUSELEAVE:
  584.             panel_set_layout(ctrl->parent, 0);
  585. //            printf("level off\n");
  586.             break;
  587.  
  588.  
  589.         default:
  590.             break;
  591.     }
  592.     return 0;
  593. };
  594.  
  595.  
  596. slider_t  *create_slider(char *caption, int id, int x, int y,
  597.                          int w, int h, ctrl_t *parent)
  598. {
  599.  
  600.     slider_t  *sld;
  601.  
  602.     if( !parent )
  603.         return NULL;
  604.  
  605.     sld = (slider_t*)create_control(sizeof(slider_t), id, x, y, w, h, parent);
  606.     sld->ctrl.handler = sld_proc;
  607.  
  608.     sld->min     = -5000;
  609.     sld->max     = 0;
  610.     sld->current = 0;
  611.     sld->pos     = 60;
  612.     sld->mode    = 0;
  613.     sld->img_vol_slider    = res_vol_slider;
  614.  
  615.     return sld;
  616. };
  617.  
  618.