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

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

uCOS

开发平台：

C/C++

edit.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        : EDIT.c
  16. Purpose     : emWin GSC button widget
  17. ---------------------------END-OF-HEADER------------------------------
  18. */
  20. #include <stdlib.h>
  21. #include <string.h>
  23. #define EDIT_C       /* Required to generate intermodule data */
  25. #include "EDIT.h"
  26. #include "GUIDebug.h"
  27. #include "GUI_Protected.h"
  28. #include "EDIT_Private.h"
  30. #if GUI_WINSUPPORT
  32. /*********************************************************************
  33. *
  34. *       Private config defaults
  35. *
  36. **********************************************************************
  37. */
  39. #ifndef EDIT_LOG_ENABLE
  40.   #ifdef _DEBUG
  41.     #define EDIT_LOG_ENABLE 0
  42.   #else
  43.     #define EDIT_LOG_ENABLE 0
  44.   #endif
  45. #endif
  47. /* Define default fonts */
  48. #ifndef EDIT_FONT_DEFAULT
  49.   #define EDIT_FONT_DEFAULT &GUI_Font13_1
  50. #endif
  52. #ifndef EDIT_ALIGN_DEFAULT
  53.   #define EDIT_ALIGN_DEFAULT GUI_TA_RIGHT | GUI_TA_VCENTER
  54. #endif
  56. /* Define colors */
  57. #ifndef EDIT_BKCOLOR0_DEFAULT
  58.   #define EDIT_BKCOLOR0_DEFAULT 0xc0c0c0
  59. #endif
  61. #ifndef EDIT_BKCOLOR1_DEFAULT
  62.   #define EDIT_BKCOLOR1_DEFAULT GUI_WHITE
  63. #endif
  65. #ifndef EDIT_TEXTCOLOR0_DEFAULT
  66.   #define EDIT_TEXTCOLOR0_DEFAULT GUI_BLACK
  67. #endif
  69. #ifndef EDIT_TEXTCOLOR1_DEFAULT
  70.   #define EDIT_TEXTCOLOR1_DEFAULT GUI_BLACK
  71. #endif
  73. #ifndef EDIT_BORDER_DEFAULT
  74.   #define EDIT_BORDER_DEFAULT 1
  75. #endif
  77. #ifndef EDIT_XOFF
  78.   #define EDIT_XOFF 2
  79. #endif
  81. /*********************************************************************
  82. *
  83. *       Static data
  84. *
  85. **********************************************************************
  86. */
  88. static int _DefaultAlign              = EDIT_ALIGN_DEFAULT;
  89. static int _DefaultBorder             = EDIT_BORDER_DEFAULT;
  90. static const GUI_FONT * _pDefaultFont = EDIT_FONT_DEFAULT;
  92. /*********************************************************************
  93. *
  94. *       Macros for internal use
  95. *
  96. **********************************************************************
  97. */
  99. #if GUI_DEBUG_LEVEL >= GUI_DEBUG_LEVEL_CHECK_ALL
  100.   #define OBJECT_ID 0x4569   /* Magic nubmer, should be unique if possible */
  101.   #define INIT_ID(p)   p->DebugId = OBJECT_ID
  102.   #define DEINIT_ID(p) p->DebugId = 0
  103. #else
  104.   #define INIT_ID(p)
  105.   #define DEINIT_ID(p)
  106. #endif
  108. /*********************************************************************
  109. *
  110. *       Static routines
  111. *
  112. **********************************************************************
  113. */
  115. #if GUI_DEBUG_LEVEL >= GUI_DEBUG_LEVEL_CHECK_ALL
  116. EDIT_Obj* EDIT_h2p(EDIT_Handle h) {
  117.   EDIT_Obj* p = (EDIT_Obj*)WM_HMEM2Ptr(h);
  118.   if (p) {
  119.     if (p->DebugId != OBJECT_ID) {
  120.       GUI_DEBUG_ERROROUT("EDIT.C: Wrong handle type or Object not init'ed");
  121.       return 0;
  122.     }
  123.   }
  124.   return p;
  125. }
  126. #endif
  128. /*********************************************************************
  129. *
  130. *       _Paint
  131. */
  132. static void _Paint(EDIT_Obj* pObj) {
  133.   int PixelLen, xSize, ySize, xPosText, xPosCursor, yPosText, yPosCursor, XSizeCursor, YSizeCursor;
  134.   int IsEnabled;
  135.   GUI_RECT rClient, rWindow;
  136.   char * s;
  137.   s = (char*) WM_HMEM2Ptr(pObj->hpText);
  138.   GUI_DEBUG_LOG("BUTTON: _Paint(..)n");
  139.   if (pObj->Border) {
  140.     GUI_SetBkColor(pObj->aBkColor[0]);
  141.     GUI_Clear();
  142.   }
  143.   IsEnabled = WIDGET__IsEnabled(&pObj->Widget);
  144.   /* Set clipping rectangle */
  145.   WIDGET__GetInsideRect(&pObj->Widget, &rWindow);
  146.   WM_SetUserClipRect(&rWindow);
  147.   /* Calculate size */
  148.   GUI_GetClientRect(&rClient);
  149.   xSize = rClient.x1 - rClient.x0 + 1;
  150.   ySize = rClient.y1 - rClient.y0 + 1;
  151.   /* Draw background */
  152.   GUI_SetBkColor (pObj->aBkColor[IsEnabled]);
  153.   GUI_SetColor   (pObj->aTextColor[0]);
  154.   GUI_Clear();
  155.   /* Calculate length */
  156.   GUI_SetFont    (pObj->pFont);
  157.   PixelLen = GUI_GetStringDistX(s);
  158.   /* Calculate size of cursor */
  159.   YSizeCursor = GUI_GetFontDistY();
  160.   if (pObj->EditMode == GUI_EDIT_MODE_INSERT) {
  161.     if (pObj->XSizeCursor != 0) {
  162.       XSizeCursor = pObj->XSizeCursor;
  163.     } else {
  164.       XSizeCursor = GUI_GetCharDistX(' ');
  165.     }
  166.   } else {
  167.     if (pObj->CursorPos < (int)strlen(s))  {
  168.       XSizeCursor = GUI_GetCharDistX(*(s + pObj->CursorPos));
  169.     } else {
  170.       XSizeCursor = pObj->XSizeCursor;
  171.     }
  172.   }
  173.   /* Calculate X-pos */
  174.   switch (pObj->Align & GUI_TA_HORIZONTAL) {
  175.     case GUI_TA_CENTER:
  176.       xPosCursor = (xSize - PixelLen + 1) / 2;
  177.       xPosText = xSize / 2;
  178.       break;
  179.     case GUI_TA_LEFT:
  180.       xPosCursor = pObj->Border + EDIT_XOFF;
  181.       xPosText   = pObj->Border + EDIT_XOFF;
  182.       break;
  183.     case GUI_TA_RIGHT:
  184.       xPosCursor = xSize - (pObj->Border + EDIT_XOFF) - PixelLen;
  185.       xPosText   = xSize - (pObj->Border + EDIT_XOFF);
  186.       break;
  187.   }
  188.   /* Calculate Y-pos */
  189.   switch (pObj->Align & GUI_TA_VERTICAL) {
  190.     case GUI_TA_TOP:
  191.       yPosCursor = 0;
  192.       yPosText = 0;
  193.       break;
  194.     case GUI_TA_BOTTOM:
  195.       yPosCursor = ySize - YSizeCursor;
  196.       yPosText = ySize;
  197.       break;
  198.     case GUI_TA_VCENTER:
  199.       yPosCursor = (ySize - YSizeCursor + 1) / 2;
  200.       yPosText = ySize / 2;
  201.       break;
  202.   }
  203.   /* Display text */
  204.   GUI_SetTextAlign(pObj->Align);
  205.   GUI_DispStringAt(s, xPosText, yPosText);
  206.   /* Display cursor */
  207.   if (pObj->Widget.State & WIDGET_STATE_FOCUS) {
  208.     int i;
  209.     for (i = 0; i != pObj->CursorPos; i++) {
  210.       xPosCursor += GUI_GetCharDistX(*(s + i));
  211.     }
  212.     GUI_InvertRect(xPosCursor, 
  213.                    yPosCursor, 
  214.                    xPosCursor + XSizeCursor - 1, 
  215.                    yPosCursor + YSizeCursor - 1);
  216.   }
  217.   WM_SetUserClipRect(NULL);
  218.   /* Draw the 3D effect (if configured) */
  219.   WIDGET__EFFECT_DrawDown(&pObj->Widget);
  220. }
  222. /*********************************************************************
  223. *
  224. *       _Delete
  225. */
  226. static void _Delete(EDIT_Obj* pObj) {
  227.   WM_FREEPTR(&pObj->hpText);
  228. }
  231. /*********************************************************************
  232. *
  233. *       _SetCursor
  234. */
  235. static void _SetCursor(EDIT_Handle hObj, EDIT_Obj* pObj, int x) {
  236.   int xPos, xSize, PixelLen, Len;
  237.   char * s = (char*) WM_HMEM2Ptr(pObj->hpText);
  238.   const GUI_FONT *pOldFont = GUI_SetFont(pObj->pFont);
  239.   xSize = WM_GetWindowSizeX(hObj);
  240.   PixelLen = GUI_GetStringDistX(s);
  241.   xPos = x;
  242.   switch (pObj->Align & GUI_TA_HORIZONTAL) {
  243.     case GUI_TA_CENTER:
  244.       xPos -= (xSize - PixelLen + 1) / 2;
  245.       break;
  246.     case GUI_TA_LEFT:
  247.       xPos -= (pObj->Border + EDIT_XOFF);
  248.       break;
  249.     case GUI_TA_RIGHT:
  250.       xPos -= xSize - PixelLen - (pObj->Border + EDIT_XOFF);
  251.       break;
  252.   }
  253.   Len = strlen(s);
  254.   if (xPos < 0) {
  255.     pObj->CursorPos = 0;
  256.   } else if (xPos > PixelLen) {
  257.     pObj->CursorPos = Len;
  258.   } else {
  259.     int i, x;
  260.     for (i = 0, x = 0; (i < Len) && (x < xPos); i++) {
  261.       int xLenChar = GUI_GetCharDistX(*(s + i));
  262.       if (xPos < (x + xLenChar))
  263.         break;
  264.       x += xLenChar;
  265.     }
  266.     pObj->CursorPos = i;
  267.     EDIT_Invalidate(hObj);
  268.   }
  269.   GUI_SetFont(pOldFont);
  270. }
  272. /*********************************************************************
  273. *
  274. *       _OnTouch
  275. */
  276. static void _OnTouch(EDIT_Handle hObj, EDIT_Obj* pObj, WM_MESSAGE*pMsg) {
  277.   GUI_TOUCH_tState* pState = (GUI_TOUCH_tState*)pMsg->Data.p;
  278.   if (pMsg->Data.p) {  /* Something happened in our area (pressed or released) */
  279.     if (pState->Pressed) {
  280.       GUI_DEBUG_LOG1("EDIT__Callback(WM_TOUCH, Pressed, Handle %d)n",1);
  281.       _SetCursor(hObj, pObj, pState->x);
  282.       WM_SetFocus(hObj);
  283.     } else {
  284.       GUI_DEBUG_LOG1("EDIT__Callback(WM_TOUCH, Released, Handle %d)n",1);
  285.     }
  286.   } else {
  287.     GUI_DEBUG_LOG1("_EDIT_Callback(WM_TOUCH, Moved out, Handle %d)n",1);
  288.   }
  289. }
  291. /*********************************************************************
  292. *
  293. *       Callback
  294. */
  295. static void EDIT__Callback (WM_MESSAGE * pMsg) {
  296.   int IsEnabled;
  297.   EDIT_Handle hObj = (EDIT_Handle)pMsg->hWin;
  298.   EDIT_Obj* pObj = (EDIT_Obj*)WM_HMEM2Ptr(hObj);
  299.   IsEnabled = WIDGET__IsEnabled(&pObj->Widget);
  300.   /* Let widget handle the standard messages */
  301.   if (WIDGET_HandleActive(hObj, pMsg) == 0) {
  302.     return;
  303.   }
  304.   switch (pMsg->MsgId) {
  305.   case WM_TOUCH:
  306.     if (IsEnabled) {
  307.       _OnTouch(hObj, pObj, pMsg);
  308.     }
  309.     break;
  310.   case WM_PAINT:
  311.     GUI_DEBUG_LOG("EDIT: _Callback(WM_PAINT)n");
  312.     _Paint(pObj);
  313.     return;
  314.   case WM_DELETE:
  315.     GUI_DEBUG_LOG("EDIT: _Callback(WM_DELETE)n");
  316.     _Delete(pObj);
  317.     break;       /* No return here ... WM_DefaultProc needs to be called */
  318.   case WM_KEY:
  319.     if (IsEnabled) {
  320.       if ( ((WM_KEY_INFO*)(pMsg->Data.p))->PressedCnt >0) {
  321.         int Key = ((WM_KEY_INFO*)(pMsg->Data.p))->Key;
  322.         switch (Key) {
  323.           case GUI_KEY_TAB:
  324.             break;                    /* Send to parent by not doing anything */
  325.           default:
  326.             EDIT_AddKey(hObj, Key);
  327.             return;
  328.         }
  329.       }
  330.     }
  331.     break;
  332.   }
  333.   WM_DefaultProc(pMsg);
  334. }
  336. /*********************************************************************
  337. *
  338. *       Exported routines:  Create
  339. *
  340. **********************************************************************
  341. */
  343. EDIT_Handle EDIT_CreateAsChild     (int x0, int y0, int xsize, int ysize, WM_HWIN hParent, int Id, int Flags, int MaxLen) {
  344.   EDIT_Handle hObj;
  345.   if (MaxLen == 0) {
  346.     MaxLen = 8;
  347.   }
  348.   /* Alloc memory for obj */
  349.   WM_LOCK();
  350.   hObj = WM_CreateWindowAsChild(x0, y0, xsize, ysize, hParent, 
  351.                        WM_CF_SHOW | Flags, EDIT__Callback,
  352.                        sizeof(EDIT_Obj)-sizeof(WM_Obj));
  353.   if (hObj) {
  354.     EDIT_Obj* pObj = (EDIT_Obj*)WM_HMEM2Ptr(hObj);
  355.     /* init widget specific variables */
  356.     WIDGET__Init(&pObj->Widget, WIDGET_STATE_FOCUSSABLE  | WIDGET_STATE_ENABLED);
  357.     pObj->Widget.Id     = Id;
  358.     /* init member variables */
  359.     INIT_ID(pObj);
  360.     pObj->pFont         = _pDefaultFont;
  361.     pObj->aBkColor[0]   = EDIT_BKCOLOR0_DEFAULT;
  362.     pObj->aBkColor[1]   = EDIT_BKCOLOR1_DEFAULT;
  363.     pObj->aTextColor[0] = EDIT_TEXTCOLOR0_DEFAULT;
  364.     pObj->aTextColor[1] = EDIT_TEXTCOLOR1_DEFAULT;
  365.     pObj->Align         = _DefaultAlign;
  366.     pObj->Border        = _DefaultBorder;
  367.     pObj->XSizeCursor   = 1;
  368.     pObj->MaxLen        = MaxLen;
  369.     if ((pObj->hpText = WM_ALLOC(MaxLen+1)) ==0) {
  370.       GUI_DEBUG_ERROROUT("EDIT_Create failed to alloc buffer");
  371.       EDIT_Delete(hObj);
  372.       hObj =0;
  373.     }
  374.   }
  375.   WM_UNLOCK();
  376.   return hObj;
  377. }
  379. EDIT_Handle EDIT_Create(int x0, int y0, int xsize, int ysize, int Id, int MaxLen, int Flags) {
  380.   return EDIT_CreateAsChild(x0, y0, xsize, ysize, WM_HMEM_NULL, Id, Flags, MaxLen);
  381. }
  383. EDIT_Handle EDIT_CreateIndirect(const GUI_WIDGET_CREATE_INFO* pCreateInfo, WM_HWIN hWinParent, int x0, int y0, WM_CALLBACK* pCallback) {
  384.   EDIT_Handle hEdit;
  385.   GUI_USE_PARA(pCallback);
  386.   hEdit = EDIT_CreateAsChild(
  387.     pCreateInfo->x0 + x0, pCreateInfo->y0 + y0, pCreateInfo->xSize, pCreateInfo->ySize,
  388.     hWinParent, pCreateInfo->Id, pCreateInfo->Flags, pCreateInfo->Para);
  389.   return hEdit;
  390. }
  392. /*********************************************************************
  393. *
  394. *       Exported routines:  Various methods
  395. *
  396. **********************************************************************
  397. */
  399. void EDIT_AddKey(EDIT_Handle hObj, int Key) {
  400.   EDIT_Obj* pObj;
  401.   if (hObj == 0)
  402.     return;
  403.   WM_LOCK();
  404.   pObj = EDIT_H2P(hObj);
  405.   if (pObj) {
  406.     if (pObj->pfAddKeyEx) {
  407.       pObj->pfAddKeyEx(pObj, hObj, Key);
  408.     } else {
  409.       char*s = (char*) WM_HMEM2Ptr(pObj->hpText);
  410.       int len = strlen(s);
  411.       switch (Key) {
  412.         case GUI_KEY_UP:
  413.           {
  414.             char c = *(s + pObj->CursorPos);
  415.             if (c < 0x7f) {
  416.               *(s + pObj->CursorPos) = c + 1;
  417.               WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
  418.             }
  419.           }
  420.           break;
  421.         case GUI_KEY_DOWN:
  422.           {
  423.             char c = *(s + pObj->CursorPos);
  424.             if (c > 0x20) {
  425.               *(s + pObj->CursorPos) = c - 1;
  426.               WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
  427.             }
  428.           }
  429.           break;
  430.         case GUI_KEY_RIGHT:
  431.           if (pObj->CursorPos < (pObj->MaxLen - 1))
  432.             if (pObj->CursorPos < len)
  433.               pObj->CursorPos++;
  434.           break;
  435.         case GUI_KEY_LEFT:
  436.           if (pObj->CursorPos > 0)
  437.             pObj->CursorPos--;
  438.           break;
  439.         case GUI_KEY_BACKSPACE:
  440.           if ((len > 0) && (pObj->CursorPos > 0)) {
  441.             int CopyLength = pObj->MaxLen - pObj->CursorPos;
  442.             strncpy(s + pObj->CursorPos - 1, s + pObj->CursorPos, CopyLength);
  443.             *(s + len - 1) = 0;
  444.             WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
  445.             pObj->CursorPos--;
  446.           }
  447.           break;
  448.         case GUI_KEY_DELETE:
  449.           if ((len > 0) && (pObj->CursorPos < len)) {
  450.             if (len > 1) {
  451.               int CopyLength = pObj->MaxLen - pObj->CursorPos - 1;
  452.               strncpy(s + pObj->CursorPos, s + pObj->CursorPos + 1, CopyLength);
  453.             }
  454.             *(s + len - 1) = 0;
  455.             WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
  456.           }
  457.           break;
  458.         case GUI_KEY_INSERT:
  459.           if (pObj->EditMode == GUI_EDIT_MODE_OVERWRITE)
  460.             pObj->EditMode = GUI_EDIT_MODE_INSERT;
  461.           else
  462.             pObj->EditMode = GUI_EDIT_MODE_OVERWRITE;
  463.           break;
  464.         case GUI_KEY_ENTER:
  465.         case GUI_KEY_ESCAPE:
  466.           break;
  467.         default:
  468.           if ((Key >= 0x20) && (Key <= 0x7f)) {
  469.             if (pObj->EditMode == GUI_EDIT_MODE_INSERT) {
  470.               if (len < pObj->MaxLen) {
  471.                 int CopyLength = pObj->MaxLen - pObj->CursorPos - 1;
  472.                 memmove(s + pObj->CursorPos + 1, s + pObj->CursorPos, CopyLength);
  473.                 *(s + pObj->CursorPos) = Key;
  474.                 WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
  475.                 if (pObj->CursorPos < (pObj->MaxLen - 1))
  476.                   pObj->CursorPos++;
  477.               }
  478.             } else {
  479.               *(s + pObj->CursorPos) = Key;
  480.               WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
  481.               if (pObj->CursorPos < (pObj->MaxLen - 1))
  482.                 pObj->CursorPos++;
  483.             }
  484.           }
  485.           break;
  486.       }
  487.     }
  488.     EDIT_Invalidate(hObj);
  489.   }
  490.   WM_UNLOCK();
  491. }
  493. void EDIT_SetFont(EDIT_Handle hObj, const GUI_FONT* pfont) {
  494.   EDIT_Obj* pObj;
  495.   if (hObj == 0)
  496.     return;
  497.   WM_LOCK();
  498.   pObj = EDIT_H2P(hObj);
  499.   if (pObj) {
  500.     pObj->pFont = pfont;
  501.     EDIT_Invalidate(hObj);
  502.   }
  503.   WM_UNLOCK();
  504. }
  506. void EDIT_SetBkColor(EDIT_Handle hObj, int Index, GUI_COLOR color) {
  507.   EDIT_Obj* pObj;
  508.   if (hObj == 0)
  509.     return;
  510.   WM_LOCK();
  511.   pObj = EDIT_H2P(hObj);
  512.   if (pObj) {
  513.     pObj->aBkColor[Index] = color;
  514.     EDIT_Invalidate(hObj);
  515.   }
  516.   WM_UNLOCK();
  517. }
  519. void EDIT_SetTextColor(EDIT_Handle hObj, int Index, GUI_COLOR color) {
  520.   EDIT_Obj* pObj;
  521.   if (hObj == 0)
  522.     return;
  523.   WM_LOCK();
  524.   pObj = EDIT_H2P(hObj);
  525.   if (pObj) {
  526.     pObj->aTextColor[Index] = color;
  527.     EDIT_Invalidate(hObj);
  528.   }
  529.   WM_UNLOCK();
  530. }
  532. void EDIT_SetText     (EDIT_Handle hObj, const char* sNew) {
  533.   EDIT_Obj* pObj;
  534.   if (hObj == 0)
  535.     return;
  536.   WM_LOCK();
  537.   pObj = EDIT_H2P(hObj);
  538.   if (pObj) {
  539.     char*sDest = (char*) WM_HMEM2Ptr(pObj->hpText);
  540.     int Len = sNew ? strlen(sNew) : 0;
  541.     if (Len > pObj->MaxLen)
  542.       Len = pObj->MaxLen;
  543.     memcpy(sDest, sNew, Len);
  544.     *(sDest+Len) = 0;
  545.     pObj->CursorPos = Len;
  546.     if (pObj->CursorPos == pObj->MaxLen)
  547.       pObj->CursorPos--;
  548.     EDIT_Invalidate(hObj);
  549.   }
  550.   WM_UNLOCK();
  551. }
  553. void EDIT_GetText(EDIT_Handle hObj, char* sDest, int MaxLen) {
  554.   EDIT_Obj* pObj;
  555.   if (hObj == 0)
  556.     return;
  557.   WM_LOCK();
  558.   pObj = EDIT_H2P(hObj);
  559.   if (pObj) {
  560.     char * sSource = (char*) WM_HMEM2Ptr(pObj->hpText);
  561.     int Len = strlen(sSource);
  562.     if (Len > (MaxLen - 1))
  563.       Len = MaxLen - 1;
  564.     memcpy((void *)sDest, (const void *)sSource, Len);
  565.     *(sDest+Len) = 0;
  566.   }
  567.   WM_UNLOCK();
  568. }
  570. I32  EDIT_GetValue(EDIT_Handle hObj) {
  571.   EDIT_Obj* pObj;
  572.   I32 r = 0;
  573.   if (hObj) {
  574.     WM_LOCK();
  575.     pObj = EDIT_H2P(hObj);
  576.     r = pObj->CurrentValue;
  577.     WM_UNLOCK();
  578.   }
  579.   return r;
  580. }
  582. void EDIT_SetValue(EDIT_Handle hObj, I32 Value) {
  583.   EDIT_Obj* pObj;
  584.   if (hObj) {
  585.     WM_LOCK();
  586.     pObj = EDIT_H2P(hObj);
  587.     /* Put in min/max range */
  588.     if (Value < pObj->Min) {
  589.       Value = pObj->Min;
  590.     }
  591.     if (Value > pObj->Max) {
  592.       Value = pObj->Max;
  593.     }
  594.     if (pObj->CurrentValue != (U32)Value) {
  595.       pObj->CurrentValue = Value;
  596.       if (pObj->pfUpdateBufer) {
  597.         pObj->pfUpdateBufer(pObj);
  598.       }
  599.       WM_InvalidateWindow(hObj);
  600.       WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
  601.     }
  602.     WM_UNLOCK();
  603.   }
  604. }
  606. void EDIT_SetMaxLen(EDIT_Handle  hObj, int MaxLen) {
  607.   EDIT_Obj* pObj;
  608.   WM_HMEM hpText;
  609.   if (hObj) {
  610.     WM_LOCK();
  611.     pObj = EDIT_H2P(hObj);
  612.     if ((hpText = WM_ALLOC(MaxLen+1)) ==0) {
  613.       GUI_DEBUG_ERROROUT("EDIT_SetMaxLen failed to alloc buffer");
  614.     } else {
  615.       WM_FREEPTR(&pObj->hpText);
  616.       pObj->hpText = hpText;
  617.       pObj->MaxLen = MaxLen;
  618.     }
  619.     EDIT_Invalidate(hObj);
  620.     WM_UNLOCK();
  621.   }
  622. }
  624. void EDIT_SetTextAlign(EDIT_Handle hObj, int Align) {
  625.   EDIT_Obj* pObj;
  626.   if (hObj == 0)
  627.     return;
  628.   WM_LOCK();
  629.   pObj = EDIT_H2P(hObj);
  630.   if (pObj) {
  631.     pObj->Align = Align;
  632.     EDIT_Invalidate(hObj);
  633.   }
  634.   WM_UNLOCK();
  635. }
  637. void EDIT_SetDefaultFont(const GUI_FONT* pFont) {
  638.   _pDefaultFont = pFont;
  639. }
  641. const GUI_FONT* EDIT_GetDefaultFont(void) {
  642.   return _pDefaultFont;
  643. }
  645. void EDIT_SetDefaultTextAlign(int Align) {
  646.   WM_LOCK();
  647.   _DefaultAlign = Align;
  648.   WM_UNLOCK();
  649. }
  651. #else  /* avoid empty object files */
  653. void Edit_C(void) {}
  655. #endif