/***********************************************************************************************************                                                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.C
Purpose     : Windows manager core
----------------------------------------------------------------------
Version-Date---Author-Explanation
----------------------------------------------------------------------

3.00a   010621 RS     a) module accelerated by skipping parameter
                         to FindNext_IVR
3.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 flags
1.16a   000724 RS     a) Function WM_EnableMemdevRead added
1.16    000614 RS     a) Cleanup
                      b) Counter for invalid windows and
                         WM_GetNumInvalidWindows() added
1.14g   000522 RS     a) WM_ExecAll added
1.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 added
1.14d   000224 RS     a) WM_CF_ACTIVATE flag now needed in order to
                         automatically activate a created window
1.14c   000209 RS     a) GUI_Clear eliminated in default callback for
                         default background window
1.14b   000125 RS     a) Bugfix for bug created in 1.14a
1.14a   000122 RS     a) WM_CreateObj: Change in order to avoid
                         compiler warning with IARs new frontend
1.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 configured
1.12h   000107 RS     a) WM_Sendmessage: unused local eliminated
                      b) WMALLOC_Init call eliminated
1.12g   991230 RS     a) Callback for background window defined
1.12f   991228 RS     a) Locking macros moved -> WM.H
1.12e   991208 RS     a) WM_DrawNext now saves the entire context, not
                         just the active window
1.12d   991204 RS     a) WM_GetBGndWin added
1.12c   991203 RS     a) WM_Init now creates default window
1.12b   991126 RS     a) Cleanup in order to avoid compiler warnings
1.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 inserted
1.12    991110 RS     a) Invalidate now also invalidates a window
                         below a transparent window
1.10c   991018 RS     a) WM_DrawNext:
                         NextDrawWin=WM_HWIN_NULL -> NextDrawWin==WM_HWIN_NULL
1.10b   991015 RS     a) WM_ValidateBWin corrected (Invalid
                         flag was never reset, leading to superfluos redraws)
                      b) WM_SetDefault(void) implemented
1.10a   991012 RS     a) Compile warnings eliminated
1.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 windows
1.08.02 990827 RS     a) Optimization bug in WM_SetHasTrans
                         fixed
1.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 windows
1.08.00 990823 RS     a) WM__GetOrgX -> WM_GetOrgX
                         WM__GetOrgY -> WM_GetOrgY
                      b) Clearing memory in WM_Init
1.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 index
1.07    990720 RS     a) New switch: WM_SUPPORT_OBSTRUCT, def. 1
1.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 simulator
1.04    990417 RS     a) DrawNext bug fixed: It had passed the
                      entire WIndow-Rectangle instead of just
                      the InvalidRectangle with the WM_PAINT
                      command
1.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 code
1.01    990314 RS     a) Invalidation and IVR calculation optimized
                      b) Windows which are on top of a window causing
                      invalidation are no longer affected
1.00    990310 RS     Moving and resizing tested in simulation
0.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 > 0
Done:
  #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;