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 <stdio.h>
  6. #include "winlib.h"
  7.  
  8. #define CAPTION_CORNER_W    8
  9.  
  10. extern int res_caption_left[];
  11. extern int res_caption_right[];
  12. extern int res_caption_body[];
  13.  
  14. extern int res_close_btn[];
  15. extern int res_close_btn_hl[];
  16. extern int res_close_btn_pressed[];
  17.  
  18. extern int res_minimize_btn[];
  19. extern int res_minimize_btn_hl[];
  20. extern int res_minimize_btn_pressed[];
  21.  
  22. extern uint32_t main_cursor;
  23.  
  24. void update_caption_size(window_t *win);
  25.  
  26. int caption_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2);
  27.  
  28.  
  29. int init_caption(window_t *win)
  30. {
  31.     button_t  *btn;
  32.  
  33.     caption_t *cpt = &win->caption;
  34.     ctx_t     *ctx = &cpt->ctx;
  35.  
  36.     link_initialize(&cpt->ctrl.link);
  37.     list_initialize(&cpt->ctrl.child);
  38.  
  39.     cpt->ctrl.handler = caption_proc;
  40.     cpt->ctrl.parent  = (ctrl_t*)win;
  41.  
  42.     cpt->text = win->caption_txt;
  43.  
  44.     ctx->pixmap = user_alloc(1920*CAPTION_HEIGHT*4);
  45.     if(!ctx->pixmap)
  46.     {
  47.         printf("not enough memory for caption bitmap\n");
  48.         return 0;
  49.     };
  50.  
  51. //    printf("win_w %d win_h %d\n", win->w, win->h);
  52.  
  53.     ctx->stride   = win->w*4;
  54.     ctx->offset_x = 0;
  55.     ctx->offset_y = 0;
  56.  
  57.     cpt->ctrl.ctx = ctx;
  58.  
  59.     btn = create_button(NULL, ID_CLOSE,0,5,16,18,(ctrl_t*)cpt);
  60.     cpt->close_btn = btn;
  61.  
  62.     btn->img_default = res_close_btn;
  63.     btn->img_hilite  = res_close_btn_hl;
  64.     btn->img_pressed = res_close_btn_pressed;
  65.  
  66.     btn = create_button(NULL, ID_MINIMIZE,0,5,16,18,(ctrl_t*)cpt);
  67.     cpt->minimize_btn = btn;
  68.  
  69.     btn->img_default = res_minimize_btn;
  70.     btn->img_hilite  = res_minimize_btn_hl;
  71.     btn->img_pressed = res_minimize_btn_pressed;
  72.  
  73.     update_caption_size(win);
  74.  
  75.     return 1;
  76. };
  77.  
  78.  
  79. void update_caption_size(window_t *win)
  80. {
  81.     caption_t *cpt = &win->caption;
  82.  
  83.     int old_size;
  84.     int new_size;
  85.     int stride;
  86.  
  87.     old_size = cpt->ctx.stride * CAPTION_HEIGHT;
  88.     old_size = (old_size+4095) & ~4095;
  89.  
  90.     stride = win->w*4;
  91.  
  92.     new_size = stride * CAPTION_HEIGHT;
  93.     new_size = (new_size+4095) & ~4095;
  94.  
  95.     if( new_size < old_size)
  96.         user_unmap(cpt->ctx.pixmap, new_size, old_size-new_size);
  97.  
  98.     cpt->ctx.stride = stride;
  99.  
  100.     cpt->ctrl.rc.l    = 0;
  101.     cpt->ctrl.rc.t    = 0;
  102.     cpt->ctrl.rc.r    = win->w;
  103.     cpt->ctrl.rc.b    = CAPTION_HEIGHT;
  104.     cpt->ctrl.w       = win->w;
  105.     cpt->ctrl.h       = CAPTION_HEIGHT;
  106.     win->client.t     = CAPTION_HEIGHT;
  107.  
  108.     cpt->close_btn->ctrl.rc.l = win->w - 25;
  109.     cpt->close_btn->ctrl.rc.r = cpt->close_btn->ctrl.rc.l +
  110.                            cpt->close_btn->ctrl.w;
  111.  
  112.     cpt->minimize_btn->ctrl.rc.l = win->w - 25 - 16 - 5;
  113.     cpt->minimize_btn->ctrl.rc.r = cpt->minimize_btn->ctrl.rc.l +
  114.                            cpt->minimize_btn->ctrl.w;
  115.  
  116. };
  117.  
  118. typedef struct
  119. {
  120.     uint32_t    width;
  121.     uint32_t    height;
  122.     uint32_t    pitch;
  123.     uint32_t    handle;
  124.     uint8_t    *data;
  125. }bitmap_t;
  126.  
  127. extern int win_font;
  128.  
  129. void draw_caption(caption_t *cpt)
  130. {
  131.     int *pixmap, *src;
  132.     int  i, j, w;
  133.  
  134.     pixmap = cpt->ctx.pixmap;
  135.     src = res_caption_left;
  136.  
  137.     for(i=0; i < CAPTION_HEIGHT; i++)
  138.     {
  139.         for(j=0; j < CAPTION_CORNER_W; j++)
  140.             pixmap[j] = src[j];
  141.         pixmap+= cpt->ctx.stride/4;
  142.         src+= CAPTION_CORNER_W;
  143.     };
  144.  
  145.     w = cpt->ctrl.w - (2*CAPTION_CORNER_W);
  146.     if( w > 0)
  147.     {
  148.         pixmap = cpt->ctx.pixmap;
  149.         pixmap+= CAPTION_CORNER_W;
  150.         src = res_caption_body;
  151.  
  152.         for(i = 0; i < CAPTION_HEIGHT; i++)
  153.         {
  154.             for(j = 0; j < w; j++)
  155.                 pixmap[j] = src[i];
  156.             pixmap+= cpt->ctx.stride/4;
  157.         }
  158.     };
  159.  
  160.     pixmap = cpt->ctx.pixmap;
  161.     pixmap+= cpt->ctrl.w - CAPTION_CORNER_W;
  162.  
  163.     src = res_caption_right;
  164.  
  165.     for(i = 0; i < CAPTION_HEIGHT; i++)
  166.     {
  167.         for(j = 0; j < CAPTION_CORNER_W; j++)
  168.             pixmap[j] = src[j];
  169.         pixmap+= cpt->ctx.stride/4;
  170.         src+= CAPTION_CORNER_W;
  171.     };
  172.  
  173.     bitmap_t bitmap;
  174.  
  175.     bitmap.data  = cpt->ctx.pixmap;
  176.     bitmap.pitch = cpt->ctx.stride;
  177.  
  178.     draw_text(&bitmap, win_font, cpt->text, 8, 18, 0xFFFFFFFF);
  179.  
  180.     ctrl_t *child;
  181.     child  = (ctrl_t*)cpt->ctrl.child.next;
  182.  
  183.     while( &child->link != &cpt->ctrl.child)
  184.     {
  185.         send_message(child, 1, 0, 0);
  186.         child = (ctrl_t*)child->link.next;
  187.     };
  188. };
  189.  
  190.  
  191. int caption_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
  192. {
  193.     caption_t *cpt = (caption_t*)ctrl;
  194.     window_t *win  = (window_t*)ctrl->parent;
  195.  
  196.     ctrl_t *child;
  197.     int x, y;
  198.  
  199.     x = ((pos_t)arg2).x;
  200.     y = ((pos_t)arg2).y;
  201.  
  202.     switch( msg )
  203.     {
  204.         case 1:
  205.             break;
  206.  
  207.  
  208.         case MSG_MOUSEMOVE:
  209.             child = get_child(ctrl, x, y);
  210.             if( win->child_over )
  211.             {
  212.                 if(child == win->child_over)
  213.                     send_message(child, msg, 0, arg2);
  214.                 else
  215.                     send_message(win->child_over, MSG_MOUSELEAVE, 0, arg2);
  216.             };
  217.  
  218.             win->child_over = child;
  219.             if( child )
  220.             {
  221.                 send_message(child, MSG_MOUSEENTER, 0, arg2);
  222.                 send_message(child,msg,0,arg2);
  223.             }
  224.             else if(main_cursor != 0)
  225.             {
  226.                 set_cursor(0);
  227.                 main_cursor = 0;
  228.             }
  229.             break;
  230.  
  231.  
  232.         case MSG_COMMAND:
  233.             switch((short)arg1)
  234.             {
  235.                 case ID_CLOSE:
  236.                     win = (window_t*)ctrl->parent;
  237.                     win->win_command = WIN_CLOSED;
  238.                     break;
  239.  
  240.                 case ID_MINIMIZE:
  241.                     __asm__ __volatile__(
  242.                     "int $0x40"
  243.                     ::"a"(18),"b"(10));
  244.                     break;
  245.                 default:
  246.                     break;
  247.             };
  248.  
  249.         default:
  250.             child = get_child(ctrl, x, y);
  251.             if(child)
  252.                 return send_message(child, msg, 0, arg2);
  253.     }
  254.     return 1;
  255. };
  256.  
  257.  
  258.  
  259. void blit_caption(caption_t *cpt)
  260. {
  261. //    printf("%s w:%d h:%d stride: %d\n",__FUNCTION__,
  262. //            cpt->ctrl.w, cpt->ctrl.h, cpt->ctx.stride);
  263.  
  264.     Blit(cpt->ctx.pixmap, 0, 0, 0, 0, cpt->ctrl.w, cpt->ctrl.h,
  265.          cpt->ctrl.w, cpt->ctrl.h, cpt->ctx.stride);
  266. };
  267.  
  268.