开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
framewin.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：17k
源码类别：

uCOS

开发平台：

C/C++

framewin.c：源码内容
  1. /*
  2. *********************************************************************************************************
  3. *                                                uC/GUI
  4. *                        Universal graphic software for embedded applications
  5. *
  6. *                       (c) Copyright 2002, Micrium Inc., Weston, FL
  7. *                       (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
  8. *
  9. *              礐/GUI is protected by international copyright laws. Knowledge of the
  10. *              source code may not be used to write a similar product. This file may
  11. *              only be used in accordance with a license and should not be redistributed
  12. *              in any way. We appreciate your understanding and fairness.
  13. *
  14. ----------------------------------------------------------------------
  15. File        : FRAMEWIN.c
  16. Purpose     : Framewindow for emWin GSC
  17. ---------------------------END-OF-HEADER------------------------------
  18. */
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include "FRAMEWIN.h"
  24. #include "WIDGET.h"
  25. #include "GUI_Protected.h"
  26. #if GUI_WINSUPPORT
  28. /*
  29.   *****************************************************************
  30.   *                                                               *
  31.   *              Config defaults                                  *
  32.   *                                                               *
  33.   *****************************************************************
  34. */
  35. /* Support for 3D effects */
  36. #ifndef FRAMEWIN_USE_3D
  37.   #define FRAMEWIN_USE_3D 1
  38. #endif
  40. #ifndef FRAMEWIN_CLIENTCOLOR_DEFAULT
  41.   #define FRAMEWIN_CLIENTCOLOR_DEFAULT 0xc0c0c0
  42. #endif
  44. /* Default for top frame size */
  45. #ifndef FRAMEWIN_CAPTIONSIZE_DEFAULT
  46.   #define FRAMEWIN_CAPTIONSIZE_DEFAULT 12
  47. #endif
  49. /* Default for left/right/top/bottom frame size */
  50. #ifndef FRAMEWIN_BORDER_DEFAULT
  51.   #define FRAMEWIN_BORDER_DEFAULT 3
  52. #endif
  54. /* Default for inner frame size */
  55. #ifndef FRAMEWIN_IBORDER_DEFAULT
  56.   #define FRAMEWIN_IBORDER_DEFAULT 1
  57. #endif
  59. #ifndef FRAMEWIN_DEFAULT_FONT
  60.   #define FRAMEWIN_DEFAULT_FONT &GUI_Font8_1
  61. #endif
  63. #ifndef FRAMEWIN_BARCOLOR_ACTIVE_DEFAULT
  64.   #define FRAMEWIN_BARCOLOR_ACTIVE_DEFAULT 0xff0000
  65. #endif
  67. #ifndef FRAMEWIN_BARCOLOR_INACTIVE_DEFAULT
  68.   #define FRAMEWIN_BARCOLOR_INACTIVE_DEFAULT 0x404040
  69. #endif
  71. #ifndef FRAMEWIN_FRAMECOLOR_DEFAULT
  72.   #define FRAMEWIN_FRAMECOLOR_DEFAULT 0xaaaaaa
  73. #endif
  77. /************************************************************
  78. *
  79. *                 Object definition
  80. *
  81. *************************************************************
  82. */
  84. typedef struct {
  85.   WIDGET Widget;
  86.   GUI_COLOR BarColor[2];
  87.   GUI_COLOR TextColor;
  88.   WM_CALLBACK* cb;
  89.   WM_HWIN hClient;
  90.   GUI_POINT CapturePoint;
  91.   const GUI_FONT* pFont;
  92.   GUI_RECT rClient;
  93.   GUI_COLOR ClientColor;
  94.   const char* pText;
  95.   I16 XOff, YOff;
  96.   I16 FrameSize;
  97.   I16 TitleHeight;
  98.   I16 TextAlign;
  99.   U16 Flags;
  100.   WM_HWIN hFocussedChild;          /* Handle to focussed child .. default none (0) */
  101. //  char HasFocus;
  102. } FRAMEWIN_Obj;
  104. /*********************************************************************
  105. *
  106. *       Static data
  107. *
  108. **********************************************************************
  109. */
  111. static const GUI_FONT* _pDefaultFont = FRAMEWIN_DEFAULT_FONT;
  112. static   GUI_COLOR _aBarColor[2] = {
  113.   FRAMEWIN_BARCOLOR_INACTIVE_DEFAULT,
  114.   FRAMEWIN_BARCOLOR_ACTIVE_DEFAULT
  115. };
  116. static GUI_COLOR _DefaultClientColor = FRAMEWIN_CLIENTCOLOR_DEFAULT;
  117. static int _DefaultCaptionSize       = FRAMEWIN_CAPTIONSIZE_DEFAULT;
  118. static int _DefaultBorderSize        = FRAMEWIN_BORDER_DEFAULT;
  120. /*
  121.   ********************************************************************
  122.   *                                                                  *
  123.   *                 Macros for internal use                          *
  124.   *                                                                  *
  125.   ********************************************************************
  126. */
  128. #define FRAMEWIN_H2P(h) (FRAMEWIN_Obj*) WM_HMEM2Ptr(h)
  130. /*
  131. ********************************************************************
  132. *                                                                  *
  133. *                    Static routines                               *
  134. *                                                                  *
  135. ********************************************************************
  136. */
  141. static void _OnTouch(FRAMEWIN_Handle hWin, FRAMEWIN_Obj* pObj, WM_MESSAGE* pMsg) {
  142.   GUI_TOUCH_tState* pState;
  143.   pState = (GUI_TOUCH_tState*)pMsg->Data.p;
  144.   if (pMsg->Data.p) {  /* Something happened in our area (pressed or released) */
  145.     if (pState->Pressed) {
  146.       WM_SetFocus(hWin);
  147.       WM_BringToTop(hWin);
  148.       if (pObj->Flags & FRAMEWIN_SF_MOVEABLE) {
  149.         if (!WM_HasCaptured(hWin)) {
  150.           WM_SetCapture(hWin, 1);
  151.           pObj->CapturePoint.x = pState->x;
  152.           pObj->CapturePoint.y = pState->y;
  153.         } else {
  154.           int dx, dy;
  155.           dx = pState->x - pObj->CapturePoint.x;
  156.           dy = pState->y - pObj->CapturePoint.y;
  157.           WM_MoveWindow(hWin, dx, dy);
  158.         }
  159.       }
  160.     }
  161.   }
  162. }
  164. static void _Paint(FRAMEWIN_Obj* pObj) {
  165.   WM_HWIN hWin = WM_GetActiveWindow();
  166.   int xsize = WM_GetWindowSizeX(hWin);
  167.   int ysize = WM_GetWindowSizeY(hWin);
  168.   int FrameSize = pObj->FrameSize;
  169.   GUI_RECT rClient; GUI_GetClientRect(&rClient);
  170.   GUI_SetFont(pObj->pFont);
  171. /* Draw Title */
  172.   GUI_SetBkColor((pObj->Widget.State & WIDGET_STATE_CHILD_HAS_FOCUS) ? pObj->BarColor[1] : pObj->BarColor[0]);
  173.   GUI_SetColor  (pObj->TextColor);
  174.   GUI_SetTextAlign(pObj->TextAlign);
  175. GUI_ClearRect(FrameSize,FrameSize, xsize-1-FrameSize, FrameSize+pObj->rClient.y0-1);
  176.   GUI_DispStringAt( pObj->pText,
  177.                    FrameSize+pObj->XOff,
  178.                    FrameSize+pObj->YOff);
  179. /* Draw Frame */
  180.   GUI_SetColor  (FRAMEWIN_FRAMECOLOR_DEFAULT);  /* pObj->BarColor[1]*/
  181.   GUI_FillRect  (0, 0, xsize-1, FrameSize-1);
  182. GUI_FillRect  (0, 0, pObj->rClient.x0-1, ysize-1);
  183. GUI_FillRect  (pObj->rClient.x1+1, 0, xsize-1, ysize-1);
  184.   GUI_FillRect  (0, pObj->rClient.y1+1, xsize-1, ysize-1);
  185.   GUI_FillRect  (0, pObj->TitleHeight+FrameSize,
  186.                     xsize-1, pObj->TitleHeight+2*FrameSize-1);
  187. /* Draw Client area */
  188.   WM_SetUserClipArea(&pObj->rClient);
  189.   /*GUI_SetBkColor(pObj->ClientColor);
  190.   GUI_Clear();*/
  191.   WM_SetUserClipArea(NULL);
  192. /* Draw the 3D effect (if configured) */
  193.   #if FRAMEWIN_USE_3D
  194.     WIDGET_EFFECT_3D_DrawUp();
  195.   #endif
  196.   
  197. }
  200. static void CalcPositions( FRAMEWIN_Handle hObj) {
  201.   if (hObj) {
  202.     FRAMEWIN_Obj * pObj = FRAMEWIN_H2P(hObj);
  203.     int TitleHeight;
  204.     int FontSize = GUI_GetYSizeOfFont(pObj->pFont);
  205.     int xsize = WM_GetWindowSizeX(hObj);
  206.     int ysize = WM_GetWindowSizeY(hObj);
  207.     TitleHeight = _DefaultCaptionSize;
  208.     /* Make sure defaults are o.k. for us */
  209.     if (FontSize + 2 >= TitleHeight)
  210.       TitleHeight = FontSize + 2;
  211.     /* Set object properties accordingly */
  212.     pObj->rClient.x0  =         _DefaultBorderSize;
  213.     pObj->rClient.x1  = xsize - _DefaultBorderSize - 1;
  214.     pObj->rClient.y0  =         _DefaultBorderSize + FRAMEWIN_IBORDER_DEFAULT + TitleHeight;
  215.     pObj->rClient.y1  = ysize - _DefaultBorderSize - 1;
  216.     pObj->FrameSize   =         _DefaultBorderSize;
  217.     pObj->TitleHeight = TitleHeight;
  218.     if (pObj->hClient) {
  219.       WM_MoveTo (pObj->hClient, 
  220.                  pObj->rClient.x0 + pObj->Widget.Win.Rect.x0, 
  221.                  pObj->rClient.y0 + pObj->Widget.Win.Rect.y0);
  222.       WM_SetSize(pObj->hClient, 
  223.                  pObj->rClient.x1 - pObj->rClient.x0 + 1, 
  224.                  pObj->rClient.y1 - pObj->rClient.y0 + 1);
  225.     }
  226.   }  
  227. }
  229. /*********************************************************************
  230. *
  231. *       Framewin Callback
  232. */
  233. static void _FRAMEWIN_Callback (WM_MESSAGE *pMsg) {
  234.   FRAMEWIN_Handle hWin = (FRAMEWIN_Handle)(pMsg->hWin);
  235.   FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hWin);
  236.   GUI_RECT* pRect = (GUI_RECT*)(pMsg->Data.p);
  237.   switch (pMsg->MsgId) {
  238.   case WM_PAINT:
  239.     _Paint(pObj);
  240.     break;
  241.   case WM_TOUCH:
  242.     _OnTouch(hWin, pObj, pMsg);
  243.     return;                       /* Return here ... Message handled */
  244.   case WM_GETCLIENTRECT:
  245. *pRect = pObj->rClient;
  246.     return;                       /* Return here ... Message handled */
  247.   case WM_GETCLIENTRECT_ABS:  /* Do not seperate from WM_GETCLIENTRECT !!! */
  248.   *pRect = pObj->rClient;
  249.     GUI_MoveRect(pRect, pObj->Widget.Win.Rect.x0, pObj->Widget.Win.Rect.y0);
  250.     return;                       /* Return here ... Message handled */
  251.   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 */
  252.     pMsg->Data.v = pObj->hClient;
  253.     return;                       /* Return here ... Message handled */
  254.   case WM_GET_FOCUSSED_CHILD:
  255.     pMsg->Data.v = pObj->hFocussedChild;
  256.     return;                       /* Return here ... Message handled */
  257.   case WM_SET_FOCUS:
  258.     if (pMsg->Data.v == 1) {
  259.       WM_SetFocus(pObj->hFocussedChild);
  260.     } else {
  261.       WM_SetFocus(0);
  262.     }
  263.     return;
  264.   }
  265.   /* Let widget handle the standard messages */
  266.   if (WIDGET_HandleActive(hWin, pMsg) == 0) {
  267.     return;
  268.   }
  269.   WM_DefaultProc(pMsg);
  270. }
  272. /*********************************************************************
  273. *
  274. *       Client Callback
  275. */
  276. static void FRAMEWIN__cbClient(WM_MESSAGE* pMsg) {
  277.   WM_HWIN hWin    = pMsg->hWin;
  278.   WM_HWIN hParent = WM_GetParent(pMsg->hWin);
  279.   FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hParent);
  280.   WM_CALLBACK* cb = pObj->cb;
  281.   switch (pMsg->MsgId) {
  282.     case WM_PAINT:
  283.       GUI_SetBkColor(pObj->ClientColor);
  284.       GUI_Clear();
  285.       if (pObj->cb) {
  286.       WM_MESSAGE msg;
  287.         msg.hWin   = hWin;
  288.     msg.MsgId  = WM_PAINT;
  289.         (*pObj->cb)(&msg);
  290.       }
  291.       return;
  292.     case WM_GET_FOCUSSED_CHILD:
  293.       pMsg->Data.v = pObj->hFocussedChild;
  294.       return;
  295.     case WM_SET_FOCUS:
  296.       if (pMsg->Data.v) {      /* Focus received */
  297.         if (pObj->hFocussedChild) {
  298.           WM_SendMessage(pObj->hFocussedChild, pMsg);
  299.         } else {
  300.           pObj->hFocussedChild = WM_SetFocusOnNextChild(hWin);
  301.         }
  302.       }
  303.       return;
  304.     case WM_KEY:
  305.       if ( ((WM_KEY_INFO*)(pMsg->Data.p))->PressedCnt >0) {
  306.         int Key = ((WM_KEY_INFO*)(pMsg->Data.p))->Key;
  307.         switch (Key) {
  308.           case GUI_KEY_TAB:
  309.             pObj->hFocussedChild = WM_SetFocusOnNextChild(hWin);
  310.             break;                    /* Send to parent by not doing anything */
  311.         }
  312.       }
  313.       break;
  314.     case WM_NOTIFY_CHILD_HAS_FOCUS:
  315.       pObj->hFocussedChild = pMsg->hWinSrc;
  316.       if (pMsg->Data.v) {
  317.         pObj->Widget.State |= WIDGET_STATE_CHILD_HAS_FOCUS;
  318.       } else {
  319.         pObj->Widget.State &= ~WIDGET_STATE_CHILD_HAS_FOCUS;
  320.       }
  321.       WM_InvalidateWindow(hParent);
  322.       break;
  323.     case WM_GET_BKCOLOR:
  324.       pMsg->Data.Color = pObj->ClientColor;
  325.       return;                       /* Message handled */
  326.     case WM_GETCLIENTRECT_ABS:      /* return client window in absolute (screen) coordinates */
  327.     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 */
  328.       WM_DefaultProc(pMsg);
  329.       return;                       /* We are done ! */
  330.   }
  331.   if (cb) {
  332.     pMsg->hWin = hParent;
  333.     (*cb)(pMsg);
  334.   }
  335. }
  337. /*********************************************************************
  338. *
  339. *        Exported routines:  Create
  340. *
  341. **********************************************************************
  342. */
  344. FRAMEWIN_Handle FRAMEWIN_CreateAsChild( 
  345.                                     int x0, int y0, int xsize, int ysize, WM_HWIN hParent,
  346.                                     const char* pText, WM_CALLBACK* cb, int Flags)
  347. {
  348.   FRAMEWIN_Handle hObj;
  349.   /* Create the window */
  350.   GUI_LOCK();
  351.   hObj = WM_CreateWindowAsChild(x0, y0, xsize/*+2*HBorder*/, ysize/*+TBorder+BBorder*/, hParent,
  352.                         Flags, _FRAMEWIN_Callback, sizeof(FRAMEWIN_Obj) - sizeof(WM_Obj));
  353.   if (hObj) {
  354.     FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
  355.     /* init widget specific variables */
  356.     WIDGET__Init(&pObj->Widget, WIDGET_STATE_FOCUSSABLE | WIDGET_STATE_ENABLED);
  357.     /* init member variables */
  358.     pObj->pFont = _pDefaultFont;
  359.     memcpy(pObj->BarColor, _aBarColor, sizeof(pObj->BarColor));
  360.     pObj->TextColor    = 0xffffff;
  361.     pObj->TextAlign    = GUI_TA_LEFT;
  362.     pObj->ClientColor  = _DefaultClientColor;
  363.     pObj->pText        = pText;
  364.     pObj->XOff = 1;
  365.     pObj->YOff = 1;
  366.     pObj->cb = cb;
  367.     CalcPositions(hObj);
  368.     pObj->hClient = WM_CreateWindowAsChild(0, 0, 0, 0, hObj, WM_CF_SHOW, FRAMEWIN__cbClient, 0);
  369.   }
  370.   GUI_UNLOCK();
  371.   return hObj;
  372. }
  374. FRAMEWIN_Handle FRAMEWIN_Create( const char* pText,
  375.                                     WM_CALLBACK* cb,
  376.                                     int Flags,
  377.                                     int x0, int y0, int xsize, int ysize) {
  379.   return FRAMEWIN_CreateAsChild(x0, y0, xsize, ysize, WM_HWIN_NULL, pText, cb, Flags);
  380. }
  383. FRAMEWIN_Handle FRAMEWIN_CreateIndirect(const GUI_WIDGET_CREATE_INFO* pCreateInfo, WM_HWIN hWinParent, int x0, int y0, WM_CALLBACK* pCallback) {
  384.   FRAMEWIN_Handle hObj;
  385.   hObj = FRAMEWIN_CreateAsChild(
  386.     pCreateInfo->x0 + x0, pCreateInfo->y0 + y0, pCreateInfo->xSize, pCreateInfo->ySize, hWinParent,
  387.     pCreateInfo->pName, pCallback, 0);
  388.   if (hObj) {
  389.     FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
  390.     pObj->Flags = pCreateInfo->Flags;
  391.   }
  392.   return hObj;
  393. }
  395. /*********************************************************************
  396. *
  397. *        Exported routines:  Various methods
  398. *
  399. **********************************************************************
  400. */
  401. void FRAMEWIN_SetFont(FRAMEWIN_Handle hObj, const GUI_FONT* pFont) {
  402.   GUI_LOCK();
  403.   if (hObj) {
  404.     FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
  405.     pObj->pFont = pFont;
  406.     CalcPositions(hObj);
  407.     FRAMEWIN_Invalidate(hObj);
  408.   }
  409.   GUI_UNLOCK();
  410. }
  412. void FRAMEWIN_SetBarColor(FRAMEWIN_Handle hObj, int index, GUI_COLOR color) {
  413.   GUI_LOCK();
  414.   if (hObj) {
  415.     FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
  416.     pObj->BarColor[index] = color;
  417.     FRAMEWIN_Invalidate(hObj);
  418.   }
  419.   GUI_UNLOCK();
  420. }
  422. void FRAMEWIN_SetTextColor(FRAMEWIN_Handle hObj, GUI_COLOR color) {
  423.   GUI_LOCK();
  424.   if (hObj) {
  425.     FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
  426.     pObj->TextColor = color;
  427.     FRAMEWIN_Invalidate(hObj);
  428.   }
  429.   GUI_UNLOCK();
  430. }
  432. void FRAMEWIN_SetText(FRAMEWIN_Handle hObj, const char* s) {
  433.   char NeedsInvalidate;
  434.   GUI_LOCK();
  435.   if (hObj) {
  436.     FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
  437.     NeedsInvalidate = 1;
  438.     if (s && pObj->pText) {
  439.       if (strcmp(s, pObj->pText) == 0) {
  440.         NeedsInvalidate = 0;
  441.       }
  442.     }
  443.     pObj->pText = s;
  444.     if (NeedsInvalidate) {
  445.       FRAMEWIN_Invalidate(hObj);
  446.     }
  447.   }
  448.   GUI_UNLOCK();
  449. }
  451. void FRAMEWIN_SetTextAlign(FRAMEWIN_Handle hObj, int Align) {
  452.   GUI_LOCK();
  453.   if (hObj) {
  454.     FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
  455.     pObj->TextAlign = Align;
  456.     switch (Align) {
  457.     case GUI_TA_HCENTER:
  458.       pObj->XOff = (pObj->rClient.x1 - pObj->rClient.x0) / 2;
  459.       break;
  460.     case GUI_TA_LEFT:
  461.       pObj->XOff = pObj->FrameSize;
  462.       break;
  463.     case GUI_TA_RIGHT:
  464.       pObj->XOff = pObj->rClient.x1 - pObj->FrameSize;
  465.       break;
  466.     }
  467.     FRAMEWIN_Invalidate(hObj);
  468.   }
  469.   GUI_UNLOCK();
  470. }
  472. void FRAMEWIN_SetTextPos(FRAMEWIN_Handle hObj, int XOff, int YOff) {
  473.   GUI_LOCK();
  474.   if (hObj) {
  475.     FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
  476.     pObj->XOff = XOff;
  477.     pObj->YOff = YOff;
  478.     FRAMEWIN_Invalidate(hObj);
  479.   }
  480.   GUI_UNLOCK();
  481. }
  483. void FRAMEWIN_SetActive(FRAMEWIN_Handle hObj, int State) {
  484.   GUI_LOCK();
  485.   if (hObj) {
  486.     if (State) {
  487.       FRAMEWIN_SetBarColor(hObj, 0, FRAMEWIN_BARCOLOR_ACTIVE_DEFAULT);
  488.     } else {
  489.       FRAMEWIN_SetBarColor(hObj, 0, FRAMEWIN_BARCOLOR_INACTIVE_DEFAULT);
  490.     }
  491.   }
  492.   GUI_UNLOCK();
  493. }
  495. void FRAMEWIN_SetClientColor(FRAMEWIN_Handle hObj, GUI_COLOR Color) {
  496.   GUI_LOCK();
  497.   if (hObj) {
  498.     FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hObj);
  499.     pObj->ClientColor = Color;
  500.     FRAMEWIN_Invalidate(hObj);
  501.   }
  502.   GUI_UNLOCK();
  503. }
  505.   /***************************************************************
  506.   *
  507.   *                Set/Get defaults
  508.   *
  509.   ***************************************************************/
  511. void FRAMEWIN_SetDefaultFont(const GUI_FONT* pFont) {
  512.   _pDefaultFont = pFont;
  513. }
  515. const GUI_FONT* FRAMEWIN_GetDefaultFont(void) {
  516.   return _pDefaultFont;
  517. }
  519. void FRAMEWIN_SetDefaultBarColor(int Index, GUI_COLOR Color) {
  520.   if ((Index >= 0) && (Index <= 1)) {
  521.     _aBarColor[Index] = Color;
  522.   }
  523. }
  525. GUI_COLOR FRAMEWIN_GetDefaultBarColor(int Index) {
  526.   GUI_COLOR r = 0;
  527.   if ((Index >= 0) && (Index <= 1)) {
  528.     r = _aBarColor[Index];
  529.   }
  530.   return r;
  531. }
  533. void FRAMEWIN_SetDefaultClientColor(GUI_COLOR Color) {
  534.   _DefaultClientColor = Color;
  535. }
  537. GUI_COLOR FRAMEWIN_GetDefaultClientColor(void) {
  538.   return _DefaultClientColor;
  539. }
  541. int FRAMEWIN_GetDefaultCaptionSize(void) {
  542.   return _DefaultCaptionSize;
  543. }
  545. void FRAMEWIN_SetDefaultCaptionSize(int DefaultCaptionSize) {
  546.   _DefaultCaptionSize = DefaultCaptionSize;
  547. }
  549. int FRAMEWIN_GetDefaultBorderSize(void) {
  550.   return _DefaultBorderSize;
  551. }
  553. void FRAMEWIN_SetDefaultBorderSize(int DefaultBorderSize) {
  554.   _DefaultBorderSize = DefaultBorderSize;
  555. }
  557. #else
  558.   void WIDGET_FrameWin(void) {} /* avoid empty object files */
  559. #endif /* GUI_WINSUPPORT */