break;
  }
  WM_DefaultProc(pMsg);
}

/*********************************************************************
*
*       Exported routines:  Create
*
**********************************************************************
*/

EDIT_Handle EDIT_CreateAsChild     (int x0, int y0, int xsize, int ysize, WM_HWIN hParent, int Id, int Flags, int MaxLen) {
  EDIT_Handle hObj;
  if (MaxLen == 0) {
    MaxLen = 8;
  }
  /* Alloc memory for obj */
  WM_LOCK();
  hObj = WM_CreateWindowAsChild(x0, y0, xsize, ysize, hParent, 
                       WM_CF_SHOW | Flags, EDIT__Callback,
                       sizeof(EDIT_Obj)-sizeof(WM_Obj));
  if (hObj) {
    EDIT_Obj* pObj = (EDIT_Obj*)WM_HMEM2Ptr(hObj);
    /* init widget specific variables */
    WIDGET__Init(&pObj->Widget, WIDGET_STATE_FOCUSSABLE  | WIDGET_STATE_ENABLED);
    pObj->Widget.Id     = Id;
    /* init member variables */
    INIT_ID(pObj);
    pObj->pFont         = _pDefaultFont;
    pObj->aBkColor[0]   = EDIT_BKCOLOR0_DEFAULT;
    pObj->aBkColor[1]   = EDIT_BKCOLOR1_DEFAULT;
    pObj->aTextColor[0] = EDIT_TEXTCOLOR0_DEFAULT;
    pObj->aTextColor[1] = EDIT_TEXTCOLOR1_DEFAULT;
    pObj->Align         = _DefaultAlign;
    pObj->Border        = _DefaultBorder;
    pObj->XSizeCursor   = 1;
    pObj->MaxLen        = MaxLen;
    if ((pObj->hpText = WM_ALLOC(MaxLen+1)) ==0) {
      GUI_DEBUG_ERROROUT("EDIT_Create failed to alloc buffer");
      EDIT_Delete(hObj);
      hObj =0;
    }
  }
  WM_UNLOCK();
  return hObj;
}

EDIT_Handle EDIT_Create(int x0, int y0, int xsize, int ysize, int Id, int MaxLen, int Flags) {
  return EDIT_CreateAsChild(x0, y0, xsize, ysize, WM_HMEM_NULL, Id, Flags, MaxLen);
}

EDIT_Handle EDIT_CreateIndirect(const GUI_WIDGET_CREATE_INFO* pCreateInfo, WM_HWIN hWinParent, int x0, int y0, WM_CALLBACK* pCallback) {
  EDIT_Handle hEdit;
  GUI_USE_PARA(pCallback);
  hEdit = EDIT_CreateAsChild(
    pCreateInfo->x0 + x0, pCreateInfo->y0 + y0, pCreateInfo->xSize, pCreateInfo->ySize,
    hWinParent, pCreateInfo->Id, 0, pCreateInfo->Para);
  if (hEdit) {
    EDIT_SetTextAlign(hEdit, pCreateInfo->Flags);
  }
  return hEdit;
}

/*********************************************************************
*
*       Exported routines:  Various methods
*
**********************************************************************
*/

void EDIT_AddKey(EDIT_Handle hObj, int Key) {
  EDIT_Obj* pObj;
  if (hObj == 0)
    return;
  WM_LOCK();
  pObj = EDIT_H2P(hObj);
  if (pObj) {
    if (pObj->pfAddKeyEx) {
      pObj->pfAddKeyEx(pObj, hObj, Key);
    } else {
      char*s = (char*) WM_HMEM2Ptr(pObj->hpText);
      int len = strlen(s);
      switch (Key) {
        case GUI_KEY_UP:
          {
            char c = *(s + pObj->CursorPos);
            if (c < 0x7f) {
              *(s + pObj->CursorPos) = c + 1;
              WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
            }
          }
          break;
        case GUI_KEY_DOWN:
          {
            char c = *(s + pObj->CursorPos);
            if (c > 0x20) {
              *(s + pObj->CursorPos) = c - 1;
              WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
            }
          }
          break;
        case GUI_KEY_RIGHT:
          if (pObj->CursorPos < (pObj->MaxLen - 1))
            if (pObj->CursorPos < len)
              pObj->CursorPos++;
          break;
        case GUI_KEY_LEFT:
          if (pObj->CursorPos > 0)
            pObj->CursorPos--;
          break;
        case GUI_KEY_BACKSPACE:
          if ((len > 0) && (pObj->CursorPos > 0)) {
            int CopyLength = pObj->MaxLen - pObj->CursorPos;
            strncpy(s + pObj->CursorPos - 1, s + pObj->CursorPos, CopyLength);
            *(s + len - 1) = 0;
            WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
            pObj->CursorPos--;
          }
          break;
        case GUI_KEY_DELETE:
          if ((len > 0) && (pObj->CursorPos < len)) {
            if (len > 1) {
              int CopyLength = pObj->MaxLen - pObj->CursorPos - 1;
              strncpy(s + pObj->CursorPos, s + pObj->CursorPos + 1, CopyLength);
            }
            *(s + len - 1) = 0;
            WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
          }
          break;
        case GUI_KEY_INSERT:
          if (pObj->EditMode == GUI_EDIT_MODE_OVERWRITE)
            pObj->EditMode = GUI_EDIT_MODE_INSERT;
          else
            pObj->EditMode = GUI_EDIT_MODE_OVERWRITE;
          break;
        case GUI_KEY_ENTER:
        case GUI_KEY_ESCAPE:
          break;
        default:
          if ((Key >= 0x20) && (Key <= 0x7f)) {
            if (pObj->EditMode == GUI_EDIT_MODE_INSERT) {
              if (len < pObj->MaxLen) {
                int CopyLength = pObj->MaxLen - pObj->CursorPos - 1;
                memmove(s + pObj->CursorPos + 1, s + pObj->CursorPos, CopyLength);
                *(s + pObj->CursorPos) = Key;
                WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
                if (pObj->CursorPos < (pObj->MaxLen - 1))
                  pObj->CursorPos++;
              }
            } else {
              *(s + pObj->CursorPos) = Key;
              WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
              if (pObj->CursorPos < (pObj->MaxLen - 1))
                pObj->CursorPos++;
            }
          }
          break;
      }
    }
    EDIT_Invalidate(hObj);
  }
  WM_UNLOCK();
}

void EDIT_SetFont(EDIT_Handle hObj, const GUI_FONT* pfont) {
  EDIT_Obj* pObj;
  if (hObj == 0)
    return;
  WM_LOCK();
  pObj = EDIT_H2P(hObj);
  if (pObj) {
    pObj->pFont = pfont;
    EDIT_Invalidate(hObj);
  }
  WM_UNLOCK();
}

void EDIT_SetBkColor(EDIT_Handle hObj, int Index, GUI_COLOR color) {
  EDIT_Obj* pObj;
  if (hObj == 0)
    return;
  WM_LOCK();
  pObj = EDIT_H2P(hObj);
  if (pObj) {
    pObj->aBkColor[Index] = color;
    EDIT_Invalidate(hObj);
  }
  WM_UNLOCK();
}

void EDIT_SetTextColor(EDIT_Handle hObj, int Index, GUI_COLOR color) {
  EDIT_Obj* pObj;
  if (hObj == 0)
    return;
  WM_LOCK();
  pObj = EDIT_H2P(hObj);
  if (pObj) {
    pObj->aTextColor[Index] = color;
    EDIT_Invalidate(hObj);
  }
  WM_UNLOCK();
}

void EDIT_SetText     (EDIT_Handle hObj, const char* sNew) {
  EDIT_Obj* pObj;
  if (hObj == 0)
    return;
  WM_LOCK();
  pObj = EDIT_H2P(hObj);
  if (pObj) {
    char*sDest = (char*) WM_HMEM2Ptr(pObj->hpText);
    int Len = sNew ? strlen(sNew) : 0;
    if (Len > pObj->MaxLen)
      Len = pObj->MaxLen;
    memcpy(sDest, sNew, Len);
    *(sDest+Len) = 0;
    pObj->CursorPos = Len;
    if (pObj->CursorPos == pObj->MaxLen)
      pObj->CursorPos--;
    EDIT_Invalidate(hObj);
  }
  WM_UNLOCK();
}

void EDIT_GetText(EDIT_Handle hObj, char* sDest, int MaxLen) {
  EDIT_Obj* pObj;
  if (hObj == 0)
    return;
  WM_LOCK();
  pObj = EDIT_H2P(hObj);
  if (pObj) {
    char * sSource = (char*) WM_HMEM2Ptr(pObj->hpText);
    int Len = strlen(sSource);
    if (Len > (MaxLen - 1))
      Len = MaxLen - 1;
    memcpy((void *)sDest, (const void *)sSource, Len);
    *(sDest+Len) = 0;
  }
  WM_UNLOCK();
}

I32  EDIT_GetValue(EDIT_Handle hObj) {
  EDIT_Obj* pObj;
  I32 r = 0;
  if (hObj) {
    WM_LOCK();
    pObj = EDIT_H2P(hObj);
    r = pObj->CurrentValue;
    WM_UNLOCK();
  }
  return r;
}

void EDIT_SetValue(EDIT_Handle hObj, I32 Value) {
  EDIT_Obj* pObj;
  if (hObj) {
    WM_LOCK();
    pObj = EDIT_H2P(hObj);
    /* Put in min/max range */
    if (Value < pObj->Min) {
      Value = pObj->Min;
    }
    if (Value > pObj->Max) {
      Value = pObj->Max;
    }
    if (pObj->CurrentValue != (U32)Value) {
      pObj->CurrentValue = Value;
      if (pObj->pfUpdateBufer) {
        pObj->pfUpdateBufer(pObj);
      }
      WM_InvalidateWindow(hObj);
      WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
    }
    WM_UNLOCK();
  }
}

void EDIT_SetMaxLen(EDIT_Handle  hObj, int MaxLen) {
  EDIT_Obj* pObj;
  WM_HMEM hpText;
  if (hObj) {
    WM_LOCK();
    pObj = EDIT_H2P(hObj);
    if ((hpText = WM_ALLOC(MaxLen+1)) ==0) {
      GUI_DEBUG_ERROROUT("EDIT_SetMaxLen failed to alloc buffer");
    } else {
      WM_FREEPTR(&pObj->hpText);
      pObj->hpText = hpText;
      pObj->MaxLen = MaxLen;
    }
    EDIT_Invalidate(hObj);
    WM_UNLOCK();
  }
}

void EDIT_SetTextAlign(EDIT_Handle hObj, int Align) {
  EDIT_Obj* pObj;
  if (hObj == 0)
    return;
  WM_LOCK();
  pObj = EDIT_H2P(hObj);
  if (pObj) {
    pObj->Align = Align;
    EDIT_Invalidate(hObj);
  }
  WM_UNLOCK();
}

void EDIT_SetDefaultFont(const GUI_FONT* pFont) {
  _pDefaultFont = pFont;
}

const GUI_FONT* EDIT_GetDefaultFont(void) {
  return _pDefaultFont;
}

void EDIT_SetDefaultTextAlign(int Align) {
  WM_LOCK();
  _DefaultAlign = Align;
  WM_UNLOCK();
}

#else  /* avoid empty object files */

void Edit_C(void) {}

#endif