Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include "winlib.h"

static int draw_window(window_t *win);

uint32_t cursor_ns;

uint32_t cursor_we;

uint32_t cursor_nwse;

uint32_t cursor_nesw;

static uint32_t  realtime;

static uint32_t  wait_time;

static uint32_t  exp_time;

ctrl_t *win_get_child(window_t *win, int x, int y)

{

    ctrl_t *child = NULL;

    {

        if(pt_in_rect(&win->client, x, y))

        {

            ctrl_t *tmp = (ctrl_t*)win->child.next;

            {

                if(pt_in_rect(&tmp->rc, x, y))

                {

                    child = get_child(tmp, x, y);

                    return child == NULL ? tmp : child;

                };

                tmp = (ctrl_t*)tmp->link.next;

            };

        }

        else child = (ctrl_t*)(&win->frame);

    };

    return child;

};

                          int w, int h, handler_t handler)

{

    char proc_info[1024];

    int stride;

    DrawWindow(x, y, w-1, h-1,

               NULL,0,0x41);

    EndDraw();

    y = *(uint32_t*)(proc_info+38);

    w = *(uint32_t*)(proc_info+42)+1;

    h = *(uint32_t*)(proc_info+46)+1;

 //   Window.ctx = ctx;

    list_initialize(&Window.child);

//    Window.bitmap.height = 1080;

//    Window.bitmap.flags  = 0;

 //   {

 //       printf("not enough memory for window bitmap\n");

 //       return 0;

  //  }

 //   ctx->offset_x = 0;

 //   ctx->offset_y = 0;

    Window.rc.t = y;

    Window.rc.r = x + w;

    Window.rc.b = y + h;

    Window.h = h;

    Window.style = style;

    Window.child_focus = NULL;

    init_panel(&Window);

    init_frame(&Window);

    send_message((ctrl_t*)&Window, MSG_SIZE, 0, 0);

    return &Window;

};

{

    ctrl_t   *child;

    {

        case MSG_PAINT:

            draw_window(win);

            break;

            child  = (ctrl_t*)win->child.next;

            while( &child->link != &win->child)

            {

                send_message(child, 2, arg1, arg2);

                child = (ctrl_t*)child->link.next;

            };

            break;

            child = win_get_child(win, arg2 & 0xFFFF, (arg2>>16));

            if( win->child_over )

            {

                if(child == win->child_over)

                    send_message(child, msg, 0, arg2);

                else

                    send_message(win->child_over, MSG_MOUSELEAVE, 0, arg2);

            }

            else if( child )

                send_message(child, MSG_MOUSEENTER, 0, arg2);

            if( child )

                send_message(child,msg,0,arg2);

            else if(main_cursor != 0)

            {

                set_cursor(0);

                main_cursor = 0;

            }

            break;

            break;

            child = win_get_child(win, arg2 & 0xFFFF, (arg2>>16));

            win->child_over = child;

            if(child) send_message(child, msg, 0, arg2);

    };

}

{

    ctrl_t *child;

    void   *ctx;

    rect_t *rc = &win->client;

    draw_panel(&win->panel);

    send_message(win, MSG_DRAW_CLIENT,0,0);

//    {

//        send_message(child, 1, 0, 0);

//        child = (ctrl_t*)child->link.next;

//    };

};

{

    int w, h;

    h = win->client.b - win->client.t;

         0, 0, w, h, w, h,win->ctx->pixmap->pitch);

};

{

    win->win_state = state;

    DrawWindow(win->rc.l, win->rc.t, win->w-1, win->h-1,

               NULL,0,0x41);

    EndDraw();

    blit_panel(&win->panel);

//    blit_client(win);

    return 0;

}

{

    char proc_info[1024];

    uint8_t  state;

    winy = *(uint32_t*)(proc_info+38);

    winw = *(uint32_t*)(proc_info+42)+1;

    winh = *(uint32_t*)(proc_info+46)+1;

    {   win->win_state = MINIMIZED;

        return;

    }

    if(state & 4)

    {

        win->win_state = ROLLED;

        return;

    };

        state = MAXIMIZED;

    else

        state = NORMAL;

    {

        win->rc.l = winx;

        win->rc.t = winy;

        win->rc.r = winx + win->w;

        win->rc.b = winy + win->h;

    };

//        winh  == win->h &&

//        state == win->win_state)

//        return;

        win->win_state = state;

    int old_size;

    int new_size;

    int pitch;

    old_size = (old_size+4095) & ~4095;

    new_size = (new_size+4095) & ~4095;

        user_unmap(win->bitmap.data, new_size, old_size-new_size);

    win->bitmap.pitch = pitch;

#endif

    win->rc.b = winy + winh;

    win->w = winw;

    win->h = winh;

    update_panel_size(win);

    adjust_frame(win);

    draw_window(win);

};

{

    ctrl_t *child;

        return send_message(mouse_capture, msg, 0, old_pos.val);

        return send_message((ctrl_t*)win, msg, 0, old_pos.val);

        return 0;

    {

        return send_message(&win->caption.ctrl, msg, 0, old_pos.val);

    }

    {

//        old_pos.x-= win->panel.ctrl.rc.l;

//        old_pos.y-= win->panel.ctrl.rc.t;

        return send_message(&win->panel.ctrl, msg, 0, old_pos.val);

    }

//        send_message((ctrl_t*)win, msg, 0, old_pos.val);

};

{

//    printf("%s win:%x\n", __FUNCTION__, win);

    DrawWindow(0,0,0,0, NULL, 0x000000,0x41);

//    DefineButton(15, 15, 0x00000001, 0);

    EndDraw();

    {

        need_update=0;

        return;

    };

    blit_panel(&win->panel);

    need_update=0;

};

{

    static uint32_t  mouse_click_time;

    static int  mouse_action;

    static int  old_buttons;

    int         buttons;

    uint32_t    wheels;

    uint32_t    click_time;

    int         action;

    pos = GetMousePos(POS_WINDOW);

    {

        mouse_action = 0x80000000;

        old_pos = pos;

    };

//    printf("pos x%d y%d\n", pos.x, pos.y);

    wheels = get_mouse_wheels();

        wheels = (short)wheels>0 ? MSG_WHEELDOWN : MSG_WHEELUP;

        send_mouse_message(win, wheels);

    }

    {

        mouse_action|= action<<3;

        mouse_action|= buttons & ~old_buttons;

    }

    old_buttons = buttons;

        DBG("mouse move \n\r");

        send_mouse_message(win, MSG_MOUSEMOVE);

    };

    {

        if((mouse_action & 0x09)==0x09)

        {

//            printf("left button down x= %d y= %d\n\r", old_x.x, old_x.y);

            click_time = get_tick_count();

            if(click_time < mouse_click_time+35) {

                mouse_click_time = click_time;

                send_mouse_message(win,MSG_LBTNDBLCLK);

            }

            else {

              mouse_click_time = click_time;

              send_mouse_message(win,MSG_LBTNDOWN);

            };

        }

        else {

//            printf("left button up \n\r");

            send_mouse_message(win,MSG_LBTNUP);

        }

    };

    {

        if((mouse_action & 0x12)==0x12) {

            DBG("right button down \n\r");

            send_mouse_message(win,MSG_RBTNDOWN);

        }

        else {

            DBG("right button up \n\r");

            send_mouse_message(win,MSG_RBTNUP);

        };

    };

    if(mouse_action & 0x24)

    {

        if((mouse_action & 0x24)==0x24){

            DBG("middle button down \n\r");

            send_mouse_message(win,MSG_MBTNDOWN);

        }

        else {

            DBG("middle button up \n\r");

            send_mouse_message(win,MSG_MBTNUP);

        };

    };

{

    int ev;

    oskey_t   key;

//    wheels    = get_mouse_wheels();

    realtime  = get_tick_count();

    exp_time  = -1;

    {

        wait_time = exp_time - realtime;

//            exp_time = update_timers(realtime);

        {

            case MSG_PAINT:

                do_sys_draw(win);

                continue;

                printf("key pressed\n");

                key = get_key();

                if( key.state == 0)

                    send_message((ctrl_t*)win, ev, 0, key.code);

                continue;

                printf("Button pressed\n");

                continue;

                do_sys_mouse(win);

                continue;

                printf("event %d\n", ev);

                continue;

        };

    };

}

{

    int ev;

    oskey_t   key;

    int button;

    exp_time  = -1;

    {

        wait_time = exp_time - realtime;

//            exp_time = update_timers(realtime);

        {

            case MSG_PAINT:

                do_sys_draw(win);

                break;

                key = get_key();

                if( key.state == 0)

                    send_message((ctrl_t*)win, ev, 0, key.code);

                break;

                button = get_os_button();

                if(button == 1)

                    win->win_command = WIN_CLOSED;

                break;

                do_sys_mouse(win);

                break;

                break;

        };

    };

};

extern unsigned char res_cursor_we[];

extern unsigned char res_cursor_nwse[];

extern unsigned char res_cursor_nesw[];

{

    cursor_ns   = load_cursor(res_cursor_ns, LOAD_FROM_MEM);

    cursor_we   = load_cursor(res_cursor_we, LOAD_FROM_MEM);

    cursor_nwse = load_cursor(res_cursor_nwse, LOAD_FROM_MEM);

    cursor_nesw = load_cursor(res_cursor_nesw, LOAD_FROM_MEM);

}

{

    int ret;

    ret |= destroy_cursor(cursor_nwse);

    ret |= destroy_cursor(cursor_we);

    ret |= destroy_cursor(cursor_ns);

};

{

    __asm__ __volatile__(

    "int $0x40"

    ::"a"(40), "b"(0xC0000027));

    __asm__ __volatile__(

    "int $0x40"

    ::"a"(66), "b"(1),"c"(1));

    list_initialize(&timers);

};

//{

//    return &Window.client_ctx;

//};

{

    int ctx_w, ctx_h;

    int src_x, src_y;

    src_y = ctrl->rc.t - ctrl->ctx->offset_y;

    ctx_h = ctrl->parent->h;

         ctrl->w, ctrl->h, ctx_w, ctx_h, ctrl->ctx->pixmap->pitch);

};

                        int src_x, int src_y, int w, int h,

                        int src_w, int src_h, int stride)

{

    volatile struct blit_call bc;

    bc.dsty = dst_y;

    bc.w    = w;

    bc.h    = h;

    bc.srcx = src_x;

    bc.srcy = src_y;

    bc.srcw = src_w;

    bc.srch = src_h;

    bc.stride = stride;

    bc.bitmap = bitmap;

    "int $0x40"

    ::"a"(73),"b"(0x20),"c"(&bc.dstx));

{

    ctrl_t *child = NULL;

    {

        if(pt_in_rect(&tmp->rc, x, y))

        {

            child = get_child(tmp, x, y);

            return child == NULL ? tmp : child;

        };

        tmp = (ctrl_t*)tmp->link.next;

    };

    return child;

};

{

    ctrl_t *old = mouse_capture;

    "int $0x40"

    ::"a"(40), "b"(0x80000027));

}

{

    mouse_capture = NULL;

    __asm__ __volatile__(

    "int $0x40"

    ::"a"(40), "b"(0xC0000027));

}

>