Usermode/Applications/axwin3_src/WM/renderers/widget.c

   1 /*
   2  * Acess2 Window Manager v3
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * render_widget.c
   6  * - AxWin2 Widget port
   7  */
   8 #include <common.h>
   9 #include <wm_renderer.h>
  10 #include <renderer_widget.h>
  11 #include <string.h>
  12 #include <wm_messages.h>
  13 #include <stdlib.h>
  14 #include "widget/common.h"
  15
  16 #define DEFAULT_ELETABLE_SIZE   64
  17 #define BORDER_EVERYTHING       0
  18
  19 // === PROTOTYPES ===
  20  int    Renderer_Widget_Init(void);
  21 tWindow *Renderer_Widget_Create(int Flags);
  22 void    Renderer_Widget_Redraw(tWindow *Window);
  23
  24 void    Widget_RenderWidget(tWindow *Window, tElement *Element);
  25 void    Widget_UpdateDimensions(tElement *Element);
  26 void    Widget_UpdatePosition(tElement *Element);
  27 // --- Messages
  28 tElement        *Widget_GetElementById(tWidgetWin *Info, uint32_t ID);
  29 void    Widget_NewWidget(tWidgetWin *Info, size_t Len, const tWidgetMsg_Create *Msg);
  30 void    Widget_SetFlags(tWidgetWin *Info, int Len, const tWidgetMsg_SetFlags *Msg);
  31 void    Widget_SetSize(tWidgetWin *Info, int Len, const tWidgetMsg_SetSize *Msg);
  32 void    Widget_SetText(tWidgetWin *Info, int Len, const tWidgetMsg_SetText *Msg);
  33  int    Renderer_Widget_HandleMessage(tWindow *Target, int Msg, int Len, const void *Data);
  34
  35 // === GLOBALS ===
  36 tWMRenderer     gRenderer_Widget = {
  37         .Name = "Widget",
  38         .CreateWindow = Renderer_Widget_Create,
  39         .Redraw = Renderer_Widget_Redraw,
  40         .HandleMessage = Renderer_Widget_HandleMessage
  41 };
  42
  43 // --- Element callbacks
  44 tWidgetDef      *gaWM_WidgetTypes[NUM_ELETYPES];
  45 const int       ciWM_NumWidgetTypes = sizeof(gaWM_WidgetTypes)/sizeof(gaWM_WidgetTypes[0]);
  46 tWidgetDef      gWidget_NullWidgetDef;
  47
  48 // === CODE ===
  49 int Renderer_Widget_Init(void)
  50 {
  51          int    i;
  52         WM_RegisterRenderer(&gRenderer_Widget);
  53
  54         for(i = 0; i < ciWM_NumWidgetTypes; i ++)
  55         {
  56                 if(gaWM_WidgetTypes[i] != NULL) continue;
  57
  58                 gaWM_WidgetTypes[i] = &gWidget_NullWidgetDef;
  59         }
  60
  61         return 0;
  62 }
  63
  64 void Widget_int_SetTypeDef(int Type, tWidgetDef *Ptr)
  65 {
  66         if( Type < 0 || Type >= ciWM_NumWidgetTypes ) {
  67                 _SysDebug("ERROR - Widget ID %i out of range (from %p)",
  68                         Type, __builtin_return_address(0)
  69                         );
  70                 return ;
  71         }
  72
  73         if( gaWM_WidgetTypes[Type] && gaWM_WidgetTypes[Type] != &gWidget_NullWidgetDef )
  74         {
  75                 _SysDebug("ERROR - Widget ID %i redefined by %p",
  76                         Type, __builtin_return_address(0)
  77                         );
  78                 return ;
  79         }
  80
  81         gaWM_WidgetTypes[Type] = Ptr;
  82 }
  83
  84 tWindow *Renderer_Widget_Create(int Flags)
  85 {
  86         tWindow *ret;
  87         tWidgetWin      *info;
  88          int    eletable_size = DEFAULT_ELETABLE_SIZE;
  89
  90         //_SysDebug("Renderer_Widget_Create: (Flags = 0x%x)", Flags);
  91
  92         // TODO: Use `Flags` as default element count?
  93         // - Actaully, it's taken by the root ele flags
  94         // - Use the upper bits?
  95
  96         ret = WM_CreateWindowStruct( sizeof(tWidgetWin) + sizeof(tElement*)*eletable_size );
  97         info = ret->RendererInfo;
  98
  99         info->TableSize = eletable_size;
 100         info->FocusedElement = &info->RootElement;
 101         info->RootElement.Window = ret;
 102         info->RootElement.ID = -1;
 103         info->RootElement.BackgroundColour = 0xCCCCCC;
 104         info->RootElement.Flags = Flags;
 105         info->RootElement.PaddingT = 2;
 106         info->RootElement.PaddingB = 2;
 107         info->RootElement.PaddingL = 2;
 108         info->RootElement.PaddingR = 2;
 109
 110         return ret;
 111 }
 112
 113 void Renderer_Widget_Redraw(tWindow *Window)
 114 {
 115         tWidgetWin      *info = Window->RendererInfo;
 116         WM_Render_FillRect(Window, 0, 0, Window->W, Window->H, info->RootElement.BackgroundColour);
 117
 118         Widget_UpdateDimensions(&info->RootElement);
 119         Widget_UpdatePosition(&info->RootElement);
 120
 121         Widget_RenderWidget(Window, &info->RootElement);
 122 }
 123
 124 // --- Render / Resize ---
 125 void Widget_RenderWidget(tWindow *Window, tElement *Element)
 126 {
 127         tElement        *child;
 128
 129         if( Element->Flags & ELEFLAG_NORENDER ) return ;
 130         if( Element->Flags & ELEFLAG_INVISIBLE )        return ;
 131
 132         #if BORDER_EVERYTHING
 133         WM_Render_DrawRect(
 134                 Window,
 135                 Element->CachedX, Element->CachedY,
 136                 Element->CachedW, Element->CachedH,
 137                 0
 138                 );
 139         #endif
 140
 141         if(gaWM_WidgetTypes[Element->Type]->Render)
 142         {
 143                 gaWM_WidgetTypes[Element->Type]->Render(Window, Element);
 144         }
 145
 146         for(child = Element->FirstChild; child; child = child->NextSibling)
 147         {
 148                 Widget_RenderWidget(Window, child);
 149         }
 150 }
 151
 152 void Widget_UpdateDimensions(tElement *Element)
 153 {
 154         tElement        *child;
 155          int    nChildren = 0;
 156          int    nFixed = 0;
 157          int    maxCross = 0;
 158          int    fixedSize = 0;
 159          int    fullCross, dynWith = 0;
 160          int    bVertical = Element->Flags & ELEFLAG_VERTICAL;
 161
 162         // Check if this element can have children
 163         if( (gaWM_WidgetTypes[Element->Type]->Flags & WIDGETTYPE_FLAG_NOCHILDREN) )
 164                 return ;
 165
 166         // Pass 1
 167         // - Get the fixed and minimum sizes of the element
 168         for( child = Element->FirstChild; child; child = child->NextSibling )
 169         {
 170                  int    minWith  = bVertical ? child->MinH : child->MinW;
 171                  int    minCross = bVertical ? child->MinW : child->MinH;
 172
 173                 // Ignore elements that will not be rendered
 174                 if( child->Flags & ELEFLAG_NORENDER )   continue ;
 175
 176                 // Absolutely positioned elements don't affect dimensions
 177                 if( child->Flags & ELEFLAG_ABSOLUTEPOS )        continue ;
 178
 179                 // Fixed width elements
 180                 if( child->FixedWith )
 181                 {
 182                         nFixed ++;
 183                         fixedSize += child->FixedWith;
 184                 }
 185                 else if( child->Flags & ELEFLAG_NOSTRETCH )
 186                 {
 187                         nFixed ++;
 188                         fixedSize += minWith;
 189                 }
 190
 191                 if( maxCross < child->FixedCross )      maxCross = child->FixedCross;
 192                 if( maxCross < minCross )       maxCross = minCross;
 193                 nChildren ++;
 194         }
 195
 196         // Get the dynamic with size from the unused space in the element
 197         if( nChildren > nFixed ) {
 198                 if( bVertical )
 199                         dynWith = Element->CachedH - Element->PaddingT - Element->PaddingB;
 200                 else
 201                         dynWith = Element->CachedW - Element->PaddingL - Element->PaddingR;
 202                 dynWith -= fixedSize;
 203                 dynWith -= Element->GapSize * (nChildren-1);
 204                 if( dynWith < 0 )       return ;
 205                 dynWith /= nChildren - nFixed;
 206         }
 207         else {
 208                 dynWith = 0;
 209         }
 210
 211         // Get the cross size
 212         if( bVertical )
 213                 fullCross = Element->CachedW - Element->PaddingL - Element->PaddingR;
 214         else
 215                 fullCross = Element->CachedH - Element->PaddingT - Element->PaddingB;
 216
 217         //_SysDebug("%i (p=%i) - WxH=%ix%i",
 218         //      Element->ID, (Element->Parent ? Element->Parent->ID : -1),
 219         //      Element->CachedW, Element->CachedH
 220         //      );
 221         //_SysDebug("  %s dynWith = %i, fullCross = %i",
 222         //      (Element->Flags & ELEFLAG_VERTICAL ? "Vert" : "Horiz"),
 223         //      dynWith, fullCross
 224         //      );
 225
 226         // Pass 2 - Set sizes and recurse
 227         for( child = Element->FirstChild; child; child = child->NextSibling )
 228         {
 229                  int    w, h;
 230
 231                 // Ignore elements that will not be rendered
 232                 if( child->Flags & ELEFLAG_NORENDER )   continue ;
 233                 // Don't resize floating elements
 234                 if( child->Flags & ELEFLAG_ABSOLUTEPOS )        continue ;
 235
 236                 // --- Width ---
 237                 if( child->Flags & ELEFLAG_NOEXPAND )
 238                         w = child->MinW;
 239                 else if( bVertical )
 240                         w = child->FixedCross ? child->FixedCross : fullCross;
 241                 else
 242                         w = child->FixedWith ? child->FixedWith : dynWith;
 243
 244                 // --- Height ---
 245                 if( child->Flags & ELEFLAG_NOSTRETCH )
 246                         h = child->MinH;
 247                 else if( bVertical )
 248                         h = child->FixedWith ? child->FixedWith : dynWith;
 249                 else
 250                         h = child->FixedCross ? child->FixedCross : fullCross;
 251
 252                 if(w < child->MinW)     w = child->MinW;
 253                 if(h < child->MinH)     h = child->MinH;
 254
 255 //              _SysDebug("Child %ix%i (min %ix%i)", w, h, child->MinW, child->MinH);
 256
 257                 // Update the dimensions if they have changed
 258                 if( child->CachedW == w && child->CachedH == h )
 259                         continue ;
 260                 child->CachedW = w;
 261                 child->CachedH = h;
 262
 263                 // Force the positions of child elements to be recalculated
 264                 child->CachedX = -1;
 265
 266                 // Recurse down so the child elements can be updated
 267                 Widget_UpdateDimensions(child);
 268         }
 269
 270 }
 271
 272 /**
 273  * \brief Update the position of child elements
 274  */
 275 void Widget_UpdatePosition(tElement *Element)
 276 {
 277         tElement        *child;
 278          int    x, y;
 279
 280         if( Element->Flags & ELEFLAG_NORENDER ) return ;
 281
 282         // Check if this element can have children
 283         if( (gaWM_WidgetTypes[Element->Type]->Flags & WIDGETTYPE_FLAG_NOCHILDREN) )
 284                 return ;
 285
 286 //      _SysDebug("Widget_UpdatePosition: (Element=%p(%i Type=%i Flags=0x%x))",
 287 //              Element, Element->ID, Element->Type, Element->Flags);
 288
 289         // Initialise
 290         x = Element->CachedX + Element->PaddingL;
 291         y = Element->CachedY + Element->PaddingT;
 292
 293         // Update each child
 294         for(child = Element->FirstChild; child; child = child->NextSibling)
 295         {
 296                  int    newX, newY;
 297                 // Ignore elements that will not be rendered
 298                 if( child->Flags & ELEFLAG_NORENDER )   continue ;
 299
 300                 newX = x; newY = y;
 301
 302                 // Handle alignment (across parent)
 303                 if( Element->Flags & ELEFLAG_ALIGN_CENTER ) {
 304                         if(Element->Flags & ELEFLAG_VERTICAL)
 305                                 newX += Element->CachedW/2 - child->CachedW/2;
 306                         else
 307                                 newY += Element->CachedH/2 - child->CachedH/2;
 308                 }
 309                 else if( Element->Flags & ELEFLAG_ALIGN_END ) {
 310                         if(Element->Flags & ELEFLAG_VERTICAL )
 311                                 newX += Element->CachedW - child->CachedW
 312                                         - Element->PaddingL - Element->PaddingR;
 313                         else
 314                                 newY += Element->CachedH - child->CachedH
 315                                         - Element->PaddingT - Element->PaddingB;
 316                 }
 317
 318 //              _SysDebug(" Widget_UpdatePosition[%i]: newX = %i, newY = %i", Element->ID, newX, newY);
 319
 320                 // Check for changes, and don't update if there was no change
 321                 if( newX != child->CachedX || newY != child->CachedY )
 322                 {
 323                         child->CachedX = newX;
 324                         child->CachedY = newY;
 325                         // Update child's children positions
 326                         Widget_UpdatePosition(child);
 327                 }
 328
 329                 // Increment
 330                 if(Element->Flags & ELEFLAG_VERTICAL ) {
 331                         y += child->CachedH + Element->GapSize;
 332                 }
 333                 else {
 334                         x += child->CachedW + Element->GapSize;
 335                 }
 336         }
 337 }
 338
 339 /**
 340  * \brief Update the minimum dimensions of the element
 341  * \note Called after a child's minimum dimensions have changed
 342  */
 343 void Widget_UpdateMinDims(tElement *Element)
 344 {
 345         tElement        *child;
 346          int    minW, minH;
 347          int    nChildren;
 348
 349         if(!Element)    return;
 350
 351         minW = 0;
 352         minH = 0;
 353         nChildren = 0;
 354
 355         for(child = Element->FirstChild; child; child = child->NextSibling)
 356         {
 357                  int    cross;
 358
 359                 if(Element->Flags & ELEFLAG_NORENDER)   continue ;
 360
 361                 if( (Element->Flags & ELEFLAG_VERTICAL) )
 362                 {
 363                         cross = child->FixedCross ? child->FixedCross : child->MinW;
 364                         if(minW < cross)        minW = cross;
 365                         minH += child->FixedWith  ? child->FixedWith  : child->MinH;
 366                 }
 367                 else
 368                 {
 369                         cross = child->FixedCross ? child->FixedCross : child->MinH;
 370                         minW += child->FixedWith  ? child->FixedWith  : child->MinW;
 371                         if(minH < cross)        minH = cross;
 372                 }
 373 //              _SysDebug("%i/%i cross = %i", Element->ID, child->ID, cross);
 374
 375                 nChildren ++;
 376         }
 377
 378         if( Element->Flags & ELEFLAG_VERTICAL )
 379                 minH += (nChildren - 1) * Element->GapSize;
 380         else
 381                 minW += (nChildren - 1) * Element->GapSize;
 382
 383         Element->MinW = Element->PaddingL + minW + Element->PaddingR;
 384         Element->MinH = Element->PaddingT + minH + Element->PaddingB;
 385
 386         // Recurse upwards
 387         Widget_UpdateMinDims(Element->Parent);
 388 }
 389
 390 tElement *Widget_GetElementByPos(tWidgetWin *Info, int X, int Y)
 391 {
 392         tElement        *ret, *next, *ele;
 393
 394         next = &Info->RootElement;
 395         do
 396         {
 397                 ret = next;
 398                 next = NULL;
 399                 for(ele = ret->FirstChild; ele; ele = ele->NextSibling)
 400                 {
 401                         if(ele->Flags & ELEFLAG_NORENDER)       continue;
 402                         if(X < ele->CachedX)    continue;
 403                         if(Y < ele->CachedY)    continue;
 404                         if(X >= ele->CachedX + ele->CachedW)    continue;
 405                         if(Y >= ele->CachedY + ele->CachedH)    continue;
 406                         next = ele;
 407                 }
 408         } while(next);
 409         return ret;
 410 }
 411
 412 // --- Helpers ---
 413 tElement *Widget_GetElementById(tWidgetWin *Info, uint32_t ID)
 414 {
 415         tElement        *ele;
 416
 417         if( ID == -1 )  return &Info->RootElement;
 418
 419         if( ID < Info->TableSize )      return Info->ElementTable[ID];
 420
 421         ele = Info->ElementTable[ID % Info->TableSize];
 422         while(ele && ele->ID != ID)     ele = ele->ListNext;
 423         return ele;
 424 }
 425
 426 tElement *Widget_int_Create(tWidgetWin *Info, tElement *Parent, int ID, int Type, int Flags)
 427 {
 428         if( Widget_GetElementById(Info, ID) )
 429                 return NULL;
 430
 431         // Create new element
 432         tElement *new = calloc(sizeof(tElement), 1);
 433         new->Window = Parent->Window;
 434         new->ID = ID;
 435         new->Type = Type;
 436         new->Parent = Parent;
 437         new->Flags = Flags;
 438         new->PaddingT = 2;
 439         new->PaddingB = 2;
 440         new->PaddingL = 2;
 441         new->PaddingR = 2;
 442         new->CachedX = -1;
 443
 444         if( gaWM_WidgetTypes[Type]->Init )
 445                 gaWM_WidgetTypes[Type]->Init(new);
 446
 447         // Add to parent's list
 448         if(Parent->LastChild)
 449                 Parent->LastChild->NextSibling = new;
 450         else
 451                 Parent->FirstChild = new;
 452         Parent->LastChild = new;
 453
 454         // Add to info
 455         {
 456                 tElement        *ele, *prev = NULL;
 457                 for(ele = Info->ElementTable[new->ID % Info->TableSize]; ele; prev = ele, ele = ele->ListNext);
 458                 if(prev)
 459                         prev->ListNext = new;
 460                 else
 461                         Info->ElementTable[new->ID % Info->TableSize] = new;
 462         }
 463
 464         return new;
 465 }
 466
 467 // --- Message Handlers ---
 468 void Widget_NewWidget(tWidgetWin *Info, size_t Len, const tWidgetMsg_Create *Msg)
 469 {
 470         const int       max_debugname_len = Len - sizeof(tWidgetMsg_Create);
 471         tElement        *parent;
 472
 473         // Sanity check
 474         if( Len < sizeof(*Msg) )
 475                 return ;
 476         if( strnlen(Msg->DebugName, max_debugname_len) == max_debugname_len )
 477                 return ;
 478
 479         _SysDebug("Widget_NewWidget (%i %i Type %i Flags 0x%x)",
 480                 Msg->Parent, Msg->NewID, Msg->Type, Msg->Flags);
 481
 482         if(Msg->Type >= ciWM_NumWidgetTypes)
 483         {
 484                 _SysDebug("Widget_NewWidget - Bad widget type %i", Msg->Type);
 485                 return ;
 486         }
 487
 488         // Create
 489         parent = Widget_GetElementById(Info, Msg->Parent);
 490         if(!parent)
 491         {
 492                 _SysDebug("Widget_NewWidget - Bad parent ID %i", Msg->Parent);
 493                 return ;
 494         }
 495
 496         Widget_int_Create(Info, parent, Msg->NewID, Msg->Type, Msg->Flags);
 497
 498         Widget_UpdateMinDims(parent);
 499 }
 500
 501 void Widget_NewWidgetSubwin(tWidgetWin *Info, size_t Len, const tWidgetMsg_CreateSubWin *Msg)
 502 {
 503         const int       max_debugname_len = Len - sizeof(tWidgetMsg_CreateSubWin);
 504         tElement        *parent, *new;
 505
 506         // Sanity check
 507         if( Len < sizeof(*Msg) )
 508                 return ;
 509         if( strnlen(Msg->DebugName, max_debugname_len) == max_debugname_len )
 510                 return ;
 511
 512         parent = Widget_GetElementById(Info, Msg->Parent);
 513         if(!parent)     return;
 514         if( Widget_GetElementById(Info, Msg->NewID) )   return ;
 515
 516         new = Widget_int_Create(Info, parent, Msg->NewID, Msg->Type, Msg->Flags);
 517         new->Data = WM_GetWindowByID(parent->Window, Msg->WindowHandle);
 518         Widget_UpdateMinDims(parent);
 519 }
 520
 521 void Widget_SetFocus(tWidgetWin *Info, tElement *Ele)
 522 {
 523         // TODO: Callbacks
 524
 525         Info->FocusedElement = Ele;
 526 }
 527
 528 void Widget_SetFlags(tWidgetWin *Info, int Len, const tWidgetMsg_SetFlags *Msg)
 529 {
 530         tElement        *ele;
 531
 532         if( Len < sizeof(*Msg) )
 533                 return ;
 534
 535         _SysDebug("Widget_SetFlags: (%i 0x%x 0x%x)", Msg->WidgetID, Msg->Value, Msg->Mask);
 536
 537         ele = Widget_GetElementById(Info, Msg->WidgetID);
 538         if(!ele)        return;
 539
 540         ele->Flags &= ~Msg->Mask;
 541         ele->Flags |= Msg->Value & Msg->Mask;
 542 }
 543
 544 void Widget_SetSize(tWidgetWin *Info, int Len, const tWidgetMsg_SetSize *Msg)
 545 {
 546         tElement        *ele;
 547
 548         if( Len < sizeof(*Msg) )
 549                 return ;
 550
 551         ele = Widget_GetElementById(Info, Msg->WidgetID);
 552         if(!ele)        return ;
 553
 554         ele->FixedWith = Msg->Value;
 555 }
 556
 557 void Widget_SetText(tWidgetWin *Info, int Len, const tWidgetMsg_SetText *Msg)
 558 {
 559         tElement        *ele;
 560
 561         if( Len < sizeof(*Msg) + 1 )
 562                 return ;
 563         if( Msg->Text[Len - sizeof(*Msg) - 1] != '\0' )
 564                 return ;
 565
 566         ele = Widget_GetElementById(Info, Msg->WidgetID);
 567         if(!ele)        return ;
 568
 569
 570         if( gaWM_WidgetTypes[ele->Type]->UpdateText )
 571         {
 572                 gaWM_WidgetTypes[ele->Type]->UpdateText( ele, Msg->Text );
 573         }
 574 //      else
 575 //      {
 576 //              if(ele->Text)   free(ele->Text);
 577 //              ele->Text = strdup(Msg->Text);
 578 //      }
 579 }
 580
 581 int Widget_GetText(tWidgetWin *Info, int Len, const tWidgetMsg_SetText *Msg)
 582 {
 583         if( Len < sizeof(*Msg) )
 584                 return 0;
 585         if( Len > sizeof(*Msg) )
 586                 return 1;       // Pass to user
 587
 588         const char      *text = NULL;
 589         tElement *ele = Widget_GetElementById(Info, Msg->WidgetID);
 590         if(ele)
 591                 text = ele->Text;
 592
 593         char    buf[sizeof(tWidgetMsg_SetText) + strlen(text?text:"") + 1];
 594         tWidgetMsg_SetText      *omsg = (void*)buf;
 595
 596         if( text ) {
 597                 omsg->WidgetID = Msg->WidgetID;
 598                 strcpy(omsg->Text, text);
 599         }
 600         else {
 601                 omsg->WidgetID = -1;
 602                 omsg->Text[0] = 0;
 603         }
 604
 605         WM_SendMessage(Info->RootElement.Window, Info->RootElement.Window, MSG_WIDGET_GETTEXT, sizeof(buf), buf);
 606         return 0;
 607 }
 608
 609 int Renderer_Widget_HandleMessage(tWindow *Target, int Msg, int Len, const void *Data)
 610 {
 611         tWidgetWin      *info = Target->RendererInfo;
 612         tElement        *ele;
 613         switch(Msg)
 614         {
 615         case WNDMSG_RESIZE: {
 616                 const struct sWndMsg_Resize     *msg = Data;
 617                 if(Len < sizeof(*msg))  return -1;
 618
 619                 info->RootElement.CachedW = msg->W;
 620                 info->RootElement.CachedH = msg->H;
 621
 622                 // TODO: Update dimensions of all child elements?
 623
 624                 return 0; }
 625
 626         case WNDMSG_MOUSEMOVE: {
 627 //              _SysDebug("TODO: Support widget mouse move events");
 628                 return 0; }
 629
 630         case WNDMSG_MOUSEBTN: {
 631                 const struct sWndMsg_MouseButton        *msg = Data;
 632                 tWidgetMsg_MouseBtn     client_msg;
 633                  int    x, y;
 634                  int    rv;
 635
 636                 if(Len < sizeof(*msg))  return -1;
 637
 638                 x = msg->X; y = msg->Y;
 639                 client_msg.Button = msg->Button;
 640                 client_msg.bPressed = msg->bPressed;
 641
 642                 ele = Widget_GetElementByPos(info, x, y);
 643                 Widget_SetFocus(info, ele);
 644                 // Send event to all elements from `ele` upwards
 645                 for( ; ele; ele = ele->Parent )
 646                 {
 647                         if(gaWM_WidgetTypes[ele->Type]->MouseButton)
 648                         {
 649                                 rv = gaWM_WidgetTypes[ele->Type]->MouseButton(
 650                                         ele,
 651                                         x - ele->CachedX, y - ele->CachedY,
 652                                         msg->Button, msg->bPressed
 653                                         );
 654                                 // Allow a type to trap the input from going any higher
 655                                 if(rv == 0)     break;
 656                         }
 657                         else
 658                         {
 659                                 // Pass to user
 660                                 client_msg.X = x - ele->CachedX;
 661                                 client_msg.Y = y - ele->CachedY;
 662                                 client_msg.WidgetID = ele->ID;
 663                                 WM_SendMessage(Target, Target, MSG_WIDGET_MOUSEBTN, sizeof(client_msg), &client_msg);
 664                         }
 665                 }
 666                 return 0; }
 667
 668         case WNDMSG_KEYDOWN: {
 669                 const struct sWndMsg_KeyAction  *msg = Data;
 670                 if(Len < sizeof(*msg))  return -1;
 671
 672                 if(!info->FocusedElement)       return 0;
 673                 ele = info->FocusedElement;
 674
 675                 if(gaWM_WidgetTypes[ele->Type]->KeyDown)
 676                         gaWM_WidgetTypes[ele->Type]->KeyDown(ele, msg->KeySym, msg->UCS32);
 677                 else
 678                 {
 679                         // TODO: Pass to user
 680                 }
 681
 682                 return 0; }
 683
 684         case WNDMSG_KEYFIRE: {
 685                 const struct sWndMsg_KeyAction  *msg = Data;
 686                 if(Len < sizeof(*msg))  return -1;
 687
 688                 if(!info->FocusedElement)       return 0;
 689                 ele = info->FocusedElement;
 690
 691                 if(gaWM_WidgetTypes[ele->Type]->KeyFire)
 692                         gaWM_WidgetTypes[ele->Type]->KeyFire(ele, msg->KeySym, msg->UCS32);
 693                 else
 694                 {
 695                         // TODO: Pass the buck
 696                 }
 697                 return 0; }
 698
 699         case WNDMSG_KEYUP: {
 700                 const struct sWndMsg_KeyAction  *msg = Data;
 701                 if(Len < sizeof(*msg))  return -1;
 702
 703                 if(!info->FocusedElement)       return 0;
 704                 ele = info->FocusedElement;
 705
 706                 if(gaWM_WidgetTypes[ele->Type]->KeyUp)
 707                         gaWM_WidgetTypes[ele->Type]->KeyUp(ele, msg->KeySym);
 708                 else
 709                 {
 710                         // TODO: Pass the buck
 711                 }
 712                 return 0; }
 713
 714         // New Widget
 715         case MSG_WIDGET_CREATE:
 716                 Widget_NewWidget(info, Len, Data);
 717                 return 0;
 718         case MSG_WIDGET_CREATESUBWIN:
 719                 Widget_NewWidgetSubwin(info, Len, Data);
 720                 return 0;
 721
 722         // Delete a widget
 723         case MSG_WIDGET_DELETE:
 724                 _SysDebug("TODO: Implement MSG_WIDGET_DELETE");
 725                 return 0;
 726
 727         // Set focused widget
 728         case MSG_WIDGET_SETFOCUS: {
 729                 tElement        *ele;
 730                 const tWidgetMsg_SetFocus       *msg = Data;
 731                 if(Len < sizeof(*msg))  return -1;
 732
 733                 ele = Widget_GetElementById(info, msg->WidgetID);
 734                 Widget_SetFocus(info, ele);
 735                 return 0; }
 736
 737         // Set Flags
 738         case MSG_WIDGET_SETFLAGS:
 739                 Widget_SetFlags(info, Len, Data);
 740                 return 0;
 741
 742         // Set length
 743         case MSG_WIDGET_SETSIZE:
 744                 Widget_SetSize(info, Len, Data);
 745                 return 0;
 746
 747         // Set text
 748         case MSG_WIDGET_SETTEXT:
 749                 Widget_SetText(info, Len, Data);
 750                 return 0;
 751         case MSG_WIDGET_GETTEXT:
 752                 return Widget_GetText(info, Len, Data);
 753
 754         //
 755         default:
 756                 return 1;       // Unhandled, pass to user
 757         }
 758 }
 759
 760 void Widget_Fire(tElement *Element)
 761 {
 762         tWidgetMsg_Fire msg;
 763         msg.WidgetID = Element->ID;
 764         WM_SendMessage(Element->Window, Element->Window, MSG_WIDGET_FIRE, sizeof(msg), &msg);
 765 }
 766