Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.         main meneger loop libGUI library
  3. */
  4.  
  5. void LibGUImain(parent_t *WindowParent)
  6. {
  7.         DWORD                   event,key,value;
  8.         header_t                *control;
  9.         gui_message_t           *events_message;
  10.         gui_timer_t             *seek_timer,*exchange_timer;
  11.         gui_callbackevent_t     *seek_calev,*calev,*exchange_calev;
  12.         int                     i;
  13.         char                    quit;
  14.  
  15.  
  16.         events_message=(struct MESSAGE*)WindowParent->message;
  17.        
  18.         //tell all child controls of main parent who is main parent
  19.         events_message->type=MESSAGE_SET_MAIN_PARENT;
  20.         events_message->arg1=(DWORD)WindowParent;
  21.         SendMessage((struct HEADER *)WindowParent,events_message);
  22.  
  23.         //display all created controls in window
  24.         gui_draw_window(WindowParent);
  25.         events_message->type=MESSAGE_FULL_REDRAW_ALL;
  26.         SendMessage((struct HEADER *)WindowParent,events_message);
  27.  
  28.         events_message->type=0;
  29.  
  30.         quit=FALSE;
  31.         WindowParent->number_callbacks=0;
  32.  
  33.         while (quit==FALSE)
  34.         {
  35.                 //check for timers
  36.                 if ((WindowParent->timer_bk!=(DWORD*)NULL) ||
  37.                     (WindowParent->number_timers_for_controls!=0)) {event=gui_ksys_wait_event_with_timeout(1);}
  38.                         else    {event=gui_ksys_wait_event();}
  39.  
  40.                 //get and chack system events
  41.                 switch(event)
  42.                 {
  43.                         case KOLIBRIOS_SYS_EVENT_BUTTON_PRESSED:
  44.                         {
  45.                                 if (ControlCheckCallbackEvent(WindowParent,DELETE_EVENT)!=NULL)
  46.                                 {
  47.                                                 WindowParent->flags |= FLAG_CONNECT_EVENT_ON;
  48.                                                 WindowParent->control_for_callback_function[WindowParent->number_callbacks]=
  49.                                                 (DWORD*)WindowParent;
  50.                                                 WindowParent->callback_for_control_callback[WindowParent->number_callbacks]=
  51.                                                 (DWORD*)ControlCheckCallbackEvent(WindowParent,(DWORD)DELETE_EVENT);
  52.                                                 WindowParent->number_callbacks++;
  53.                                 }
  54.  
  55.                                 quit=TRUE;
  56.                                 break;
  57.                         }
  58.  
  59.                         case KOLIBRIOS_SYS_EVENT_REDRAW:
  60.                         {
  61.                                 GetNewWindowSizePos(WindowParent);
  62.                                 SetWindowSizeRequest(WindowParent,WindowParent->ctrl_sizex,WindowParent->ctrl_sizey);
  63.                                 gui_draw_window(WindowParent);
  64.                                
  65.                                 events_message->type=MESSAGE_FULL_REDRAW_ALL;
  66.                                 SendMessage((struct HEADER *)WindowParent,events_message);
  67.                                 break;
  68.                         }
  69.  
  70.                         case KOLIBRIOS_SYS_EVENT_KEYS:
  71.                         {
  72.                                 key=gui_ksys_get_key();
  73.  
  74.                                
  75.                                 key=key>>8;
  76.  
  77.                                 if (key & 128)
  78.                                 {
  79.                                         events_message->arg1=KEY_UP;
  80.                                         events_message->arg2=key & 127;
  81.                                 }
  82.                                         else
  83.                                 {
  84.                                         events_message->arg1=KEY_DOWN;
  85.                                         events_message->arg2=key;
  86.                                 }
  87.                                
  88.                                 events_message->type=MESSAGE_KEYS_EVENT;
  89.                                 SendMessage((struct HEADER *)WindowParent,events_message);
  90.                                 break;
  91.                         }
  92.  
  93.                         case KOLIBRIOS_SYS_EVENT_MOUSE:
  94.                         {
  95.                                 value=gui_ksys_get_window_mouse_coordinates();
  96.                                
  97.                                 events_message->type=MESSAGE_MOUSE_EVENT;
  98.                                 events_message->arg2=(value & 0xffff)-screen.y;//y
  99.                                 value=value >>16;
  100.                                 events_message->arg1=value-screen.x;//x
  101.  
  102.                                 value=gui_ksys_get_mouse_buttons_state();
  103.                                
  104.                                 switch(value)
  105.                                 {
  106.                                         case KOLIBRIOS_SYS_MOUSE_BUTTON_LEFT_DOWN:
  107.                                         {
  108.                                                 events_message->arg3=MOUSE_LEFT_BUTTON_DOWN;
  109.                                                 break;
  110.                                         }
  111.                                         case KOLIBRIOS_SYS_MOUSE_BUTTON_RIGHT_DOWN:
  112.                                         {
  113.                                                 events_message->arg3=MOUSE_RIGHT_BUTTON_DOWN;
  114.                                                 break;
  115.                                         }
  116.                                         case KOLIBRIOS_SYS_MOUSE_BUTTON_MIDDLE_DOWN:
  117.                                         {
  118.                                                 events_message->arg3=MOUSE_MIDDLE_BUTTON_DOWN;
  119.                                                 break;
  120.                                         }
  121.                                         case KOLIBRIOS_SYS_MOUSE_BUTTON_4_DOWN:
  122.                                         {
  123.                                                 events_message->arg3=MOUSE_4_BUTTON_DOWN;
  124.                                                 break;
  125.                                         }
  126.                                         case KOLIBRIOS_SYS_MOUSE_BUTTON_5_DOWN:
  127.                                         {
  128.                                                 events_message->arg3=MOUSE_5_BUTTON_DOWN;
  129.                                                 break;
  130.                                         }
  131.                                         default:
  132.                                         {
  133.                                                 if (events_message->arg3==MOUSE_LEFT_BUTTON_DOWN)
  134.                                                 {
  135.                                                         events_message->arg3=MOUSE_LEFT_BUTTON_UP;
  136.                                                         break;
  137.                                                 }
  138.                                                 if (events_message->arg3==MOUSE_RIGHT_BUTTON_DOWN)
  139.                                                 {
  140.                                                         events_message->arg3=MOUSE_RIGHT_BUTTON_UP;
  141.                                                         break;
  142.                                                 }
  143.                                                 if (events_message->arg3==MOUSE_MIDDLE_BUTTON_DOWN)
  144.                                                 {
  145.                                                         events_message->arg3=MOUSE_MIDDLE_BUTTON_UP;
  146.                                                         break;
  147.                                                 }
  148.                                                 if (events_message->arg3==MOUSE_4_BUTTON_DOWN)
  149.                                                 {
  150.                                                         events_message->arg3=MOUSE_4_BUTTON_UP;
  151.                                                         break;
  152.                                                 }
  153.                                                 if (events_message->arg3==MOUSE_5_BUTTON_DOWN)
  154.                                                 {
  155.                                                         events_message->arg3=MOUSE_5_BUTTON_UP;
  156.                                                         break;
  157.                                                 }
  158.  
  159.                                                 break;
  160.                                         }
  161.                                 }                              
  162.                                 SendMessage((struct HEADER *)WindowParent,events_message);
  163.                                 break;                          
  164.                         }
  165.                 }
  166.  
  167.                 //call functions for events
  168.                 seek_calev=(struct CALLBACKEVENT*)WindowParent->calev_bk;
  169.                 while(seek_calev!=(struct CALLBACKEVENT*)NULL)
  170.                 {
  171.                         if (seek_calev->event_type==events_message->type)
  172.                         {
  173.                                 CallbackFunctionForEvent=(void(*)(struct MESSAGE *message,void *data))seek_calev->func;
  174.                                 CallbackFunctionForEvent(events_message,seek_calev->func_data);
  175.                         }
  176.                         exchange_calev=(struct CALLBACKEVENT*)seek_calev->calev_fd;
  177.                         seek_calev=exchange_calev;
  178.                 }
  179.                
  180.  
  181.                 //call timers of controls
  182.                 if (WindowParent->number_timers_for_controls!=0)
  183.                 {
  184.                         events_message->type=(char)MESSAGE_CALL_TIMER_EVENT;
  185.                         SendMessage((struct HEADER *)WindowParent,events_message);
  186.                 }
  187.  
  188.                 //call callback functions
  189.                 for(i=0;i<WindowParent->number_callbacks;i++)
  190.                 {
  191.                         control=(struct HEADER*)WindowParent->control_for_callback_function[i];
  192.                         //check callback control
  193.                         if (control!=(header_t*)NULL)
  194.                         {
  195.                                 if (control->flags & FLAG_CONNECT_EVENT_ON)
  196.                                 {
  197.                                         calev=(struct CALLBACKEVENT*)
  198.                                         WindowParent->callback_for_control_callback[i];
  199. #ifdef DEBUG
  200.                                 printf("\ntry to call callback %d for function %d data %d",
  201.                                 (DWORD)calev,
  202.                                 (DWORD)calev->func,
  203.                                 (DWORD)calev->func_data);
  204. #endif
  205.  
  206.                                         CallbackFunction=(void (*)(header_t *Control,void *data))calev->func;
  207.                                         CallbackFunction(control,calev->func_data);
  208.  
  209.                                         control->flags=control->flags & FLAG_CONNECT_EVENT_OFF;
  210.                                 }
  211.                         }
  212.                 }
  213.                 WindowParent->number_callbacks=0;
  214.  
  215.                 //call timers of parent window
  216.                 seek_timer=(struct TIMER*)WindowParent->timer_bk;
  217.                 while(seek_timer!=(struct TIMER*)NULL)
  218.                 {
  219.                         if (seek_timer->flags & FLAG_TIMER_ON)  Timer(seek_timer);
  220.  
  221.                         exchange_timer=(struct TIMER*)seek_timer->tmr_fd;
  222.                         seek_timer=exchange_timer;
  223.                 }
  224.  
  225.                 //check for IDL function and call it if enabled
  226.                 if (WindowParent->IDL_func!=(DWORD*)NULL)
  227.                 {
  228.                         IDL_Function=(void(*)(void *data))WindowParent->IDL_func;
  229.                         IDL_Function(WindowParent->IDL_func_data);
  230.                 }
  231.  
  232.         }
  233. }
  234.