/*********************************************************************
*
* FRAMEWIN_AddMenu
*/
void FRAMEWIN_AddMenu(FRAMEWIN_Handle hObj, WM_HWIN hMenu) {
if (hObj) {
FRAMEWIN_Obj* pObj;
WM_LOCK();
pObj = FRAMEWIN_H2P(hObj);
if (pObj) {
int TitleHeight, BorderSize, IBorderSize = 0;
int x0, y0, xSize;
TitleHeight = FRAMEWIN__CalcTitleHeight(pObj);
BorderSize = pObj->Props.BorderSize;
if (pObj->Widget.State & FRAMEWIN_SF_TITLEVIS) {
IBorderSize = pObj->Props.IBorderSize;
}
x0 = BorderSize;
y0 = BorderSize + TitleHeight + IBorderSize;
xSize = WM__GetWindowSizeX(&pObj->Widget.Win);
xSize -= BorderSize * 2;
pObj->hMenu = hMenu;
if (pObj->cb) {
MENU_SetOwner(hMenu, pObj->hClient);
}
MENU_Attach(hMenu, hObj, x0, y0, xSize, 0, 0);
WM_SetAnchor(hMenu, WM_CF_ANCHOR_LEFT | WM_CF_ANCHOR_RIGHT);
FRAMEWIN__UpdatePositions(pObj);
FRAMEWIN_Invalidate(hObj);
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* Client Callback
*/
static void FRAMEWIN__cbClient(WM_MESSAGE* pMsg) {
WM_HWIN hWin = pMsg->hWin;
WM_HWIN hParent = WM_GetParent(pMsg->hWin);
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hParent);
WM_CALLBACK* cb = pObj->cb;
switch (pMsg->MsgId) {
case WM_PAINT:
GUI_SetBkColor(pObj->ClientColor);
GUI_Clear();
if (pObj->cb) {
WM_MESSAGE msg;
msg.hWin = hWin;
msg.MsgId = WM_PAINT;
(*pObj->cb)(&msg);
}
return;
case WM_GET_FOCUSSED_CHILD:
pMsg->Data.v = pObj->hFocussedChild;
return;
case WM_SET_FOCUS:
if (pMsg->Data.v) { /* Focus received */
if (pObj->hFocussedChild) {
WM_SendMessage(pObj->hFocussedChild, pMsg);
} else {
pObj->hFocussedChild = WM_SetFocusOnNextChild(hWin);
}
}
return;
case WM_KEY:
if ( ((WM_KEY_INFO*)(pMsg->Data.p))->PressedCnt >0) {
int Key = ((WM_KEY_INFO*)(pMsg->Data.p))->Key;
switch (Key) {
case GUI_KEY_TAB:
pObj->hFocussedChild = WM_SetFocusOnNextChild(hWin);
break; /* Send to parent by not doing anything */
}
}
break;
case WM_NOTIFY_CHILD_HAS_FOCUS:
pObj->hFocussedChild = pMsg->hWinSrc;
if (pMsg->Data.v) {
pObj->Widget.State |= WIDGET_STATE_CHILD_HAS_FOCUS;
} else {
pObj->Widget.State &= ~WIDGET_STATE_CHILD_HAS_FOCUS;
}
WM_InvalidateWindow(hParent);
break;
case WM_GET_BKCOLOR:
pMsg->Data.Color = pObj->ClientColor;
return; /* Message handled */
case WM_GETCLIENTRECT_ABS: /* return client window in absolute (screen) coordinates */
case WM_GET_CLIENT_WINDOW: /* return handle to client window. For most windows, there is no seperate client window, so it is the same handle */
WM_DefaultProc(pMsg);
return; /* We are done ! */
}
if (cb) {
pMsg->hWin = hParent;
(*cb)(pMsg);
}
}
static void CalcPositions( FRAMEWIN_Handle hObj) {
if (hObj) {
FRAMEWIN_Obj * pObj = FRAMEWIN_H2P(hObj);
int TitleHeight;
int FontSize = GUI_GetYSizeOfFont(pObj->pFont);
int xsize = WM_GetWindowSizeX(hObj);
int ysize = WM_GetWindowSizeY(hObj);
TitleHeight = _DefaultCaptionSize;
/* Make sure defaults are o.k. for us */
if (FontSize + 2 >= TitleHeight)
TitleHeight = FontSize + 2;
/* Set object properties accordingly */
pObj->rClient.x0 = _DefaultBorderSize;
pObj->rClient.x1 = xsize - _DefaultBorderSize - 1;
pObj->rClient.y0 = _DefaultBorderSize + FRAMEWIN_IBORDER_DEFAULT + TitleHeight;
pObj->rClient.y1 = ysize - _DefaultBorderSize - 1;
pObj->FrameSize = _DefaultBorderSize;
pObj->TitleHeight = TitleHeight;
if (pObj->hClient) {
WM_MoveTo (pObj->hClient,
pObj->rClient.x0 + pObj->Widget.Win.Rect.x0,
pObj->rClient.y0 + pObj->Widget.Win.Rect.y0);
WM_SetSize(pObj->hClient,
pObj->rClient.x1 - pObj->rClient.x0 + 1,
pObj->rClient.y1 - pObj->rClient.y0 + 1);
}
}
}
FRAMEWIN_Handle FRAMEWIN_CreateAsChild(
int x0, int y0, int xsize, int ysize, WM_HWIN hParent,
const char* pText, WM_CALLBACK* cb, int Flags)
{
FRAMEWIN_Handle hObj;
/* Create the window */
GUI_LOCK();
hObj = WM_CreateWindowAsChild(x0, y0, xsize/*+2*HBorder*/, ysize/*+TBorder+BBorder*/, hParent,
Flags, _FRAMEWIN_Callback, sizeof(FRAMEWIN_Obj) - sizeof(WM_Obj));
if (hObj) {
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
/* init widget specific variables */
WIDGET__Init(&pObj->Widget, WIDGET_STATE_FOCUSSABLE | WIDGET_STATE_ENABLED);
/* init member variables */
pObj->pFont = _pDefaultFont;
memcpy(pObj->BarColor, _aBarColor, sizeof(pObj->BarColor));
pObj->TextColor = 0xffffff;
pObj->TextAlign = GUI_TA_LEFT;
pObj->ClientColor = _DefaultClientColor;
pObj->pText = pText;
pObj->XOff = 1;
pObj->YOff = 1;
pObj->cb = cb;
CalcPositions(hObj);
pObj->hClient = WM_CreateWindowAsChild(0, 0, 0, 0, hObj, WM_CF_SHOW, FRAMEWIN__cbClient, 0);
}
GUI_UNLOCK();
return hObj;
}
void FRAMEWIN_SetBarColor(FRAMEWIN_Handle hObj, int index, GUI_COLOR color) {
GUI_LOCK();
if (hObj) {
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
pObj->BarColor[index] = color;
FRAMEWIN_Invalidate(hObj);
}
GUI_UNLOCK();
}
void FRAMEWIN_SetClientColor(FRAMEWIN_Handle hObj, GUI_COLOR Color) {
GUI_LOCK();
if (hObj) {
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
pObj->ClientColor = Color;
FRAMEWIN_Invalidate(hObj);
}
GUI_UNLOCK();
}
/*********************************************************************
*
* FRAMEWIN_Maximize
*/
void FRAMEWIN_Maximize(FRAMEWIN_Handle hObj) {
if (hObj) {
FRAMEWIN_Obj* pObj;
WM_LOCK();
pObj = FRAMEWIN_H2P(hObj);
_MaximizeFramewin(hObj, pObj);
WM_UNLOCK();
}
}
/*********************************************************************
*
* FRAMEWIN_Restore
*/
void FRAMEWIN_Restore(FRAMEWIN_Handle hObj) {
if (hObj) {
FRAMEWIN_Obj* pObj;
WM_LOCK();
pObj = FRAMEWIN_H2P(hObj);
_RestoreMinimized(hObj, pObj);
_RestoreMaximized(hObj, pObj);
WM_UNLOCK();
}
}
/*********************************************************************
*
* Exported routines: Various methods
*
**********************************************************************
*/
void FRAMEWIN_SetFont(FRAMEWIN_Handle hObj, const GUI_FONT* pFont) {
GUI_LOCK();
if (hObj) {
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
pObj->pFont = pFont;
CalcPositions(hObj);
FRAMEWIN_Invalidate(hObj);
}
GUI_UNLOCK();
}
void FRAMEWIN_SetTextPos(FRAMEWIN_Handle hObj, int XOff, int YOff) {
GUI_LOCK();
if (hObj) {
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
pObj->XOff = XOff;
pObj->YOff = YOff;
FRAMEWIN_Invalidate(hObj);
}
GUI_UNLOCK();
}
FRAMEWIN_Handle FRAMEWIN_CreateIndirect(const GUI_WIDGET_CREATE_INFO* pCreateInfo, WM_HWIN hWinParent, int x0, int y0, WM_CALLBACK* pCallback) {
FRAMEWIN_Handle hObj;
hObj = FRAMEWIN_CreateAsChild(
pCreateInfo->x0 + x0, pCreateInfo->y0 + y0, pCreateInfo->xSize, pCreateInfo->ySize, hWinParent,
pCreateInfo->pName, pCallback, 0);
if (hObj) {
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
pObj->Flags = pCreateInfo->Flags;
}
return hObj;
}
/*********************************************************************
*
* FRAMEWIN_IsMaximized
*/
int FRAMEWIN_IsMaximized(FRAMEWIN_Handle hObj) {
int r = 0;
if (hObj) {
FRAMEWIN_Obj* pObj;
WM_LOCK();
pObj = FRAMEWIN_H2P(hObj);
r = (pObj->Flags & FRAMEWIN_SF_MAXIMIZED) ? 1 : 0;
WM_UNLOCK();
}
return r;
}
/*********************************************************************
*
* _Draw
*/
static void _Draw(void) {
FRAMEWIN_Obj* pObj;
WM_HWIN hWin;
hWin = WM_GetActiveWindow();
hWin = WM_GetParent(hWin);
pObj = FRAMEWIN_H2P(hWin);
if (pObj->Flags & FRAMEWIN_SF_MAXIMIZED) {
_DrawRestore();
} else {
_DrawMax();
}
}
/*********************************************************************
*
* FRAMEWIN_SetFont
*/
void FRAMEWIN_SetFont(FRAMEWIN_Handle hObj, const GUI_FONT GUI_UNI_PTR * pFont) {
GUI_LOCK();
if (hObj) {
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
int OldHeight = FRAMEWIN__CalcTitleHeight(pObj);
pObj->Props.pFont = pFont;
FRAMEWIN__UpdatePositions(pObj);
FRAMEWIN__UpdateButtons(pObj, OldHeight);
FRAMEWIN_Invalidate(hObj);
}
GUI_UNLOCK();
}
/*********************************************************************
*
* Callback
*
* This is the overwritten callback routine for the button.
* The primary reason for overwriting it is that we define the default
* action of the Framewindow here.
* It works as follows:
* - User clicks and releases the button
* -> BUTTON sends WM_NOTIFY_PARENT to FRAMEWIN
* -> FRAMEWIN either a) reacts or b)sends WM_NOTIFY_PARENT_REFLECTION back
* In case of a) This module reacts !
*/
static void _cbMax(WM_MESSAGE* pMsg) {
if (pMsg->MsgId == WM_NOTIFY_PARENT_REFLECTION) {
WM_HWIN hWin = pMsg->hWinSrc;
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hWin);
if (pObj->Flags & FRAMEWIN_SF_MAXIMIZED) {
FRAMEWIN_Restore(hWin);
} else {
FRAMEWIN_Maximize(hWin);
}
return; /* We are done ! */
}
BUTTON_Callback(pMsg);
}
/*********************************************************************
*
* FRAMEWIN_SetResizeable
*/
void FRAMEWIN_SetResizeable(FRAMEWIN_Handle hObj, int State) {
if (hObj) {
FRAMEWIN_Obj* pObj;
WM_LOCK();
pObj = FRAMEWIN_H2P(hObj);
if (pObj) {
if (State) {
GUI_HOOK_Add(&pObj->pFirstHook, &_HOOK_Resizeable, &_HOOKFUNC_Resizeable);
} else {
GUI_HOOK_Remove(&pObj->pFirstHook, &_HOOK_Resizeable);
}
}
WM_UNLOCK();
}
}
void FRAMEWIN_SetText(FRAMEWIN_Handle hObj, const char* s) {
char NeedsInvalidate;
GUI_LOCK();
if (hObj) {
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
NeedsInvalidate = 1;
if (s && pObj->pText) {
if (strcmp(s, pObj->pText) == 0) {
NeedsInvalidate = 0;
}
}
pObj->pText = s;
if (NeedsInvalidate) {
FRAMEWIN_Invalidate(hObj);
}
}
GUI_UNLOCK();
}
void FRAMEWIN_SetTextAlign(FRAMEWIN_Handle hObj, int Align) {
GUI_LOCK();
if (hObj) {
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
pObj->TextAlign = Align;
switch (Align) {
case GUI_TA_HCENTER:
pObj->XOff = (pObj->rClient.x1 - pObj->rClient.x0) / 2;
break;
case GUI_TA_LEFT:
pObj->XOff = pObj->FrameSize;
break;
case GUI_TA_RIGHT:
pObj->XOff = pObj->rClient.x1 - pObj->FrameSize;
break;
}
FRAMEWIN_Invalidate(hObj);
}
GUI_UNLOCK();
}
/*********************************************************************
*
* Framewin Callback
*/
static void _FRAMEWIN_Callback (WM_MESSAGE *pMsg) {
FRAMEWIN_Handle hWin = (FRAMEWIN_Handle)(pMsg->hWin);
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hWin);
GUI_RECT* pRect = (GUI_RECT*)(pMsg->Data.p);
switch (pMsg->MsgId) {
case WM_PAINT:
_Paint(pObj);
break;
case WM_TOUCH:
_OnTouch(hWin, pObj, pMsg);
return; /* Return here ... Message handled */
case WM_GETCLIENTRECT:
*pRect = pObj->rClient;
return; /* Return here ... Message handled */
case WM_GETCLIENTRECT_ABS: /* Do not seperate from WM_GETCLIENTRECT !!! */
*pRect = pObj->rClient;
GUI_MoveRect(pRect, pObj->Widget.Win.Rect.x0, pObj->Widget.Win.Rect.y0);
return; /* Return here ... Message handled */
case WM_GET_CLIENT_WINDOW: /* return handle to client window. For most windows, there is no seperate client window, so it is the same handle */
pMsg->Data.v = pObj->hClient;
return; /* Return here ... Message handled */
case WM_GET_FOCUSSED_CHILD:
pMsg->Data.v = pObj->hFocussedChild;
return; /* Return here ... Message handled */
case WM_SET_FOCUS:
if (pMsg->Data.v == 1) {
WM_SetFocus(pObj->hFocussedChild);
} else {
WM_SetFocus(0);
}
return;
}
/* Let widget handle the standard messages */
if (WIDGET_HandleActive(hWin, pMsg) == 0) {
return;
}
WM_DefaultProc(pMsg);
}
/*********************************************************************
*
* FRAMEWIN_AddButton
*/
WM_HWIN FRAMEWIN_AddButton(FRAMEWIN_Handle hObj, int Flags, int Off, int Id) {
WM_HWIN r = 0;
if (hObj) {
FRAMEWIN_Obj* pObj;
POSITIONS Pos;
int Size = FRAMEWIN_GetTitleHeight(hObj);
int BorderSize = FRAMEWIN_GetBorderSize(hObj);
int WinFlags, x;
WM_LOCK();
pObj = FRAMEWIN_H2P(hObj);
FRAMEWIN__CalcPositions(pObj, &Pos);
if (Flags & FRAMEWIN_BUTTON_RIGHT) {
x = Pos.rTitleText.x1 - (Size - 1) - Off;
WinFlags = WM_CF_SHOW | WM_CF_ANCHOR_RIGHT;
} else {
x = Pos.rTitleText.x0 + Off;
WinFlags = WM_CF_SHOW;
}
r = BUTTON_CreateAsChild(x, BorderSize, Size, Size, hObj, Id, WinFlags);
BUTTON_SetFocussable(r, 0);
WM_UNLOCK();
}
return r;
}
