Subversion Repositories Kolibri OS

Rev

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