wm.c

在ucos上实现了图形用户接口GUI；值得一看

/*
*********************************************************************************************************
*                                                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 "headers.h"
#include <stddef.h>           // needed for definition of NULL
#include <string.h>           // required for memset

#define WM_C
#include "WIntern.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) {//make hNew to be the second window of the link,just after WM__FirstWin
    pFirst = WM_H2P(WM__FirstWin);
    pNew   = WM_H2P(hNew);
    pNew->hNextLin = pFirst->hNextLin;
    pFirst->hNextLin = hNew;
  } else {
    WM__FirstWin = hNew;//no firstwin,make this win to be desktop window
  }
}


/********************************************************************
   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;        //set "now is in callback function" flag
      (*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;
  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;