Subversion Repositories Kolibri OS

Rev

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