pRect->x1 = pWin->Rect.x1 - pWin->Rect.x0;  pRect->y1 = pWin->Rect.y1 - pWin->Rect.y0;}static void WM__GetInvalidRectAbs(WM_Obj* pWin, GUI_RECT* pRect) {  *pRect = pWin->InvalidRect;  GUI_MoveRect (pRect, pWin->Rect.x0, pWin->Rect.y0);}/*          *****************************************************************          *                                                               *          *              Invalidation functions                           *          *                                                               *          ******************************************************************//* Invalidate, using window coordinates */static void WM_InvalidateBWin1(WM_HWIN hWin, const GUI_RECT*pRect) {  GUI_RECT r;  WM_Obj* pWin = WM_H2P(hWin);  WM__GetClientRectWin(pWin, &r);  if (pRect)    GUI__IntersectRect(&r, pRect);  if (WM__RectIsNZ(&r)) {    if (pWin->Status & WM_SF_INVALID) {      GUI_MergeRect(&pWin->InvalidRect, &pWin->InvalidRect, &r);    } else {      pWin->InvalidRect = r;      pWin->Status |= WM_SF_INVALID;      WM__NumInvalidWindows++;      /* Debug code: shows invalid areas */      #if (WM_SHOW_INVALID)      {        GUI_CONTEXT Context = GUI_Context;        WM_SelectWindow(hWin);        GUI_SetBkColor(GUI_GREEN);        GUI_ClearRect(r.x0, r.y0, r.x1, r.y1);        GUI_Context = Context;      }      #endif    }  }}/* Invalidate, using desktop coordinates (only this window,   not the ones below !!!)*/static void WM_InvalidateBWin1Abs(WM_HWIN hWin, const GUI_RECT*pRect) {  GUI_RECT r = *pRect;  WM_LOCK();  GUI_MoveRect(&r, -WM_H2P(hWin)->Rect.x0, -WM_H2P(hWin)->Rect.y0);  WM_InvalidateBWin1(hWin, &r);  WM_UNLOCK();}/*  Invalidate a certain section of the display. One main reason for this is  that a window has been moved or destroyed.  The following windows are affected:  * windows below the window creating the invalidation.  * transparent windows located above  The coordinates given are absolute coordinates (desktop coordinates)*/void WM__InvalidateAreaBelow(const GUI_RECT* pRect, WM_HWIN StopWin) {  WM_HWIN   iWin, iNext;  /* Iterate over windows below StopWin */  for (iWin = WM__FirstWin; iWin!=StopWin; iWin = iNext) {    GUI_RECT r = *pRect;    WM_Obj* pWin = WM_H2P(iWin);    iNext = pWin->hNextLin;    if (GUI__IntersectRects(&r, &r, &pWin->Rect)) {      WM_InvalidateBWin1Abs (iWin, &r);    }  };}/*  Invalidate any transparent window above the given area*/void WM__InvalidateTransAreaAbove(const GUI_RECT* pRect, WM_HWIN StopWin) {  GUI_USE_PARA(pRect);  GUI_USE_PARA(StopWin);#if 0  WM_HWIN   iWin;  /* Iterate over windows below StopWin */  for (iWin = StopWin; iWin!=WM_HWIN_NULL; iWin = WM_H2P(iWin)->Next) {    WM_Obj *pWin = WM_H2P(iWin);    if (pWin->Status & WM_SF_HASTRANS) {      GUI_RECT r = *pRect;      if (GUI__IntersectRects(&r, &r, &WM_H2P(iWin)->Rect)) {        WM_InvalidateBWin1Abs (iWin, &r);      }    }  }#endif}/*          *****************************************************************          *                                                               *          *              Invalidation functions                           *          *                                                               *          ******************************************************************//* Invalidate a section of the window. The optional rectangle   contains client coordinates, which are independent of the   position of the window on the logical desktop area.*/void WM_InvalidateRect(WM_HWIN hWin, const GUI_RECT*pRect) {  GUI_RECT r;  WM_Obj* pWin;  WM_LOCK();  pWin = WM_H2P(hWin);  WM__GetClientRectWin(pWin, &r);  if (pRect) {    GUI__IntersectRect(&r, pRect);  }  WM_InvalidateBWin1(hWin, &r);/* Convert into absolute coordinates ... */  GUI_MoveRect (&r, pWin->Rect.x0, pWin->Rect.y0);/* Make sure windows below are invalidated if this one is transparent */  if (pWin->Status & WM_SF_HASTRANS) {    ResetNextDrawWin();    WM__InvalidateAreaBelow(&r, hWin);  }/* Invalidate the transparent ones above */  WM__InvalidateTransAreaAbove(&r,hWin);  WM_UNLOCK();}void WM_InvalidateWindow(WM_HWIN hWin) {  WM_InvalidateRect(hWin, NULL);}/* Invalidate, using desktop coordinates */void WM_InvalidateBWinAbs(WM_HWIN hWin, const GUI_RECT*pRect) {  GUI_RECT r = *pRect;  WM_LOCK();  GUI_MoveRect(&r, -WM_H2P(hWin)->Rect.x0, -WM_H2P(hWin)->Rect.y0);  WM_InvalidateRect(hWin, &r);  WM_UNLOCK();}/*  Invalidate a certain section of the display. One main reason for this is  that the top window has been moved or destroyed.  The coordinates given are absolute coordinates (desktop coordinates)*/void WM_InvalidateArea(GUI_RECT* pRect) {  WM_HWIN   iWin;  WM_LOCK();  /* Iterate over all windows */  for (iWin=WM__FirstWin; iWin !=0; ) {    WM_Obj* pWin = WM_H2P(iWin);    GUI_RECT r = *pRect;    GUI__IntersectRect(&r, &pWin->Rect);    /* Calculate which area is actually visible by subtracting the       windows which are on top of this one */    WM_InvalidateBWinAbs (iWin, &r);    iWin = pWin->hNextLin;  }  WM_UNLOCK();}/*  ********************************************************************  *                                                                  *  *              manage windows stack                                *  *                                                                  *  *********************************************************************//* Return index (handle) of the window which is bottom of stack.   Note that in the current implementation, this is always   window 0.*/WM_HWIN WM_GetDesktopWindow(void) {  return WM__FirstWin;}/*  ********************************************************************  *  *              Create window (as child)  *  *********************************************************************/WM_HWIN WM_CreateWindowAsChild(                    int x0, int y0, int width, int height                   ,WM_HWIN hWinParent                   ,U16 Style                   ,WM_CALLBACK* cb                   ,int NumExtraBytes){  WM_Obj* pWin;  WM_HWIN hWin;  WM_LOCK();  Style |= WM__CreateFlags;  /* Get Parent info */  if (!hWinParent) {    if (WM__NumWindows) {      hWinParent = WM_HBKWIN;    }  }  if (hWinParent) {    GUI_RECT Rect;    WM_MESSAGE Msg;    Msg.MsgId = WM_GETCLIENTRECT_ABS;    Msg.Data.p = &Rect;    WM_SendMessage(hWinParent, &Msg);    x0 += Rect.x0;    y0 += Rect.y0;    if (width==0)      width = Rect.x1-Rect.x0+1;    if (height==0)      height = Rect.y1-Rect.y0+1;  }  if ((hWin = (WM_HWIN) WM_ALLOC(NumExtraBytes+sizeof(WM_Obj))) == 0) {    GUI_DEBUG_ERROROUT("WM_CreateWindow: No memory to create window");  } else {    WM__NumWindows++;    pWin = WM_H2P(hWin);    memset (pWin,   0, sizeof(WM_Obj));        /* erase this data structure           The explicit zero-init is no longer needed since the entire data structure           is already zeroed. The advantage is that it reduces program size.           */    pWin->Rect.x0 = x0;    pWin->Rect.y0 = y0;    pWin->Rect.x1 = x0+width-1;    pWin->Rect.y1 = y0+height-1;    pWin->Status = WM_SF_INUSE;     /* Mark window as in use */    pWin->cb = cb;    /* Add to linked lists */    pWin->hParent = hWinParent;    _AddChild(hWinParent, hWin, Style & WM_CF_STAYONTOP);    _AddToLinList(hWin);  /* Put Window on top (or bottom) of windows stack */    if (Style & WM_CF_ACTIVATE /*| (cb==NULL)*/) {      WM_SelectWindow(hWin);  /* This is not needed                                 if callbacks are being used, but it                                 does not cost a lot and makes life                                 easier ... */    }  /* Mark client area as invalid */    WM__SendMsgNoData(hWin, WM_CREATE);  /* Handle the Style flags, one at a time */    if (Style & WM_CF_SHOW) {      WM_ShowWindow(hWin);    }  /* Hide if parent is not visible */    if (hWinParent) {      WM_Obj* pWinParent = WM_H2P(hWinParent);      if (!(pWinParent->Status & WM_SF_ISVIS)) {        WM_HideWindow(hWin);      }    }    /* Copy the flags which can simply be accepted */    pWin->Status |= (Style & (WM_SF_MEMDEV|WM_SF_STAYONTOP|WM_SF_HASTRANS));  }  WM_UNLOCK();  return hWin;}WM_HWIN WM_CreateWindow(int x0, int y0, int width, int height, U16 Style, WM_CALLBACK* cb, int NumExtraBytes) {  return WM_CreateWindowAsChild(x0,y0,width,height, 0 /* No parent */,  Style, cb, NumExtraBytes);}/******************************************************************          Delete window*******************************************************************/void WM_DeleteWindow (WM_HWIN Win) {  WM_Obj* pWin;  if (!Win)    return;  WM_LOCK();  if (WM__IsWindow(Win)) {    pWin = WM_H2P(Win);    ResetNextDrawWin();              /* Make sure the window will no longer receive drawing messages */  /* Make sure that focus is set to an existing window */    if (WM__hWinFocus == Win) {      WM__hWinFocus = 0;    }    if (Win == WM__hCapture) {      WM__hCapture = 0;    }  /* Delete all children */    _DeleteAllChildren(pWin->hFirstChild);    _DeleteInSiblingList(Win);  /* Send WM_DELETE message to window in order to inform window itself */    WM__SendMsgNoData(Win, WM_DELETE);     /* tell window about it */    /* Inform other modules if necessary */    if (WM__pfDeleteWindowHook) {      (*WM__pfDeleteWindowHook)(Win);    }  /* Remove window from window stack */    if (pWin->Status & WM_SF_INVALID) {      WM__NumInvalidWindows--;    }    WM__RemoveFromLinList(Win);  /* Clear area used by this window */    WM_InvalidateArea(&pWin->Rect);  /* Free window memory */    WM__NumWindows--;    WM_FREE(Win);  /* Select a valid window */    WM_SelectWindow(WM__FirstWin);  } else {    GUI_DEBUG_WARN("WM_DeleteWindow: Invalid handle");  }  WM_UNLOCK();}void WM__SetMaxClipRect(const WM_Obj* pWin) {  WM_LOCK();  LCD_SetClipRectEx(&pWin->Rect);  WM_UNLOCK();}/******************************************************************              WM_SelectWindow******************************************************************Sets the active Window. The active Window is the one that is used for alldrawing (and text) operations.*/WM_HWIN WM_SelectWindow(WM_HWIN  hWin) {  WM_HWIN hWinPrev;  WM_LOCK();  hWinPrev = GUI_Context.hAWin;  if (hWin == 0) {    hWin = WM__FirstWin;  }  if (!(WM_H2P(hWin)->Status & WM_SF_INUSE)) {    GUI_DEBUG_ERROROUT1("Selecting invalid window", hWin);    hWin=0;  }  /* Select new window */  GUI_Context.hAWin = hWin;  WM__SetMaxClipRect(WM_H2P(hWin));  WM_UNLOCK();  return hWinPrev;}WM_HWIN WM_GetActiveWindow(void) {  return GUI_Context.hAWin;}/*  ********************************************************************  *                                                                  *  *                 Show / hide window                               *  *                                                                  *  *********************************************************************/void WM_ShowWindow   (WM_HWIN hWin) {  WM_Obj *pWin;  WM_LOCK();  pWin = WM_H2P(hWin);    /* First check if this is necessary at all */  if ((pWin->Status&WM_SF_ISVIS)) {    WM_UNLOCK();    return;  }  /* Set Visibility flag */  pWin->Status |= WM_SF_ISVIS;  /* Mark content as invalid */  WM_InvalidateWindow(hWin);  WM_UNLOCK();}/*          *****************************************************************          *                                                               *          *                    GetOrg                                     *          *                                                               *          *****************************************************************These routines return the offset of the client area in absolute coordinates.They are used to convert window coordinates into absolute coordinates and areused in the clipping libraries (CL_).*/int WM__GetOrgX(void) {  return WM_H2P(GUI_Context.hAWin)->Rect.x0;}int WM__GetOrgY(void) {  return WM_H2P(GUI_Context.hAWin)->Rect.y0;}/***********************************************************************           IVR calculationIVRs are invalid rectangles. When redrawing, only the portion of thewindow which is  a) within the window-rectangle  b) not covered by an other window  c) marked as invalid  is actually redrawn. Unfortunately, this section is not always  rectangular. If the window is partially covered by an other window,  it consists of the sum of multiple rectangles. In all drawing  operations, we have to iterate over every one of these rectangles in  order to make sure the window is drawn completly.Function works as follows:  STEP 1: - Set upper left coordinates to next pixel. If end of line (right border), goto next line -> (r.x0, r.y0)  STEP 2: - Check if we are done, return if we are.  STEP 3: - If we are at the left border, find max. heigtht (r.y1) by iterating over windows above  STEP 4: - Find x0 for the given y0, y1 by iterating over windows above  STEP 5: - If r.x0 out of right border, this stripe is done. Set next stripe and goto STEP 2  STEP 6: - Find r.x1. We have to Iterate over all windows which are above*/#if WM_SUPPORT_OBSTRUCTstatic int FindNext_IVR(void) {  int hParent;  int iWin;  GUI_RECT r;  U8 Status;  WM_Obj* pWin;  WM_Obj* pAWin;  WM_Obj* pParent;  r = ClipContext.CurRect;  /* temps  so we do not have to work with pointers too much */  /*     STEP 1:       Set the next position which could be part of the next IVR       This will be the first unhandle pixel in reading order, i.e. next one to the right       or next one down if we are at the right border.  */  if (ClipContext.Cnt == 0) {       /* First IVR starts in upper left */    r.x0 = ClipContext.ClientRect.x0;    r.y0 = ClipContext.ClientRect.y0;  } else {