Subversion Repositories Kolibri OS

Rev

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