/***********************************************************************************************************                                                uC/GUI*                        Universal graphic software for embedded applications**                       (c) Copyright 2002, Micrium Inc., Weston, FL*                       (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH**              礐/GUI is protected by international copyright laws. Knowledge of the*              source code may not be used to write a similar product. This file may*              only be used in accordance with a license and should not be redistributed*              in any way. We appreciate your understanding and fairness.*----------------------------------------------------------------------File        : WM.CPurpose     : Windows manager core----------------------------------------------------------------------Version-Date---Author-Explanation----------------------------------------------------------------------3.00a   010621 RS     a) module accelerated by skipping parameter                         to FindNext_IVR3.00    010502 RS     a) WM module split up for library applications                      b) Module dramatically accelerated (without                         changes in the routine structure)1.18    000909 RS     a) WM_CreateBWin does not activate the                         new window unless specified via create flags1.16a   000724 RS     a) Function WM_EnableMemdevRead added1.16    000614 RS     a) Cleanup                      b) Counter for invalid windows and                         WM_GetNumInvalidWindows() added1.14g   000522 RS     a) WM_ExecAll added1.14f   000316 RS     a) Internal Create routine created in order to                         handle creation of regular windows and                         objects seperately (and correctly) in all                         cases (by avoiding casts)1.14e   000307 RS     a) WM_MoveTo added1.14d   000224 RS     a) WM_CF_ACTIVATE flag now needed in order to                         automatically activate a created window1.14c   000209 RS     a) GUI_Clear eliminated in default callback for                         default background window1.14b   000125 RS     a) Bugfix for bug created in 1.14a1.14a   000122 RS     a) WM_CreateObj: Change in order to avoid                         compiler warning with IARs new frontend1.14    999109 RS     a) Bugfix: Deleted window could still receive                         up to 1 drawing message. Fixed. (->NextDrawWin)                      b) WM_Obj now uses memory handle                      c) WM_DefaultProc now handles WM_DELETE                      d) Drawing area reduction for callbacks                         to invalide area                      e) WM_SetCallback added                      f) Call to WM_Error if insufficient windows have                         been configured1.12h   000107 RS     a) WM_Sendmessage: unused local eliminated                      b) WMALLOC_Init call eliminated1.12g   991230 RS     a) Callback for background window defined1.12f   991228 RS     a) Locking macros moved -> WM.H1.12e   991208 RS     a) WM_DrawNext now saves the entire context, not                         just the active window1.12d   991204 RS     a) WM_GetBGndWin added1.12c   991203 RS     a) WM_Init now creates default window1.12b   991126 RS     a) Cleanup in order to avoid compiler warnings1.12a   991112 RS     a) Invalidate now also invalidates any                         transparent window on top of the invalidated                         area                      b) Internal changes in order to support                         dynamic memory (using WM_ALLOC)                      c) Additional ASSERTs inserted1.12    991110 RS     a) Invalidate now also invalidates a window                         below a transparent window1.10c   991018 RS     a) WM_DrawNext:                         NextDrawWin=WM_HWIN_NULL -> NextDrawWin==WM_HWIN_NULL1.10b   991015 RS     a) WM_ValidateBWin corrected (Invalid                         flag was never reset, leading to superfluos redraws)                      b) WM_SetDefault(void) implemented1.10a   991012 RS     a) Compile warnings eliminated1.10    990918 RS     a) Objects for windows manager added:                         WM_CreateObject, WM_DeleteObject                      b) "Magic number" -1 eliminated                      c) static routines put on top of file                      d) Locking added (WM_LOCK), ensuring thread                         safety of all routines                      e) Window marked as valid only if a callback                         exists, allowing mixed callback/non callback                         modes for different windows1.08.02 990827 RS     a) Optimization bug in WM_SetHasTrans                         fixed1.08.01 990826 RS     a) Transparent windows can no longer obstruct                      an area of a window below in Z-direction                      (in FindNext_IVR) for correct handling of                      transparent windows1.08.00 990823 RS     a) WM__GetOrgX -> WM_GetOrgX                         WM__GetOrgY -> WM_GetOrgY                      b) Clearing memory in WM_Init1.07.01 990730 RS     a) In WM_DrawNext() add. condition added to make                      sure that loop does not iterate using                      -1 (end-of-list) as index1.07    990720 RS     a) New switch: WM_SUPPORT_OBSTRUCT, def. 11.06    990504 BB     functions WM_GetWinSizeX() and WM_GetWinSizeY()                      added.1.05    990423 RS     a) Prototype for WM_CreateBWin changed,                      parameter WM_MESSAGE* is no longer const                      (Causing some other changes reg. const)                      b) WM_ShowBWin WM_HideBWin tested in simulator1.04    990417 RS     a) DrawNext bug fixed: It had passed the                      entire WIndow-Rectangle instead of just                      the InvalidRectangle with the WM_PAINT                      command1.03    990401 RS     a) Implemented the following functions                      WM_SetHasTrans()                      WM_ClrHasTrans()                      WM_GetHasTrans()                      WM_HideBWin()                      WM_ShowBWin()                      WM_ValidateBWin()                      WM_GetActiveBWin()1.02    990315 RS     a) Windows stack organisation routines cleaned                      up, resulting in more efficient code1.01    990314 RS     a) Invalidation and IVR calculation optimized                      b) Windows which are on top of a window causing                      invalidation are no longer affected1.00    990310 RS     Moving and resizing tested in simulation0.99    990309 RS     All routines implemented, moving & resizing                      need to be tested under different circumstances.0.50    990308 RS     Core of WM works (Calculation and iteration over                      IVRs). Side routines like moving windows and the                      corresponding message handling missing.                      There is now a clear seperation between the LCD                      and GL layers and WM.0.01    990301 RS     Incomplete version, for BB to check----------------------------------------------------------------------Known problems:None.----------------------------------------------------------------------Open issues:None.----------------------------------------------------------------------Todo:Nothing.*/#include <stddef.h>           /* needed for definition of NULL */#include <string.h>           /* required for memset */#define WM_C#include "WM_Intern.h"#if GUI_WINSUPPORT    /* If 0, WM will not generate any code *//********************************************************************              Config defaults*********************************************************************//* This is for tests only. It will fill the invalid area of a window.   Can be used for debugging. */#ifndef WM_SHOW_INVALID  #define WM_SHOW_INVALID 0#endif/*********************************************************************                 Macros for internal use**********************************************************************/#define ASSIGN_IF_LESS(v0,v1) if (v1<v0) v0=v1/********************************************************************              Local typedefs*********************************************************************/typedef struct {  GUI_RECT ClientRect;  GUI_RECT CurRect;  int Cnt;  int EntranceCnt;} WM_IVR_CONTEXT;/********************************************************************              WM_ global data*********************************************************************/U8                     WM_IsActive;U16                    WM__CreateFlags;WM_DELETE_WINDOW_HOOK* WM__pfDeleteWindowHook;GUI_COLOR              WM__BkColor = GUI_INVALID_COLOR;WM_HWIN                WM__hCapture, WM__hWinFocus;char                   WM__CaptureReleaseAuto;/********************************************************************              Static data*********************************************************************/static WM_HWIN        NextDrawWin;static U8             IsInCallback;static WM_IVR_CONTEXT ClipContext;static char           _IsInited;/*********************************************************************       Static routines**********************************************************************//*********************************************************************       _ClipAtParentBorders  Iterates over all its ancestors and intersects all rectangles to  find out which part is actually visible.  Reduces the rectangle to the visible area.*/void _ClipAtParentBorders(GUI_RECT* pRect, WM_Obj* pWin) {  WM_HWIN hWin;  hWin = pWin->hParent;  while (hWin) {    pWin = WM_H2P(hWin);    GUI__IntersectRect(pRect, &pWin->Rect);    hWin = pWin->hParent;  }}/*********************************************************************  When drawing, we have to start at the bottom window !*/static void ResetNextDrawWin(void) {  NextDrawWin = WM_HWIN_NULL;}/*********************************************************************       _AddChild*/void _AddChild(WM_HWIN hParent, WM_HWIN hChild, int OnTop) {  WM_Obj* pChild;  WM_Obj* pParent;  WM_Obj* pi;  WM_HWIN hi;  if (hParent) {    pParent = WM_H2P(hParent);    pChild  = WM_H2P(hChild);    hi = pParent->hFirstChild;    if (hi == 0) {   /* No child yet ... Makes things easy ! */      pParent->hFirstChild = hChild;        return;                         /* Early out ... We are done */    }    if (!OnTop) {      pi = WM_H2P(hi);      if (pi->Status & WM_SF_STAYONTOP) {        pChild->hNext = hi;        pParent->hFirstChild = hChild;        return;                         /* Early out ... We are done */      }    }    /* put if at the end of the list or after the last non "STAY-ON-TOP" child */    do {      WM_Obj* pNext;      WM_HWIN hNext;      pi = WM_H2P(hi);      if ((hNext = pi->hNext) == 0) {        pi->hNext = hChild;        break;      }      if (!OnTop) {        pNext = WM_H2P(hNext);        if (pNext->Status & WM_SF_STAYONTOP) {          pi->hNext = hChild;          pChild->hNext = hNext;          break;        }      }      hi = hNext;    }  while (1);  }}/**********************************************************************/static void _DeleteAllChildren(WM_HWIN hChild) {  while (hChild) {    WM_Obj* pChild = WM_H2P(hChild);    WM_HWIN hNext = pChild->hNext;    WM_DeleteWindow(hChild);    hChild = hNext;  }}/**********************************************************************/static void _DeleteInSiblingList(WM_HWIN hWin) {  WM_Obj* pWin;  WM_Obj* pParent;  WM_Obj* pi;  WM_HWIN hParent;  WM_HWIN hi;  pWin = WM_H2P(hWin);  if (pWin->hParent) {    hParent = pWin->hParent;    pParent = WM_H2P(hParent);    hi = pParent->hFirstChild;    if (hi == hWin) {      pi = WM_H2P(hi);      pParent->hFirstChild = pi->hNext;    } else {      while (hi) {        pi = WM_H2P(hi);        if (pi->hNext == hWin) {          pi->hNext = pWin->hNext;          return;        }        hi = pi->hNext;      }    }  }}/***********************************************************************             Module internal routines************************************************************************/void WM__Client2Screen(const WM_Obj* pWin, GUI_RECT *pRect) {  GUI_MoveRect(pRect, pWin->Rect.x0, pWin->Rect.y0);}int WM__IsWindow(WM_HWIN hWin) {  WM_HWIN iWin;  int r = 0;  for (iWin = WM__FirstWin; iWin; iWin = WM_H2P(iWin)->hNextLin) {    if (iWin == hWin) {      r = 1;      break;    }  }  return r;}/**********************************************************************/void WM__RemoveFromLinList(WM_HWIN hWin) {  WM_Obj* piWin;  WM_HWIN hiWin, hNext;  for (hiWin = WM__FirstWin; hiWin; ) {    piWin = WM_H2P(hiWin);    hNext = piWin->hNextLin;    if (hNext == hWin) {      piWin->hNextLin = WM_H2P(hWin)->hNextLin;      break;    }    hiWin = hNext;  }}/**********************************************************************/void _AddToLinList(WM_HWIN hNew) {  WM_Obj* pFirst;  WM_Obj* pNew;  if (WM__FirstWin) {    pFirst = WM_H2P(WM__FirstWin);    pNew   = WM_H2P(hNew);    pNew->hNextLin = pFirst->hNextLin;    pFirst->hNextLin = hNew;  } else {    WM__FirstWin = hNew;  }}/*********************************************************************   Check if the rectangle has some content (is non-zero)   Returns 0 if the Rectangle has no content, else 1.*/int WM__RectIsNZ(const GUI_RECT* pr) {  if (pr->x0 > pr->x1)    return 0;  if (pr->y0 > pr->y1)    return 0;  return 1;}/*  ********************************************************************  *                                                                  *  *                    Sending messages                              *  *                                                                  *  *********************************************************************/void WM_SendMessage(WM_HWIN hWin, WM_MESSAGE* pMsg) {  WM_Obj* pWin;  WM_LOCK();  if (hWin) {    pWin = WM_H2P(hWin);  /* Do some checking to avoid program crashes due to user     programming errors */    #if GUI_DEBUG_LEVEL > 0      if (!pWin->Status)        goto Done;    #endif    if (pWin->cb != NULL) {      pMsg->hWin = hWin;      IsInCallback = 1;      (*pWin->cb)(pMsg);      IsInCallback = 0;    }  }  #if GUI_DEBUG_LEVEL > 0Done:  #endif  WM_UNLOCK();}/**********************************************************************/void WM__SendMsgNoData(WM_HWIN hWin, U8 MsgId) {  WM_MESSAGE Msg;  Msg.hWin  = hWin;  Msg.MsgId = MsgId;  WM_SendMessage(hWin, &Msg);}/* Get client rectangle in windows coordinates. This means that the  upper left corner is always at (0,0). */void WM__GetClientRectWin(WM_Obj* pWin, GUI_RECT* pRect) {  pRect->x0 = pRect->y0 = 0;  pRect->x1 = pWin->Rect.x1 - pWin->Rect.x0;  pRect->y1 = pWin->Rect.y1 - pWin->Rect.y0;