Anubis / Anubis

   
   
   
                             The Anubis/Paradize Project.
   
                      Opening a host window containing widgets. 
   
                        Copyright (c) Alain Prouté 2004-2005. 

   
   Authors:   Alain Prouté
   
      
read widget.anubis   
   

   *** (1) Opening a host window containing a widget. 
      
   In order to open a host window with a widget inside, use the following:
   
public define Bool
   open_host_window
     (
       Int32 x, Int32 y,       // position of host window on screen
       String title,           // title of host window
       Widget content          // content of host window
     ).
      
   The value returned is 'true' if and only  if the host window has been created. The size
   of the host window is adapted to the size of the content. Here is a variant which opens
   the host window centered in the screen:
   
public define Bool
   open_host_window
     (
       String title, 
       Widget content
     ). 

   
   

   *** (2) A simple example. 
   
   In order to help to understand how to use widgets, we provide a example, which is of no
   use by itself, but illustrates as simply  as possible the main principles of the widget
   system:
   
      - constructing a tree of widgets,
      - using state variables,
      - monitoring variables in order to be always up to date. 

   The  example   (fully  commented   and  ready   to  be  compiled)   may  be   found  in
   'widgets3/simple_example.anubis'.
   
   
   
   
   
   --- That's all for the public part ! --------------------------------------------------
   
      
   
 read widgets3/trace.anubis   
   
   
   
   
   *** The paint method
   
   Given the  rectangle 'clip' within which painting  must occur, we first  divide it into
   rectangles small  enough to fit into the  (double) buffer. Then, for  each rectangle we
   redraw  the root  widget within  this rectangle,  but into  the buffer.  The  buffer is
   positioned at the same  place as the rectangle in the host  window. Finally, the buffer
   is mapped to the host window.
   
   
read tools.anubis   
   
define (HostWindow,List(Rectangle)) -> One
   widget_paint_method
     (
       HostImage buffer, 
       Widget root_widget
     )  =
   with black = rgb(0,0,0), 
   (HostWindow win, List(Rectangle) clips) |->
      set_position(root_widget)(position_tool_box(0,0),position(0,0)); 
      if size(buffer) is (width_b,height_b) then 
      if size(win) is (win_width,win_height) then 
      with wrects = divide(rect(0,0,win_width,win_height),width_b,height_b), 
      if get_size(root_widget)(unique) is (root_w,root_h) then 
      //with clips = (List(Rectangle))[rect(0,30,300,90)], 
   
      //print("Subdivision:\n"); 
      //print(wrects); 
      //print("Clipping:\n"); 
      //print(clips); 
   
      map_forget((Rectangle wr) |-> 
          map_forget((Rectangle cr) |-> 
              if cr is rect(cx,cy,cu,cv) then 
              if wr is rect(bx,by,bu,bv) then 
              redraw(root_widget)(draw_tool_box(win,buffer,bx,by,0,0,cx,cy,cu,cv)); 
              paint_image(win,cr,bx,by,buffer),
            clips),
        wrects). 
   
   
   
      map_forget((Rectangle clip) |-> 
        (if clip is rect(cx,cy,cu,cv) then 
         if (cx < cu & cy < cv)
         then (
               with clip1 = (Rectangle)rect(max(0,cx),max(0,cy),cu,cv),
               with rects = divide(clip1,width_b,height_b), 
               forget(map(
                 (Rectangle r) |-> if r is rect(x,y,u,v) then 
                                   (
                                     //paint_rectangle(buffer,rect(0,0,u-x,v-y),black);
                                     redraw(root_widget)(draw_tool_box(win,buffer,x,y,0,0,x,y,u,v));
                                     paint_image(win,r,x,y,buffer)
                                   ),
               rects)))
             else unique),
        clips). 
   
   
   
   
   
   *** Events handling. 
   
   
   We must translate a widget answer into a list of rectangles.
   
define List(Rectangle)
   translate
     (
       HostWindow win, 
       WidgetAnswer a
     ) =
   if a is 
     {
       not_handled(l)  then if size(win) is (w,h) then 
                              map((WidgetRectangle wr) |-> 
                                    if wr is rect(x,y,u,v) then 
                                      rect(max(0,x),max(0,y),min(w,u),min(h,v)),
                                  l),
       handled(l)      then if size(win) is (w,h) then 
                              map((WidgetRectangle wr) |-> 
                                    if wr is rect(x,y,u,v) then 
                                      rect(max(0,x),max(0,y),min(w,u),min(h,v)),
                                  l),
       resized         then if size(win) is (w,h) then [rect(0,0,w,h)]
     }.
   

define Rectangle
   dummy_send_r
     (
       WidgetRectangle r
     ) =
   rect(0,0,0,0). 
   
define WidgetRectangle
   dummy_recv_r
     (
       Rectangle r
     ) =
   rect(0,0,0,0). 
   
   
   
   Handling events in widgets. 
   
define (HostWindow win, HostWindowEvent(One) e) -> List(Rectangle)   
   widget_event_handler
     (
       Widget                                                                 root_widget,
       Var((Var((Int32,Int32)),
            (KeyboardState ks, KeyboardKey k) -> WidgetAnswer,
            (List(WidgetRectangle) -> One redraw) -> One))                    k_handler_loc, 
       Var(Var(Bool))                                                         k_handler_v, 
       Var(Maybe((Var((Int32,Int32)),
                  (KeyboardState,WidgetMouseCapturedEvent) -> WidgetAnswer))) m_handler_loc,
       Var(Var(Bool))                                                         m_handler_v,
       Var(One)                                                               tick_v
     ) =
   (HostWindow win, HostWindowEvent(One) e) |-> 
   with dummy_p_v = var(((Int32,Int32))(0,0)), 
     if e is 
       {
         quit                   then alert, 
         expose                 then alert, 
         pointer_entering       then [ ], 
         pointer_leaving        then 
           translate(win,if *m_handler_loc is 
                       {
                         failure     then main_event_handler(root_widget)
                                           (event_tool_box(win,
                                                           dummy_p_v,k_handler_loc,k_handler_v,
                                                                     m_handler_loc,m_handler_v,
                                                                     tick_v,dummy_send_r,dummy_recv_r),
                                            mouse_gone),
                         success(xyh) then handled([])
                       }), 
         key_down(ks,k)         then if *k_handler_loc is (pos_loc,handler,eoc) then 
                                     if *pos_loc is (wx,wy) then 
                                     if handler(ks,k) is 
                                       {
                                         not_handled(l)  then 
                                           map((WidgetRectangle wr) |->
                                             if wr is rect(x,y,u,v) then 
                                               rect(x+wx,y+wy,u+wx,v+wy),l)
                                         handled(l)  then 
                                           map((WidgetRectangle wr) |->
                                             if wr is rect(x,y,u,v) then 
                                               rect(x+wx,y+wy,u+wx,v+wy),l)
                                         resized     then if size(win) is (w,h) then [rect(0,0,w,h)],
                                       }, 
         mouse_move(ks,x,y)     then 
           translate(win,if *m_handler_loc is 
                       {
                         failure     then main_event_handler(root_widget)
                                           (event_tool_box(win,
                                                           dummy_p_v,k_handler_loc,k_handler_v,
                                                                     m_handler_loc,m_handler_v,
                                                                     tick_v,dummy_send_r,dummy_recv_r),
                                            mouse_move(ks,x,y)),
                         success(xyh) then if xyh is (p_v,h) then if *p_v is (wx,wy) then 
                           if h(ks,moved(x-wx,y-wy)) is
                             {
                               not_handled(l)     then 
                                 not_handled(map((WidgetRectangle r) |->
                                   if r is rect(x,y,u,v) then rect(x+wx,y+wy,u+wx,v+wy),l)),
                               handled(l)     then 
                                 handled(map((WidgetRectangle r) |->
                                   if r is rect(x,y,u,v) then rect(x+wx,y+wy,u+wx,v+wy),l)),
                               resized        then resized
                             }
                       }), 
         mouse_click(ks,mc,x,y) then 
           translate(win,if *m_handler_loc is 
                       {
                         failure then main_event_handler(root_widget)
                                         (event_tool_box(win,
                                                         dummy_p_v,k_handler_loc,k_handler_v,
                                                                   m_handler_loc,m_handler_v,
                                                                   tick_v,dummy_send_r,dummy_recv_r),
                                          mouse_click(ks,mc,x,y)), 
                         success(xyh) then if xyh is (p_v,h) then if *p_v is (wx,wy) then 
                           m_handler_loc <- failure; 
                           (*m_handler_v) <- false; 
                           if h(ks,liberated(x-wx,y-wy)) is 
                             {
                               not_handled(l)     then 
                                 not_handled(map((WidgetRectangle r) |-> 
                                   if r is rect(x,y,u,v) then rect(x+wx,y+wy,u+wx,v+wy),l)),
                               handled(l)     then 
                                 handled(map((WidgetRectangle r) |-> 
                                   if r is rect(x,y,u,v) then rect(x+wx,y+wy,u+wx,v+wy),l)),
                               resized        then resized
                             }
                       }), 
         mouse_wheel(ks,d,x,y)  then [ ], 
         tick                   then tick_v <- unique; [ ], 
         repaint(l)             then l,
         specific(_)            then [ ]
       }.
   
   
   
   
   
   *** Events compression. 
   
   Events compression is necessary, because in  general too many window events arrive. The
   generic host  window handler (see  'predefined.anubis') recovers window events  not one
   after  the other  but  all  available events  in  a list  of  events (in  chronological
   order). This list must be optimized (compressed).
   
   The compression  is a kind  of rewritting  of the list.  We have choosen  the following
   rewrite rules:
   
     [expose . t]  --> [expose]          because expose redraws the whole window
     [mouse_move(ks1,x1,y1), mouse_move(ks2,x2,y2) . t] --> [mouse_move(ks2,x2,y2) . t]
   
   define List(HostWindowEvent(One))
   compress_events
     (
       List(HostWindowEvent(One)) l
     ) =
   if l is 
     {
       [ ] then [ ],
       [e1 . es1] then 
         if e1 is expose then [expose] else
         if e1 is pointer_entering then compress_events(es1) else
         if e1 is mouse_move(ks1,x1,y1) then if es1 is 
           {
             [ ] then l,
             [e2 . es2] then if e2 is mouse_move(ks2,x2,y2) 
                             then compress_events(es1)
                             else [e1 . compress_events(es1)]
           }
         else [e1 . compress_events(es1)]
     }.
   
define Bool     
   has_mouse_move
     (
       List(HostWindowEvent(One)) l
     ) =
     if l is 
       {
	       [] then false,
	       [e . es] then if e is mouse_move(_,_,_) then true else has_mouse_move(es)
       }.            

 
define List(HostWindowEvent(One))     
     compress_events1
       (
         List(HostWindowEvent(One)) l
       ) =
     if l is 
       {
	       [] then [], 
	       [e . es] then with es1 = compress_events1(es), 
	         if e is
	           {
		           quit                   then [quit], 
		           expose                 then [expose],
		           pointer_entering       then if member(es1,e) then es1 else [e . es1],
		           pointer_leaving        then if member(es1,e) then es1 else [e . es1],
		           key_down(_,_)          then [e . es1],
		           mouse_move(_,_,_)      then if has_mouse_move(es1) then es1 else [e . es1],
		           mouse_click(_,_,_,_)   then [e . es1],
		           mouse_wheel(_,_,_,_)   then [e . es1],
		           tick                   then [e . es1],
		           repaint(_)             then [e . es1],
		           specific(_)            then [e . es1]
	           }
       }.
   
       
define List(HostWindowEvent(One))     
     compress_events
       (
         List(HostWindowEvent(One)) l
       ) =
    with n = length(l), 
    result = compress_events1(l), 
    //print(n+" ---> "+length(result)+"\n");
    result. 
       
       
       
   *** Opening a host window with a root widget. 
   
   The function 'open_host_window' below creates  the buffer and the locations for capture
   handlers, sets the positions of the widgets and opens the host window.
   
public define Bool
   open_host_window
     (
       Int32                       x,   // position of host window on screen
       Int32                       y, 
       String                  title,   // title of host window
       Widget                content    // root widget in host window
     ) =
   with     buffer = to_host_image(create_rgba_image(1000,800,rgba(0,0,0,0)),1), 
     k_handler_loc = var((var(((Int32,Int32))(0,0)),
                          (KeyboardState ks, KeyboardKey k) |-> handled([]),
                          (List(WidgetRectangle) -> One rd) |-> unique)), 
     k_handler_v   = var(var((Bool)false)),
     m_handler_loc = var((Maybe((Var((Int32,Int32)),
                                 (KeyboardState,WidgetMouseCapturedEvent) -> WidgetAnswer)))failure),
     m_handler_v   = var(var((Bool)false)),
            tick_v = var((One)unique), 
   //with content = duplicate(content)(unique), 
   set_position(content)(position_tool_box(0,0),position(0,0)); 
   if get_size(content)(unique) is (w,h) then 
   if open_host_window(rect(x,y,x+w,y+h),
                       title,
                       managed, 
                       widget_paint_method(buffer,content),
                      (HostWindow win, HostWindowEvent(One) e) |->
                         with answer =
                           widget_event_handler(content,k_handler_loc,k_handler_v,
                                                        m_handler_loc,m_handler_v,
                                                        tick_v)(win,e),
                         set_position(content)(position_tool_box(0,0),position(0,0));
                         //(if e is tick then unique else (print("answer:\n"); print(answer))); 
                         answer, 
                       compress_events) is 
     {
       failure then print("Cannot open the window.\n"); false,
       success(win) then show(win); true
     }.
   
read tools/basis.anubis
   
public define Bool
   open_host_window
     (
       String title, 
       Widget content
     ) = 
   if get_size(content)(unique) is (w,h) then
   if screen_size is (sw,sh) then 
   open_host_window((max(0,sw-w))>>1,(max(0,sh-h))>>1,
                    title, 
                    content).