Subversion Repositories Kolibri OS

Rev

Rev 5372 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1.  
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <math.h>
  5. #include <stdio.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 *src;
  124.     ctx_t *ctx;
  125.     int x, y;
  126.  
  127.     ctx = btn->ctrl.ctx;
  128.  
  129.     lock_bitmap(ctx->pixmap);
  130.    
  131.     x = btn->ctrl.rc.l - ctx->offset_x;
  132.     y = btn->ctrl.rc.t - ctx->offset_y;
  133.  
  134.     src = btn->img_default;
  135.  
  136.     if(btn->state & bPressed)
  137.         src = btn->img_pressed;
  138.     else if(btn->state & bHighlight)
  139.         src = btn->img_hilite;
  140.  
  141.     blit_raw(ctx, src, x, y, btn->ctrl.w, btn->ctrl.h, btn->ctrl.w*4);
  142.  
  143.     return 0;
  144. };
  145.  
  146.  
  147. int draw_spin_cairo(button_t *btn)
  148. {
  149.     void *ctx;
  150.  
  151.     return 0;
  152. };
  153.  
  154.  
  155. int button_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
  156. {
  157.     int  x, y;
  158.     int  state;
  159.     int  old_state;
  160.     int  action=0;
  161.  
  162.     button_t *btn = (button_t*)ctrl;
  163.  
  164.     switch( msg )
  165.     {
  166.         case MSG_PAINT:
  167.             draw_button_cairo(btn);
  168.             update_rect((ctrl_t*)btn);
  169.             break;
  170.  
  171.         case MSG_MOUSEENTER:
  172. //            printf("mouse enter\n");
  173.             btn->state|= bHighlight;
  174.             send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  175.             break;
  176.  
  177.         case MSG_MOUSELEAVE:
  178. //            printf("mouse leave\n");
  179.             if( (ctrl_t*)btn != mouse_capture) {
  180.                 btn->state &= ~bHighlight;
  181.                 send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  182.             };
  183.             break;
  184.  
  185.         case MSG_LBTNDOWN:
  186.         case MSG_LBTNDBLCLK:
  187. //            printf("push button\n");
  188.             capture_mouse((ctrl_t*)btn);
  189.             btn->state|= bPressed;
  190.             send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  191.             break;
  192.  
  193.         case MSG_LBTNUP:
  194.  
  195.  //           printf("button action\n");
  196.             if(btn->state & bPressed)
  197.                 action = MSG_COMMAND;
  198.  
  199.             release_mouse();
  200.  
  201.             x = ((pos_t)arg2).x;
  202.             y = ((pos_t)arg2).y;
  203.  
  204.             if( pt_in_rect( &btn->ctrl.rc, x, y) )
  205.                 state = bHighlight;
  206.             else
  207.                 state = 0;
  208.  
  209.             if(action)
  210.                 send_message(btn->ctrl.parent,MSG_COMMAND,btn->ctrl.id,(int)btn);
  211.  
  212.             btn->state = state;
  213.             send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  214.             break;
  215.  
  216.         case MSG_MOUSEMOVE:
  217.  
  218.             if(main_cursor != 0)
  219.             {
  220.                 set_cursor(0);
  221.                 main_cursor = 0;
  222.             }
  223.  
  224.             if( ! (btn->state & bHighlight))
  225.             {
  226.                 btn->state|= bHighlight;
  227.                 send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  228.             };
  229.  
  230.             if( (ctrl_t*)btn != mouse_capture)
  231.                 return 0;
  232.  
  233.             x = ((pos_t)arg2).x;
  234.             y = ((pos_t)arg2).y;
  235.  
  236.             old_state = btn->state;
  237.  
  238.             if( pt_in_rect(&btn->ctrl.rc, x, y) )
  239.                 btn->state |= bPressed;
  240.             else
  241.                 btn->state &= ~bPressed;
  242.  
  243.             if( old_state ^ btn->state)
  244.                 send_message(&btn->ctrl, MSG_PAINT, 0, 0);
  245.     }
  246.     return 0;
  247. };
  248.  
  249.  
  250. int draw_progress(progress_t *prg, int background)
  251. {
  252.     int *pixmap, *src;
  253.     ctx_t *ctx;
  254.     int i, j;
  255.     int x, y;
  256.     rect_t rc = prg->ctrl.rc;
  257.  
  258.     int len = prg->ctrl.w;
  259.  
  260.     ctx = prg->ctrl.ctx;
  261.    
  262.     lock_bitmap(ctx->pixmap);
  263.  
  264.     x = prg->ctrl.rc.l - ctx->offset_x;
  265.     y = prg->ctrl.rc.t - ctx->offset_y;
  266.  
  267.     if( background )
  268.     {
  269.         src = res_progress_bar;
  270.  
  271.         pixmap = (int*)ctx->pixmap->data;
  272.         pixmap+= y * ctx->pixmap->pitch/4 + x;
  273.  
  274.         for(i=0; i < 10; i++)
  275.         {
  276.             for(j = 0; j < len; j++)
  277.                 pixmap[j] = *src;
  278.  
  279.             pixmap+= ctx->pixmap->pitch/4;
  280.             src++;
  281.         };
  282.     };
  283.  
  284.  
  285.     len = prg->current*prg->ctrl.w/(prg->max - prg->min);
  286.  
  287.     src = res_prg_level;
  288.  
  289.     pixmap = (int*)ctx->pixmap->data;
  290.     pixmap+= y*ctx->pixmap->pitch/4 + x;
  291.  
  292.     for(i=0; i < prg->ctrl.h ;i++)
  293.     {
  294.         for(j=0; j < len; j++)
  295.             pixmap[j] = *src;
  296.         pixmap+= ctx->pixmap->pitch/4;
  297.         src++;
  298.     };
  299.  
  300.     return 0;
  301. };
  302.  
  303.  
  304. int prg_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
  305. {
  306.     progress_t *prg = (progress_t*)ctrl;
  307.     int pos;
  308.  
  309.     switch( msg )
  310.     {
  311.         case MSG_PAINT:
  312.             draw_progress(prg, 1);
  313.             update_rect(ctrl);
  314.             break;
  315.  
  316.         case MSG_LBTNDOWN:
  317.             prg->pos = ((pos_t)arg2).x - ctrl->rc.l;
  318.             send_message(ctrl->parent,MSG_COMMAND,ctrl->id,(int)ctrl);
  319.             break;
  320.  
  321.         case PRG_PROGRESS:
  322.             draw_progress(prg, 0);
  323.             update_rect(ctrl);
  324.             break;
  325.  
  326.         default:
  327.             break;
  328.     }
  329.     return 0;
  330. };
  331.  
  332.  
  333. progress_t *create_progress(char *caption, int id, int x, int y,
  334.                         int w, int h, ctrl_t *parent)
  335. {
  336.     progress_t  *prg;
  337.     int        len;
  338.  
  339.     if( !parent )
  340.         return NULL;
  341.  
  342.     prg = (progress_t*)create_control(sizeof(progress_t), id, x, y, w, h, parent);
  343.  
  344.     prg->ctrl.handler = prg_proc;
  345.  
  346.     prg->min        = 0;
  347.     prg->max        = 1;
  348.     prg->current    = 0;
  349.     prg->pos        = 0;
  350.  
  351.     return prg;
  352. };
  353.  
  354. int draw_level(level_t *lvl)
  355. {
  356.     int *pixmap;
  357.     ctx_t *ctx;
  358.     int i, j;
  359.     int x, y;
  360.  
  361.     int len;
  362.     double level;
  363.  
  364.     ctx = lvl->ctrl.ctx;
  365.  
  366.     lock_bitmap(ctx->pixmap);
  367.    
  368.     x = lvl->ctrl.rc.l - ctx->offset_x;
  369.     y = lvl->ctrl.rc.t - ctx->offset_y;
  370.  
  371.     level = (log2(lvl->current+1)-7)*12 + lvl->vol/50 ;
  372.  
  373.     len = level;
  374.  
  375.     if(len < 0)
  376.         len = 0;
  377.     if(len > 96)
  378.         len = 96;
  379.  
  380.     pixmap = (int*)ctx->pixmap->data;
  381.  
  382.     pixmap+=  y*ctx->pixmap->pitch/4 + x;
  383.  
  384.     for(i=0; i < 10; i++)
  385.     {
  386.         for(j = 0; j < 96; j++)
  387.            pixmap[j] = 0xFF1C1C1C;
  388.            pixmap+= ctx->pixmap->pitch/4;
  389.     };
  390.  
  391.     blit_raw(ctx, lvl->img_level, x, y, len, 10, 96*4);
  392.  
  393.     return 0;
  394. };
  395.  
  396.  
  397. int lvl_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
  398. {
  399.     level_t *lvl = (level_t*)ctrl;
  400. //    int pos;
  401.  
  402.     switch( msg )
  403.     {
  404.         case MSG_PAINT:
  405.             if(lvl->visible)
  406.             {
  407.                 draw_level(lvl);
  408.                 update_rect(ctrl);
  409.             };
  410.             break;
  411.  
  412. //        case MSG_LBTNDOWN:
  413. //            prg->pos = ((pos_t)arg2).x - ctrl->rc.l;
  414. //            send_message(ctrl->parent,MSG_COMMAND,ctrl->id,(int)ctrl);
  415. //            break;
  416.  
  417.         default:
  418.             break;
  419.     }
  420.     return 0;
  421. };
  422.  
  423. level_t    *create_level(char *caption, int id, int x, int y,
  424.                          int w, int h, ctrl_t *parent)
  425. {
  426.     level_t  *lvl;
  427.  
  428.     if( !parent )
  429.         return NULL;
  430.  
  431.     lvl = (level_t*)create_control(sizeof(level_t), id, x, y, w, h, parent);
  432.     lvl->ctrl.handler = lvl_proc;
  433.  
  434.     lvl->min          = 0;
  435.     lvl->max          = 1;
  436.     lvl->current      = 0;
  437.     lvl->pos          = 0;
  438.     lvl->visible      = 0;
  439.     lvl->img_level    = res_level;
  440.  
  441.     return lvl;
  442. };
  443.  
  444.  
  445. int draw_slider(slider_t *sld)
  446. {
  447.     int *pixmap;
  448.     ctx_t *ctx;
  449.     int i, j;
  450.     int x, y;
  451.  
  452.     int32_t len;
  453.     double level;
  454.  
  455.     ctx = sld->ctrl.ctx;
  456.  
  457.     lock_bitmap(ctx->pixmap);
  458.    
  459.     x = sld->ctrl.rc.l - ctx->offset_x;
  460.     y = sld->ctrl.rc.t - ctx->offset_y;
  461.  
  462.     len = 96 + 12;
  463.  
  464.     pixmap = (int*)ctx->pixmap->data;
  465.     pixmap+=  y*ctx->pixmap->pitch/4 + x;
  466.  
  467.     for(i=0; i < 11; i++)
  468.     {
  469.         for(j = 0; j < len; j++)
  470.            pixmap[j] = 0xFF1C1C1C;
  471.            pixmap+= ctx->pixmap->pitch/4;
  472.     };
  473.  
  474.     blit_raw(ctx, sld->img_vol_slider, x+6, y+4, 96, 4, 96*4);
  475.  
  476.     blit_raw(ctx, res_slider, x+sld->pos, y, 12, 11, 12*4);
  477.  
  478.     return 0;
  479. };
  480.  
  481.  
  482. int sld_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
  483. {
  484.     slider_t *sld = (slider_t*)ctrl;
  485.     int pos;
  486.  
  487.     switch( msg )
  488.     {
  489.         case MSG_PAINT:
  490.             draw_slider(sld);
  491.             update_rect(ctrl);
  492.             break;
  493.  
  494.         case MSG_LBTNDOWN:
  495.             capture_mouse(ctrl);
  496.             sld->mode = 1;
  497.  
  498.             pos = ((pos_t)arg2).x - ctrl->rc.l - 6;
  499.             if( pos < 0 )
  500.                 pos = 0;
  501.             else if(pos > 96)
  502.                 pos = 96;
  503.             if( sld->pos != pos)
  504.             {
  505.                 sld->pos = pos;
  506.                 send_message(ctrl->parent,MSG_COMMAND,ctrl->id,(int)ctrl);
  507.             };
  508.            break;
  509.  
  510.         case MSG_LBTNUP:
  511.             if(sld->mode)
  512.             {
  513.                 release_mouse();
  514.                 sld->mode = 0;
  515.             };
  516.             break;
  517.  
  518.         case MSG_MOUSEMOVE:
  519.             if(sld->mode)
  520.             {
  521.                 pos = ((pos_t)arg2).x - ctrl->rc.l - 6;
  522.                 if( pos < 0 )
  523.                     pos = 0;
  524.                 else if(pos > 96)
  525.                     pos = 96;
  526.                 if( sld->pos != pos)
  527.                 {
  528.                     sld->pos = pos;
  529. //                printf("slider pos %d\n", sld->pos);
  530.                     send_message(ctrl->parent,MSG_COMMAND,ctrl->id,(int)ctrl);
  531.                 }
  532.             };
  533.             break;
  534.  
  535.         case MSG_MOUSEENTER:
  536.             panel_set_layout(ctrl->parent, 1);
  537. //            printf("level on\n");
  538.             break;
  539.  
  540.         case MSG_MOUSELEAVE:
  541.             panel_set_layout(ctrl->parent, 0);
  542. //            printf("level off\n");
  543.             break;
  544.  
  545.  
  546.         default:
  547.             break;
  548.     }
  549.     return 0;
  550. };
  551.  
  552.  
  553. slider_t  *create_slider(char *caption, int id, int x, int y,
  554.                          int w, int h, ctrl_t *parent)
  555. {
  556.  
  557.     slider_t  *sld;
  558.  
  559.     if( !parent )
  560.         return NULL;
  561.  
  562.     sld = (slider_t*)create_control(sizeof(slider_t), id, x, y, w, h, parent);
  563.     sld->ctrl.handler = sld_proc;
  564.  
  565.     sld->min     = -5000;
  566.     sld->max     = 0;
  567.     sld->current = 0;
  568.     sld->pos     = 60;
  569.     sld->mode    = 0;
  570.     sld->img_vol_slider    = res_vol_slider;
  571.  
  572.     return sld;
  573. };
  574.  
  575.