Subversion Repositories Kolibri OS

Rev

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