Initial import. Contains the im, cd and iup librairies, and a "working" Makefile for them under linux.

33 files changed, 14620 insertions, 0 deletions

diff --git a/iup/src/mot/iupmot_button.c b/iup/src/mot/iupmot_button.c
new file mode 100755
index 0000000..2d93588
--- /dev/null
+++ b/iup/src/mot/iupmot_button.c
@@ -0,0 +1,301 @@
+/** \file
+ * \brief Button Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/PushB.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_dialog.h"
+#include "iup_str.h"
+#include "iup_button.h"
+#include "iup_drv.h"
+#include "iup_image.h"
+#include "iup_key.h"
+
+#include "iupmot_drv.h"
+
+
+void iupdrvButtonAddBorders(int *x, int *y)
+{
+  int border_size = 2*5;
+  (*x) += border_size;
+  (*y) += border_size;
+}
+
+static int motButtonSetTitleAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_BUTTON_TEXT)
+  {
+    iupmotSetMnemonicTitle(ih, value);
+    return 1;
+  }
+
+  return 0;
+}
+
+static int motButtonSetAlignmentAttrib(Ihandle* ih, const char* value)
+{
+  unsigned char align;
+  char value1[30]="", value2[30]="";
+
+  iupStrToStrStr(value, value1, value2, ':');   /* value2 is ignored, NOT supported in Motif */
+
+  if (iupStrEqualNoCase(value1, "ARIGHT"))
+    align = XmALIGNMENT_END;
+  else if (iupStrEqualNoCase(value1, "ACENTER"))
+    align = XmALIGNMENT_CENTER;
+  else /* "ALEFT" */
+    align = XmALIGNMENT_BEGINNING;
+
+  XtVaSetValues (ih->handle, XmNalignment, align, NULL);
+  return 1;
+}
+
+static int motButtonSetImageAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_BUTTON_IMAGE)
+  {
+    iupmotSetPixmap(ih, value, XmNlabelPixmap, 0);
+
+    if (!iupAttribGet(ih, "IMINACTIVE"))
+    {
+      /* if not active and IMINACTIVE is not defined 
+         then automaticaly create one based on IMAGE */
+      iupmotSetPixmap(ih, value, XmNlabelInsensitivePixmap, 1); /* make_inactive */
+    }
+    return 1;
+  }
+  else
+    return 0;
+}
+
+static int motButtonSetImInactiveAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_BUTTON_IMAGE)
+  {
+    iupmotSetPixmap(ih, value, XmNlabelInsensitivePixmap, 0);
+    return 1;
+  }
+  else
+    return 0;
+}
+
+static int motButtonSetImPressAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_BUTTON_IMAGE)
+  {
+    iupmotSetPixmap(ih, value, XmNarmPixmap, 0);
+    return 1;
+  }
+  else
+    return 0;
+}
+
+static int motButtonSetPaddingAttrib(Ihandle* ih, const char* value)
+{
+  iupStrToIntInt(value, &ih->data->horiz_padding, &ih->data->vert_padding, 'x');
+  if (ih->handle)
+  {
+    XtVaSetValues(ih->handle, XmNmarginHeight, ih->data->vert_padding,
+                              XmNmarginWidth, ih->data->horiz_padding, NULL);
+  }
+  return 0;
+}
+
+static int motButtonSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  if (iupAttribGet(ih, "IMPRESS") || iupAttribGetBoolean(ih, "FLAT"))
+  {
+    /* ignore given value, must use only from parent */
+    value = iupBaseNativeParentGetBgColor(ih);
+
+    if (iupdrvBaseSetBgColorAttrib(ih, value))
+      return 1;
+  }
+
+  return iupdrvBaseSetBgColorAttrib(ih, value);
+}
+
+static int motButtonSetBackgroundAttrib(Ihandle* ih, const char* value)
+{
+  if (iupAttribGet(ih, "IMPRESS") || iupAttribGetBoolean(ih, "FLAT"))
+  {
+    /* ignore given value, must use only from parent */
+    value = iupAttribGetInheritNativeParent(ih, "BACKGROUND");
+
+    if (iupdrvBaseSetBgColorAttrib(ih, value))
+      return 1;
+    else
+    {
+      Pixmap pixmap = (Pixmap)iupImageGetImage(value, ih, 0);
+      if (pixmap)
+      {
+        XtVaSetValues(ih->handle, XmNbackgroundPixmap, pixmap, NULL);
+        return 1;
+      }
+    }
+  }
+  return 0; 
+}
+
+static void motButtonActivateCallback(Widget w, Ihandle* ih, XtPointer call_data)
+{
+  Icallback cb;
+
+  /* Must manually hide the tip if the button is pressed. */
+  iupmotTipLeaveNotify();
+
+  cb = IupGetCallback(ih, "ACTION");
+  if (cb)
+  {
+    if (cb(ih) == IUP_CLOSE) 
+      IupExitLoop();
+  }
+  (void)w;
+  (void)call_data;
+}
+
+static void motButtonEnterLeaveWindowEvent(Widget w, Ihandle* ih, XEvent *evt, Boolean *cont)
+{
+  iupmotEnterLeaveWindowEvent(w, ih, evt, cont);
+
+  if (evt->type == EnterNotify)
+    XtVaSetValues(ih->handle, XmNshadowThickness, 2, NULL);
+  else  if (evt->type == LeaveNotify)
+    XtVaSetValues(ih->handle, XmNshadowThickness, 0, NULL);
+}
+
+static int motButtonMapMethod(Ihandle* ih)
+{
+  char* value;
+  int num_args = 0;
+  Arg args[30];
+
+  value = iupAttribGet(ih, "IMAGE");
+  if (value)
+  {
+    ih->data->type = IUP_BUTTON_IMAGE;
+    iupmotSetArg(args, num_args, XmNlabelType, XmPIXMAP);
+  }
+  else
+  {
+    ih->data->type = IUP_BUTTON_TEXT;
+    iupmotSetArg(args, num_args, XmNlabelType, XmSTRING);
+  }
+
+  /* Core */
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+  /* Label */
+  iupmotSetArg(args, num_args, XmNrecomputeSize, False);  /* no automatic resize from text */
+  iupmotSetArg(args, num_args, XmNmarginHeight, 0);  /* default padding */
+  iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+  iupmotSetArg(args, num_args, XmNmarginTop, 0);     /* no extra margins */
+  iupmotSetArg(args, num_args, XmNmarginLeft, 0);
+  iupmotSetArg(args, num_args, XmNmarginBottom, 0);
+  iupmotSetArg(args, num_args, XmNmarginRight, 0);
+  /* PushButton */
+  iupmotSetArg(args, num_args, XmNfillOnArm, False);
+
+  /* Primitive */
+  if (iupAttribGetBoolean(ih, "FOCUSONCLICK"))
+  {
+    if (iupAttribGetBoolean(ih, "CANFOCUS"))
+      iupmotSetArg(args, num_args, XmNtraversalOn, True);
+    else
+      iupmotSetArg(args, num_args, XmNtraversalOn, False);
+  }
+  else
+    iupmotSetArg(args, num_args, XmNtraversalOn, False);
+  iupmotSetArg(args, num_args, XmNhighlightThickness, 2);
+  iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+  
+  ih->handle = XtCreateManagedWidget(
+    iupDialogGetChildIdStr(ih),  /* child identifier */
+    xmPushButtonWidgetClass,     /* widget class */
+    iupChildTreeGetNativeParentHandle(ih), /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  XtAddCallback(ih->handle, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+
+  value = iupAttribGet(ih, "IMPRESS");
+  if (iupAttribGetBoolean(ih, "FLAT") && !value)
+  {
+    XtVaSetValues(ih->handle, XmNshadowThickness, 0, NULL);
+    XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)motButtonEnterLeaveWindowEvent, (XtPointer)ih);
+    XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)motButtonEnterLeaveWindowEvent, (XtPointer)ih);
+  }
+  else
+  {
+    if (value && !iupAttribGetStr(ih, "IMPRESSBORDER"))
+      XtVaSetValues(ih->handle, XmNshadowThickness, 0, NULL);
+    else
+      XtVaSetValues(ih->handle, XmNshadowThickness, 2, NULL);
+    XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+    XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  }
+
+  XtAddEventHandler(ih->handle, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, KeyPressMask,    False, (XtEventHandler)iupmotKeyPressEvent,    (XtPointer)ih);
+
+  XtAddCallback(ih->handle, XmNactivateCallback, (XtCallbackProc)motButtonActivateCallback, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, ButtonPressMask|ButtonReleaseMask, False, (XtEventHandler)iupmotButtonPressReleaseEvent, (XtPointer)ih);
+
+  /* Disable Drag Source */
+  iupmotDisableDragSource(ih->handle);
+
+  /* initialize the widget */
+  XtRealizeWidget(ih->handle);
+
+  if (ih->data->type == IUP_BUTTON_TEXT)
+    iupmotSetString(ih->handle, XmNlabelString, "");
+
+  return IUP_NOERROR;
+}
+
+void iupdrvButtonInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motButtonMapMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", iupmotGetBgColorAttrib, motButtonSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "BACKGROUND", NULL, motButtonSetBackgroundAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, iupdrvBaseSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGFGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "TITLE", NULL, motButtonSetTitleAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+
+  /* IupButton only */
+  iupClassRegisterAttribute(ic, "ALIGNMENT", NULL, motButtonSetAlignmentAttrib, "ACENTER:ACENTER", NULL, IUPAF_NO_INHERIT);  /* force new default value */
+  iupClassRegisterAttribute(ic, "IMAGE", NULL, motButtonSetImageAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "IMINACTIVE", NULL, motButtonSetImInactiveAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "IMPRESS", NULL, motButtonSetImPressAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "FOCUSONCLICK", NULL, NULL, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NO_INHERIT);
+
+  iupClassRegisterAttribute(ic, "PADDING", iupButtonGetPaddingAttrib, motButtonSetPaddingAttrib, IUPAF_SAMEASSYSTEM, "0x0", IUPAF_NOT_MAPPED);
+}
diff --git a/iup/src/mot/iupmot_canvas.c b/iup/src/mot/iupmot_canvas.c
new file mode 100755
index 0000000..7777cf3
--- /dev/null
+++ b/iup/src/mot/iupmot_canvas.c
@@ -0,0 +1,639 @@
+/** \file
+ * \brief Canvas Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/ScrolledW.h>
+#include <Xm/DrawingA.h>
+#include <Xm/ScrollBar.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+#include <limits.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_dialog.h"
+#include "iup_str.h"
+#include "iup_drv.h"
+#include "iup_drvfont.h"
+#include "iup_canvas.h"
+#include "iup_key.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+
+static void motDialogScrollbarCallback(Widget w, XtPointer client_data, XtPointer call_data)
+{
+  int op = (int)client_data, ipage, ipos;
+  Ihandle *ih;
+  IFniff cb;
+  double posx, posy;
+  (void)call_data;
+
+  XtVaGetValues(w, XmNuserData, &ih, NULL);
+  if (!ih) return;
+
+  XtVaGetValues(w, 
+    XmNvalue, &ipos, 
+    XmNpageIncrement, &ipage,
+    NULL);
+
+  if (op > IUP_SBDRAGV)
+  {
+    iupCanvasCalcScrollRealPos(iupAttribGetFloat(ih,"XMIN"), iupAttribGetFloat(ih,"XMAX"), &posx, 
+                               IUP_SB_MIN, IUP_SB_MAX, ipage, &ipos);
+    ih->data->posx = (float)posx;
+    posy = ih->data->posy;
+  }
+  else
+  {
+    iupCanvasCalcScrollRealPos(iupAttribGetFloat(ih,"YMIN"), iupAttribGetFloat(ih,"YMAX"), &posy, 
+                               IUP_SB_MIN, IUP_SB_MAX, ipage, &ipos);
+    ih->data->posy = (float)posy;
+    posx = ih->data->posx;
+  }
+
+  cb = (IFniff)IupGetCallback(ih,"SCROLL_CB");
+  if (cb)
+    cb(ih, op, (float)posx, (float)posy);
+  else
+  {
+    IFnff cb = (IFnff)IupGetCallback(ih,"ACTION");
+    if (cb)
+      cb (ih, (float)posx, (float)posy);
+  }
+}
+
+static void motCanvasResizeCallback(Widget w, Ihandle *ih, XtPointer call_data)
+{
+  Dimension width, height;
+  IFnii cb;
+  (void)call_data;
+
+  if (!XtWindow(w) || !ih) return;
+
+  /* client size */
+  XtVaGetValues(w, XmNwidth, &width,
+                   XmNheight, &height,
+                   NULL);
+
+  cb = (IFnii)IupGetCallback(ih,"RESIZE_CB");
+  if (cb)
+    cb(ih,width,height);
+}
+
+static int motCanvasSetBgColorAttrib(Ihandle* ih, const char* value);
+
+static void motCanvasExposeCallback(Widget w, Ihandle *ih, XtPointer call_data)
+{
+  IFnff cb;
+  (void)call_data;
+
+  if (!XtWindow(w) || !ih) return;
+
+  cb = (IFnff)IupGetCallback(ih,"ACTION");
+  if (cb)
+  {
+    if (!iupAttribGet(ih, "_IUPMOT_NO_BGCOLOR"))
+      motCanvasSetBgColorAttrib(ih, iupAttribGetStr(ih, "BGCOLOR"));  /* reset to update window attributes */
+
+    cb (ih, ih->data->posx, ih->data->posy);
+  }
+}
+
+static void motCanvasInputCallback(Widget w, Ihandle *ih, XtPointer call_data)
+{
+  XEvent *evt = ((XmDrawingAreaCallbackStruct*)call_data)->event;
+
+  if (!XtWindow(w) || !ih) return;
+
+  switch (evt->type)
+  {
+  case ButtonPress:
+    /* Force focus on canvas click */
+    if (iupAttribGetBoolean(ih, "CANFOCUS"))
+      XmProcessTraversal(w, XmTRAVERSE_CURRENT);
+    /* break missing on purpose... */
+  case ButtonRelease:
+    {
+      XButtonEvent *but_evt = (XButtonEvent*)evt;
+      Boolean cont = True;
+      iupmotButtonPressReleaseEvent(w, ih, evt, &cont);
+      if (cont == False)
+        return;
+
+      if ((evt->type==ButtonPress) && (but_evt->button==Button4 || but_evt->button==Button5))
+      {                                             
+        IFnfiis wcb = (IFnfiis)IupGetCallback(ih, "WHEEL_CB");
+        if (wcb)
+        {
+          char status[IUPKEY_STATUS_SIZE] = IUPKEY_STATUS_INIT;
+          int delta = but_evt->button==Button4? 1: -1;
+          iupmotButtonKeySetStatus(but_evt->state, but_evt->button, status, 0);
+
+          wcb(ih, (float)delta, but_evt->x, but_evt->y, status);
+        }
+        else
+        {
+          IFniff scb = (IFniff)IupGetCallback(ih,"SCROLL_CB");
+          float posy = ih->data->posy;
+          int delta = but_evt->button==Button4? 1: -1;
+          int op = but_evt->button==Button4? IUP_SBUP: IUP_SBDN;
+          posy -= delta*iupAttribGetFloat(ih, "DY")/10.0f;
+          IupSetfAttribute(ih, "POSY", "%g", posy);
+          if (scb)
+            scb(ih,op,ih->data->posx,ih->data->posy);
+        }
+      }
+    }
+    break;
+  }
+}
+
+static void motCanvasSetScrollInfo(Widget sb, int imin, int imax, int ipos, int ipage, int iline)
+{
+  XtVaSetValues(sb,
+                XmNminimum,       imin,
+                XmNmaximum,       imax,
+                XmNvalue,         ipos,
+                XmNincrement,     iline,
+                XmNpageIncrement, ipage,
+                XmNsliderSize,    ipage,  /* to make the thumb proportional */
+                NULL);
+}
+
+static int motCanvasSetDXAttrib(Ihandle* ih, const char *value)
+{
+  if (ih->data->sb & IUP_SB_HORIZ)
+  {
+    double posx, xmin, xmax, linex;
+    float dx;
+    int iposx, ipagex, ilinex;
+    Widget sb_horiz, sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+    XtVaGetValues(sb_win, XmNhorizontalScrollBar, &sb_horiz, NULL);
+    if (!sb_horiz) return 1;
+
+    if (!iupStrToFloat(value, &dx))
+      return 1;
+
+    xmin = iupAttribGetFloat(ih, "XMIN");
+    xmax = iupAttribGetFloat(ih, "XMAX");
+    posx = ih->data->posx;
+
+    iupCanvasCalcScrollIntPos(xmin, xmax, dx, posx, 
+                              IUP_SB_MIN, IUP_SB_MAX, &ipagex, &iposx);
+
+    if (!iupAttribGet(ih,"LINEX"))
+    {
+      ilinex = ipagex/10;
+      if (!ilinex)
+        ilinex = 1;
+    }
+    else
+    {
+      /* line and page convertions are the same */
+      linex = iupAttribGetFloat(ih,"LINEX");
+      iupCanvasCalcScrollIntPos(xmin, xmax, linex, 0, 
+                                IUP_SB_MIN, IUP_SB_MAX, &ilinex,  NULL);
+    }
+
+    if (dx >= (xmax-xmin))
+    {
+      if (iupAttribGetBoolean(ih, "XAUTOHIDE"))
+        XtUnmanageChild(sb_horiz);
+      else
+        XtSetSensitive(sb_horiz, 0);
+      return 1;
+    }
+    else
+    {
+      if (!XtIsManaged(sb_horiz))
+        XtManageChild(sb_horiz);
+      XtSetSensitive(sb_horiz, 1);
+    }
+
+    motCanvasSetScrollInfo(sb_horiz, IUP_SB_MIN, IUP_SB_MAX, iposx, ipagex, ilinex);
+
+    /* update position because it could be corrected */
+    iupCanvasCalcScrollRealPos(xmin, xmax, &posx, 
+                               IUP_SB_MIN, IUP_SB_MAX, ipagex, &iposx);
+
+    ih->data->posx = (float)posx;
+  }
+  return 1;
+}
+
+static int motCanvasSetPosXAttrib(Ihandle* ih, const char *value)
+{
+  if (ih->data->sb & IUP_SB_HORIZ)
+  {
+    double xmin, xmax, dx;
+    float posx;
+    int iposx, ipagex;
+    Widget sb_horiz, sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+    XtVaGetValues(sb_win, XmNhorizontalScrollBar, &sb_horiz, NULL);
+    if (!sb_horiz) return 1;
+
+    if (!iupStrToFloat(value, &posx))
+      return 1;
+
+    xmin = iupAttribGetFloat(ih, "XMIN");
+    xmax = iupAttribGetFloat(ih, "XMAX");
+    dx = iupAttribGetFloat(ih, "DX");
+
+    if (posx < xmin) posx = (float)xmin;
+    if (posx > (xmax - dx)) posx = (float)(xmax - dx);
+    ih->data->posx = posx;
+
+    iupCanvasCalcScrollIntPos(xmin, xmax, dx, posx, 
+                              IUP_SB_MIN, IUP_SB_MAX, &ipagex, &iposx);
+
+    XtVaSetValues(sb_horiz, XmNvalue, iposx, NULL);
+  }
+  return 1;
+}
+
+static int motCanvasSetDYAttrib(Ihandle* ih, const char *value)
+{
+  if (ih->data->sb & IUP_SB_VERT)
+  {
+    double posy, ymin, ymax, liney;
+    float dy;
+    int iposy, ipagey, iliney;
+    Widget sb_vert, sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+    XtVaGetValues(sb_win, XmNverticalScrollBar, &sb_vert, NULL);
+    if (!sb_vert) return 1;
+
+    if (!iupStrToFloat(value, &dy))
+      return 1;
+
+    ymin = iupAttribGetFloat(ih, "YMIN");
+    ymax = iupAttribGetFloat(ih, "YMAX");
+    posy = ih->data->posy;
+
+    iupCanvasCalcScrollIntPos(ymin, ymax, dy, posy, 
+                              IUP_SB_MIN, IUP_SB_MAX, &ipagey, &iposy);
+
+    if (!iupAttribGet(ih,"LINEY"))
+    {
+      iliney = ipagey/10;
+      if (!iliney)
+        iliney = 1;
+    }
+    else
+    {
+      /* line and page convertions are the same */
+      liney = iupAttribGetFloat(ih,"LINEY");
+      iupCanvasCalcScrollIntPos(ymin, ymax, liney, 0, 
+                                IUP_SB_MIN, IUP_SB_MAX, &iliney,  NULL);
+    }
+
+    if (dy >= (ymax-ymin))
+    {
+      if (iupAttribGetBoolean(ih, "YAUTOHIDE"))
+        XtUnmanageChild(sb_vert);
+      else
+        XtSetSensitive(sb_vert, 0);
+      return 1;
+    }
+    else
+    {
+      if (!XtIsManaged(sb_vert))
+        XtManageChild(sb_vert);
+      XtSetSensitive(sb_vert, 1);
+    }
+
+    motCanvasSetScrollInfo(sb_vert, IUP_SB_MIN, IUP_SB_MAX, iposy, ipagey, iliney);
+
+    /* update position because it could be corrected */
+    iupCanvasCalcScrollRealPos(ymin, ymax, &posy, 
+                               IUP_SB_MIN, IUP_SB_MAX, ipagey, &iposy);
+
+    ih->data->posy = (float)posy;
+  }
+  return 1;
+}
+
+static int motCanvasSetPosYAttrib(Ihandle* ih, const char *value)
+{
+  if (ih->data->sb & IUP_SB_VERT)
+  {
+    double ymin, ymax, dy;
+    float posy;
+    int iposy, ipagey;
+    Widget sb_vert, sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+    XtVaGetValues(sb_win, XmNverticalScrollBar, &sb_vert, NULL);
+    if (!sb_vert) return 1;
+
+    if (!iupStrToFloat(value, &posy))
+      return 1;
+
+    ymin = iupAttribGetFloat(ih, "YMIN");
+    ymax = iupAttribGetFloat(ih, "YMAX");
+    dy = iupAttribGetFloat(ih, "DY");
+
+    if (posy < ymin) posy = (float)ymin;
+    if (posy > (ymax - dy)) posy = (float)(ymax - dy);
+    ih->data->posy = posy;
+
+    iupCanvasCalcScrollIntPos(ymin, ymax, dy, posy, 
+                              IUP_SB_MIN, IUP_SB_MAX, &ipagey, &iposy);
+
+    XtVaSetValues(sb_vert, XmNvalue, iposy, NULL);
+  }
+  return 1;
+}
+
+static char* motCanvasGetXDisplayAttrib(Ihandle *ih)
+{
+  (void)ih;
+  return (char*)iupmot_display;
+}
+
+static char* motCanvasGetXScreenAttrib(Ihandle *ih)
+{
+  (void)ih;
+  return (char*)iupmot_screen;
+}
+
+static char* motCanvasGetXWindowAttrib(Ihandle *ih)
+{
+  return (char*)XtWindow(ih->handle);
+}
+
+static char* motCanvasGetClientSizeAttrib(Ihandle *ih)
+{
+  char* str = iupStrGetMemory(20);
+ 
+  Dimension width, height;
+  XtVaGetValues(ih->handle, XmNwidth,  &width,
+                            XmNheight, &height, 
+                            NULL);
+
+  sprintf(str, "%dx%d", (int)width, (int)height);
+  return str;
+}
+
+static int motCanvasSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color;
+
+  /* ignore given value, must use only from parent for the scrollbars */
+  char* parent_value = iupBaseNativeParentGetBgColor(ih);
+
+  color = iupmotColorGetPixelStr(parent_value);
+  if (color != (Pixel)-1)
+  {
+    Widget sb;
+    Widget sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+
+    iupmotSetBgColor(sb_win, color);
+
+    XtVaGetValues(sb_win, XmNverticalScrollBar, &sb, NULL);
+    if (sb) iupmotSetBgColor(sb, color);
+
+    XtVaGetValues(sb_win, XmNhorizontalScrollBar, &sb, NULL);
+    if (sb) iupmotSetBgColor(sb, color);
+  }
+
+  if (!IupGetCallback(ih, "ACTION")) 
+    iupdrvBaseSetBgColorAttrib(ih, value);  /* Use the given value only here */
+  else
+  {
+    XSetWindowAttributes attrs;
+    attrs.background_pixmap = None;
+    XChangeWindowAttributes(iupmot_display, XtWindow(ih->handle), CWBackPixmap, &attrs);
+    iupAttribSetStr(ih, "_IUPMOT_NO_BGCOLOR", "1");
+  }
+
+  return 1;
+}
+
+static void motCanvasLayoutUpdateMethod(Ihandle *ih)
+{
+  Widget sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  Dimension border;
+
+  /* IMPORTANT:
+   The ScrolledWindow border, added by the Core, is NOT included in the Motif size.
+   So when setting the size, we must compensate the border, 
+   so the actual size will be the size we expect.
+  */
+
+  XtVaGetValues(sb_win, XmNborderWidth, &border, NULL);
+
+  XtVaSetValues(sb_win,
+    XmNx, (XtArgVal)ih->x,
+    XmNy, (XtArgVal)ih->y,
+    XmNwidth, (XtArgVal)(ih->currentwidth-2*border),
+    XmNheight, (XtArgVal)(ih->currentheight-2*border),
+    NULL);
+}
+
+static int motCanvasMapMethod(Ihandle* ih)
+{
+  Widget sb_win;
+  char *visual;
+  int num_args = 0;
+  Arg args[20];
+
+  if (!ih->parent)
+    return IUP_ERROR;
+
+  ih->data->sb = iupBaseGetScrollbar(ih);
+
+  /******************************/
+  /* Create the scrolled window */
+  /******************************/
+
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+  iupmotSetArg(args, num_args, XmNscrollingPolicy, XmAPPLICATION_DEFINED);
+  iupmotSetArg(args, num_args, XmNvisualPolicy, XmVARIABLE);
+  iupmotSetArg(args, num_args, XmNspacing, 0); /* no space between scrollbars and draw area */
+  iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+
+  if (iupAttribGetBoolean(ih, "BORDER"))
+  {
+    iupmotSetArg(args, num_args, XmNborderWidth, 1);
+    iupmotSetArg(args, num_args, XmNborderColor, iupmotColorGetPixelStr("0 0 0"));
+  }
+  else
+    iupmotSetArg(args, num_args, XmNborderWidth, 0);
+  
+  sb_win = XtCreateManagedWidget(
+    iupDialogGetChildIdStr(ih),  /* child identifier */
+    xmScrolledWindowWidgetClass,     /* widget class */
+    iupChildTreeGetNativeParentHandle(ih), /* widget parent */
+    args, num_args);
+
+  if (!sb_win)
+    return IUP_ERROR;
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  /****************************/
+  /* Create the drawing area  */
+  /****************************/
+
+  num_args = 0;
+  iupmotSetArg(args, num_args, XmNmarginHeight, 0);  /* no shadow margins */
+  iupmotSetArg(args, num_args, XmNmarginWidth, 0);  /* no shadow margins */
+  iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+  iupmotSetArg(args, num_args, XmNresizePolicy, XmRESIZE_NONE); /* no automatic resize of children */
+  if (ih->iclass->is_interactive)
+  {
+    iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP); /* include in navigation */
+
+    if (iupAttribGetBoolean(ih, "CANFOCUS"))
+      iupmotSetArg(args, num_args, XmNtraversalOn, True);
+    else
+      iupmotSetArg(args, num_args, XmNtraversalOn, False);
+  }
+  else
+  {
+    iupmotSetArg(args, num_args, XmNnavigationType, XmNONE);
+    iupmotSetArg(args, num_args, XmNtraversalOn, False);
+  }
+
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+
+  visual = IupGetAttribute(ih, "VISUAL");   /* defined by the OpenGL Canvas or NULL */
+  if (visual)
+  {
+    Colormap colormap = (Colormap)iupAttribGet(ih, "COLORMAP");
+    if (colormap)
+      iupmotSetArg(args, num_args, XmNcolormap,colormap);
+
+    iupmotDialogSetVisual(ih, visual);
+  }
+
+  ih->handle = XtCreateManagedWidget(
+    "draw_area",                 /* child identifier */
+    xmDrawingAreaWidgetClass,    /* widget class */
+    sb_win,                  /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+  {
+    XtDestroyWidget(sb_win);
+    return IUP_ERROR;
+  }
+
+  if (visual)
+    iupmotDialogResetVisual(ih);
+
+  iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)sb_win);
+  XtVaSetValues(sb_win, XmNworkWindow, ih->handle, NULL);
+
+  {
+    XSetWindowAttributes attrs;
+    attrs.bit_gravity = ForgetGravity; /* For the DrawingArea widget gets Expose events when you resize it to be smaller. */
+
+    if (iupAttribGetBoolean(ih, "BACKINGSTORE"))
+      attrs.backing_store = WhenMapped;
+    else
+      attrs.backing_store = NotUseful;
+
+    XChangeWindowAttributes(iupmot_display, XtWindow(ih->handle), CWBitGravity|CWBackingStore, &attrs);
+  }
+
+  if (ih->data->sb & IUP_SB_HORIZ)
+  {
+    Widget sb_horiz = XtVaCreateManagedWidget("sb_horiz",
+      xmScrollBarWidgetClass, sb_win,
+      XmNorientation, XmHORIZONTAL,
+      XmNsliderMark, XmTHUMB_MARK,
+      XmNuserData, ih,
+      NULL);
+
+    XtAddCallback(sb_horiz, XmNvalueChangedCallback, motDialogScrollbarCallback, (void*)IUP_SBPOSH);
+    XtAddCallback(sb_horiz, XmNdragCallback, motDialogScrollbarCallback, (void*)IUP_SBDRAGH);
+    XtAddCallback(sb_horiz, XmNdecrementCallback, motDialogScrollbarCallback, (void*)IUP_SBLEFT);
+    XtAddCallback(sb_horiz, XmNincrementCallback, motDialogScrollbarCallback, (void*)IUP_SBRIGHT);
+    XtAddCallback(sb_horiz, XmNpageDecrementCallback, motDialogScrollbarCallback, (void*)IUP_SBPGLEFT);
+    XtAddCallback(sb_horiz, XmNpageIncrementCallback, motDialogScrollbarCallback, (void*)IUP_SBPGRIGHT);
+
+    XtVaSetValues(sb_win, XmNhorizontalScrollBar, sb_horiz, NULL);
+  }
+
+  if (ih->data->sb & IUP_SB_VERT)
+  {
+    Widget sb_vert = XtVaCreateManagedWidget("sb_vert",
+      xmScrollBarWidgetClass, sb_win,
+      XmNorientation, XmVERTICAL,
+      XmNsliderMark, XmTHUMB_MARK,
+      XmNuserData, ih,
+      NULL);
+
+    XtAddCallback(sb_vert, XmNvalueChangedCallback, motDialogScrollbarCallback, (void*)IUP_SBPOSV);
+    XtAddCallback(sb_vert, XmNdragCallback, motDialogScrollbarCallback, (void*)IUP_SBDRAGV);
+    XtAddCallback(sb_vert, XmNdecrementCallback, motDialogScrollbarCallback, (void*)IUP_SBUP);
+    XtAddCallback(sb_vert, XmNincrementCallback, motDialogScrollbarCallback, (void*)IUP_SBDN);
+    XtAddCallback(sb_vert, XmNpageDecrementCallback, motDialogScrollbarCallback, (void*)IUP_SBPGUP);
+    XtAddCallback(sb_vert, XmNpageIncrementCallback, motDialogScrollbarCallback, (void*)IUP_SBPGDN);
+
+    XtVaSetValues(sb_win, XmNverticalScrollBar, sb_vert, NULL);
+  }
+
+  XtAddCallback(ih->handle, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNexposeCallback, (XtCallbackProc)motCanvasExposeCallback, (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNresizeCallback, (XtCallbackProc)motCanvasResizeCallback,  (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNinputCallback,  (XtCallbackProc)motCanvasInputCallback,   (XtPointer)ih);
+
+  XtAddEventHandler(ih->handle, EnterWindowMask, False,(XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, LeaveWindowMask, False,(XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+
+  XtAddEventHandler(ih->handle, FocusChangeMask, False,(XtEventHandler)iupmotFocusChangeEvent,        (XtPointer)ih);
+  XtAddEventHandler(ih->handle, KeyPressMask,    False, (XtEventHandler)iupmotKeyPressEvent,    (XtPointer)ih);
+  XtAddEventHandler(ih->handle, KeyReleaseMask,  False, (XtEventHandler)iupmotCanvasKeyReleaseEvent,  (XtPointer)ih);
+  XtAddEventHandler(ih->handle, PointerMotionMask, False, (XtEventHandler)iupmotPointerMotionEvent, (XtPointer)ih);
+
+  /* initialize the widget */
+  XtRealizeWidget(sb_win);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvCanvasInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motCanvasMapMethod;
+  ic->LayoutUpdate = motCanvasLayoutUpdateMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, motCanvasSetBgColorAttrib, "255 255 255", NULL, IUPAF_DEFAULT);  /* force new default value */
+  
+  /* IupCanvas only */
+  iupClassRegisterAttribute(ic, "DRAWSIZE", motCanvasGetClientSizeAttrib, NULL, NULL, NULL, IUPAF_READONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "CURSOR", NULL, iupdrvBaseSetCursorAttrib, IUPAF_SAMEASSYSTEM, "ARROW", IUPAF_NO_INHERIT);
+
+  iupClassRegisterAttribute(ic, "DX", NULL, motCanvasSetDXAttrib, "0.1", NULL, IUPAF_NO_INHERIT);  /* force new default value */
+  iupClassRegisterAttribute(ic, "DY", NULL, motCanvasSetDYAttrib, "0.1", NULL, IUPAF_NO_INHERIT);  /* force new default value */
+  iupClassRegisterAttribute(ic, "POSX", iupCanvasGetPosXAttrib, motCanvasSetPosXAttrib, "0.0", NULL, IUPAF_NO_INHERIT);  /* force new default value */
+  iupClassRegisterAttribute(ic, "POSY", iupCanvasGetPosYAttrib, motCanvasSetPosYAttrib, "0.0", NULL, IUPAF_NO_INHERIT);  /* force new default value */
+  iupClassRegisterAttribute(ic, "YAUTOHIDE", NULL, NULL, "YES", NULL, IUPAF_NOT_MAPPED);
+  iupClassRegisterAttribute(ic, "XAUTOHIDE", NULL, NULL, "YES", NULL, IUPAF_NOT_MAPPED);
+
+  /* IupCanvas X only */
+  iupClassRegisterAttribute(ic, "XWINDOW", motCanvasGetXWindowAttrib, NULL, NULL, NULL, IUPAF_NO_INHERIT|IUPAF_NO_STRING);
+  iupClassRegisterAttribute(ic, "XDISPLAY", motCanvasGetXDisplayAttrib, NULL, NULL, NULL, IUPAF_READONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT|IUPAF_NO_STRING);
+  iupClassRegisterAttribute(ic, "XSCREEN", motCanvasGetXScreenAttrib, NULL, NULL, NULL, IUPAF_READONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT|IUPAF_NO_STRING);
+  iupClassRegisterAttribute(ic, "BACKINGSTORE", NULL, NULL, "YES", NULL, IUPAF_NOT_MAPPED);
+}
diff --git a/iup/src/mot/iupmot_clipboard.c b/iup/src/mot/iupmot_clipboard.c
new file mode 100755
index 0000000..43a0087
--- /dev/null
+++ b/iup/src/mot/iupmot_clipboard.c
@@ -0,0 +1,208 @@
+/** \file
+ * \brief Clipboard for the Motif Driver.
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <Xm/Xm.h>
+#include <Xm/CutPaste.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_image.h"
+
+#include "iupmot_drv.h"
+
+
+static Window motClipboardGetWindow(void)
+{
+  Ihandle* focus = IupGetFocus();
+  Ihandle* dlg;
+  if (!focus) return (Window)NULL;
+  dlg = IupGetDialog(focus);
+  if (dlg)
+    return XtWindow(dlg->handle);
+  else
+    return (Window)NULL;
+}
+
+static int motClipboardSetTextAttrib(Ihandle *ih, const char *value)
+{
+  long item_id = 0;
+  Window window = motClipboardGetWindow();
+  XmString clip_label = XmStringCreateLocalized ("IupClipboard");
+  (void)ih;
+
+  if (XmClipboardStartCopy(iupmot_display, window, clip_label, CurrentTime, NULL, NULL, &item_id)!=ClipboardSuccess)
+  {
+    XmStringFree(clip_label);
+    return 0;
+  }
+
+  XmStringFree(clip_label);
+
+  XmClipboardCopy(iupmot_display, window, item_id, "STRING", (char*)value, (long)strlen(value)+1, 0, NULL);
+  XmClipboardEndCopy(iupmot_display, window, item_id);
+  return 0;
+}
+
+static char* motClipboardGetTextAttrib(Ihandle *ih)
+{
+  unsigned long size;
+  char* str;
+  Window window = motClipboardGetWindow();
+  (void)ih;
+  
+  if (XmClipboardInquireLength(iupmot_display, window, "STRING", &size)!=ClipboardSuccess)
+    return NULL;
+
+  str = iupStrGetMemory(size+1);
+
+  if (XmClipboardRetrieve(iupmot_display, window, "STRING", str, size+1, NULL, NULL)!=ClipboardSuccess)
+    return NULL;
+
+  return str;
+}
+
+static int motClipboardSetImageAttrib(Ihandle *ih, const char *value)
+{
+  Pixmap pixmap;
+  long item_id = 0;
+  Window window = motClipboardGetWindow();
+  XmString clip_label = XmStringCreateLocalized ("IupClipboard");
+
+  if (XmClipboardStartCopy(iupmot_display, window, clip_label, CurrentTime, NULL, NULL, &item_id)!=ClipboardSuccess)
+  {
+    XmStringFree(clip_label);
+    return 0;
+  }
+
+  XmStringFree(clip_label);
+
+  pixmap = (Pixmap)iupImageGetImage(value, ih, 0);
+
+  XmClipboardCopy(iupmot_display, window, item_id, "PIXMAP", (char*)&pixmap, sizeof(Pixmap), 0, NULL);
+  XmClipboardEndCopy(iupmot_display, window, item_id);
+
+  (void)ih;
+  return 0;
+}
+
+static int motClipboardSetNativeImageAttrib(Ihandle *ih, const char *value)
+{
+  long item_id = 0;
+  Window window = motClipboardGetWindow();
+  XmString clip_label = XmStringCreateLocalized ("IupClipboard");
+  Pixmap pixmap = (Pixmap)value;
+
+  if (XmClipboardStartCopy(iupmot_display, window, clip_label, CurrentTime, NULL, NULL, &item_id)!=ClipboardSuccess)
+  {
+    XmStringFree(clip_label);
+    return 0;
+  }
+
+  XmStringFree(clip_label);
+
+  XmClipboardCopy(iupmot_display, window, item_id, "PIXMAP", (char*)&pixmap, sizeof(Pixmap), 0, NULL);
+  XmClipboardEndCopy(iupmot_display, window, item_id);
+
+  (void)ih;
+  return 0;
+}
+
+static char* motClipboardGetNativeImageAttrib(Ihandle *ih)
+{
+  unsigned long size;
+  void* data;
+  Pixmap pixmap;
+  Window window = motClipboardGetWindow();
+  (void)ih;
+  
+  if (XmClipboardInquireLength(iupmot_display, window, "PIXMAP", &size)!=ClipboardSuccess)
+    return NULL;
+
+  data = XtMalloc(size);
+
+  if (XmClipboardRetrieve(iupmot_display, window, "PIXMAP", data, size, NULL, NULL)!=ClipboardSuccess)
+    return NULL;
+
+  pixmap = *((Pixmap*)data);
+  XtFree(data);
+  return (char*)pixmap;
+}
+
+static int motClipboardIsAvailable(const char* format_name)
+{
+  Window window = motClipboardGetWindow();
+  int count, i;
+  unsigned long max_length, length;
+  char* str;
+
+	if (XmClipboardInquireCount(iupmot_display, window, &count, &max_length) != ClipboardSuccess)
+    return 0;
+
+  str = iupStrGetMemory(max_length+1);
+	
+  for (i = 1; i<=count; i++)
+  {
+  	if (XmClipboardInquireFormat(iupmot_display, window, i, str, max_length+1, &length)==ClipboardSuccess)
+    {
+      if (iupStrEqualNoCase(str, format_name))
+        return 1;
+    }
+  }
+	
+  return 0;
+}
+
+static char* motClipboardGetTextAvailableAttrib(Ihandle *ih)
+{
+  (void)ih;
+  if (motClipboardIsAvailable("STRING"))
+    return "YES";
+  else
+    return "NO";
+}
+
+static char* motClipboardGetImageAvailableAttrib(Ihandle *ih)
+{
+  (void)ih;
+  if (motClipboardIsAvailable("PIXMAP"))
+    return "YES";
+  else
+    return "NO";
+}
+
+/******************************************************************************/
+
+Ihandle* IupClipboard(void)
+{
+  return IupCreate("clipboard");
+}
+
+Iclass* iupClipboardGetClass(void)
+{
+  Iclass* ic = iupClassNew(NULL);
+
+  ic->name = "clipboard";
+  ic->format = NULL;  /* no parameters */
+  ic->nativetype = IUP_TYPECONTROL;
+  ic->childtype = IUP_CHILDNONE;
+  ic->is_interactive = 0;
+
+  /* Attribute functions */
+  iupClassRegisterAttribute(ic, "TEXT", motClipboardGetTextAttrib, motClipboardSetTextAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "NATIVEIMAGE", motClipboardGetNativeImageAttrib, motClipboardSetNativeImageAttrib, NULL, NULL, IUPAF_NO_STRING|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "IMAGE", NULL, motClipboardSetImageAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "TEXTAVAILABLE", motClipboardGetTextAvailableAttrib, NULL, NULL, NULL, IUPAF_READONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "IMAGEAVAILABLE", motClipboardGetImageAvailableAttrib, NULL, NULL, NULL, IUPAF_READONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
+
+  return ic;
+}
diff --git a/iup/src/mot/iupmot_color.c b/iup/src/mot/iupmot_color.c
new file mode 100755
index 0000000..276bccc
--- /dev/null
+++ b/iup/src/mot/iupmot_color.c
@@ -0,0 +1,380 @@
+/** \file
+ * \brief Motif Driver color management
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#include <Xm/Xm.h>
+#include <X11/Xproto.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h" 
+#include "iup_str.h" 
+#include "iup_drvinfo.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+
+/* local variables */
+
+typedef struct _Icolor
+{
+  Colormap colormap;         /* colormap for all canvas, dialogs and menus */
+  XColor color_table[256];   /* colormap colors */
+  int num_colors;            /* number of colors in colormap  */
+
+  int rshift;                /* red shift for truecolor */
+  int gshift;                /* green shift for truecolor */
+  int bshift;                /* blue shift for truecolor */
+
+  int direct_conv[256];      /* used with directColor visuals */
+} Icolor;
+
+static Icolor mot_color;
+
+
+/*******************************************
+              NOT  TrueColor Functions
+*******************************************/
+
+static int motColor8BppErrorHandler(Display* dpy, XErrorEvent *err)
+{
+  char msg[80];
+
+  /* BadAcess in XFreeColors is OK */
+  if (err->request_code==X_FreeColors && err->error_code==BadAccess)
+    return 0;
+
+  XGetErrorText(dpy, err->error_code, msg, 80 );
+  fprintf(stderr,"IUP Motif error handler: Xlib request %d: %s\n", err->request_code, msg);
+
+  return 0;
+}
+
+static unsigned long motColorNearestRGB(XColor* xc1)
+{
+  static int nearest_try = 0;
+
+  int pos = 0, i;
+  unsigned long min_dist = ULONG_MAX, this_dist;
+  int dr, dg, db;
+  XColor* xc2;
+
+  for (i=0; i<mot_color.num_colors; i++)
+  {
+    xc2 = &(mot_color.color_table[i]);
+
+    dr = (xc1->red   - xc2->red) / 850;       /* 0.30 / 255 */
+    dg = (xc1->green - xc2->green) / 432;     /* 0.59 / 255 */
+    db = (xc1->blue  - xc2->blue) /  2318;    /* 0.11 / 255 */
+
+    this_dist = dr*dr + dg*dg + db*db;
+
+    if (this_dist < min_dist)
+    {
+      min_dist = this_dist;            
+      pos = i;                          
+    }
+  }
+
+  /* verifico se a cor ainda esta alocada */
+  /* Try to allocate the closest match color.  This should only
+     fail if the cell is read/write.  Otherwise, we're incrementing
+     the cell's reference count. (comentario extraido da biblioteca Mesa) */
+  if (!XAllocColor(iupmot_display, mot_color.colormap,
+                   &(mot_color.color_table[pos])))
+  {
+    /* nao esta, preciso atualizar a tabela e procurar novamente */
+    /* isto acontece porque a cor encontrada pode ter sido de uma aplicacao que nao existe mais */
+    /* uma vez atualizada, o problema nao ocorrera' na nova procura */
+    /* ou a celula e' read write */
+
+    if (nearest_try == 1)
+    {
+      nearest_try = 0;
+      return mot_color.color_table[pos].pixel;
+    }
+
+    XQueryColors(iupmot_display, mot_color.colormap, mot_color.color_table, mot_color.num_colors);
+
+    nearest_try = 1; /* garante que so' vai tentar isso uma vez */
+    return motColorNearestRGB(xc1);
+  }
+
+  return mot_color.color_table[pos].pixel;
+}
+
+static unsigned long motColorGetPixel_NotTrueColor(unsigned char cr, unsigned char cg, unsigned char cb)
+{
+  unsigned long pixel;
+  XColor xc;
+  xc.red = iupCOLOR8TO16(cr);
+  xc.green = iupCOLOR8TO16(cg);
+  xc.blue = iupCOLOR8TO16(cb);
+  xc.flags = DoRed | DoGreen | DoBlue;
+
+  /* verificamos se a nova cor ja' esta' disponivel */
+  if (!XAllocColor(iupmot_display, mot_color.colormap, &xc))
+  {
+    /* nao estava disponivel, procuro pela mais proxima na tabela de cores */
+    pixel = motColorNearestRGB(&xc); 
+  }
+  else
+  {
+    /* ja' estava disponivel */
+    /* atualizo a tabela de cores */
+    mot_color.color_table[xc.pixel] = xc;
+    pixel = xc.pixel;
+  }
+
+  return pixel;
+}
+
+static void motColorGetRGB_NotTrueColor(unsigned long pixel, unsigned char* red, unsigned char* green, unsigned char* blue)
+{
+  XColor xc;
+  xc.pixel = pixel;
+  XQueryColor(iupmot_display, mot_color.colormap, &xc);
+  *red = (unsigned char)xc.red;
+  *green = (unsigned char)xc.green;
+  *blue = (unsigned char)xc.blue;
+}
+
+static void motColorReserveColors(void)
+{
+  unsigned char r, g, b;
+  unsigned long background, foreground, shadow, highlight, selection;
+  XtVaGetValues(iupmot_appshell, XmNbackground, &background, NULL);
+  XmGetColors(DefaultScreenOfDisplay(iupmot_display), mot_color.colormap,
+              background, &foreground, &highlight, &shadow, &selection);
+  motColorGetRGB_NotTrueColor(background, &r, &g, &b);
+  motColorGetPixel_NotTrueColor(r, g, b);
+  motColorGetRGB_NotTrueColor(foreground, &r, &g, &b);
+  motColorGetPixel_NotTrueColor(r, g, b);
+  motColorGetRGB_NotTrueColor(shadow, &r, &g, &b);
+  motColorGetPixel_NotTrueColor(r, g, b);
+  motColorGetRGB_NotTrueColor(highlight, &r, &g, &b);
+  motColorGetPixel_NotTrueColor(r, g, b);
+  motColorGetRGB_NotTrueColor(selection, &r, &g, &b);
+  motColorGetPixel_NotTrueColor(r, g, b);
+}
+
+
+/*******************************************
+              TrueColor Functions
+*******************************************/
+
+
+static void motColorGetRGB_TrueColor(unsigned long pixel, unsigned char* red, unsigned char* green, unsigned char* blue)
+{
+  unsigned long r = pixel & iupmot_visual->red_mask;
+  unsigned long g = pixel & iupmot_visual->green_mask;
+  unsigned long b = pixel & iupmot_visual->blue_mask;
+  if (mot_color.rshift<0) r = r >> (-mot_color.rshift);
+  else r = r << mot_color.rshift;
+  if (mot_color.gshift<0) g = g >> (-mot_color.gshift);
+  else g = g << mot_color.gshift;
+  if (mot_color.bshift<0) b = b >> (-mot_color.bshift);
+  else b = b << mot_color.bshift;
+  *red = iupCOLOR16TO8(r);
+  *green = iupCOLOR16TO8(g);
+  *blue = iupCOLOR16TO8(b);
+}
+
+static unsigned long motColorGetPixel_TrueColor(unsigned char cr, unsigned char cg, unsigned char cb)
+{
+  unsigned long r = iupCOLOR8TO16(cr);
+  unsigned long g = iupCOLOR8TO16(cg);
+  unsigned long b = iupCOLOR8TO16(cb);
+
+  if (mot_color.rshift<0) 
+    r = r << (-mot_color.rshift);
+  else 
+    r = r >> mot_color.rshift;
+
+  if (mot_color.gshift<0) 
+    g = g << (-mot_color.gshift);
+  else 
+    g = g >> mot_color.gshift;
+
+  if (mot_color.bshift<0) 
+    b = b << (-mot_color.bshift);
+  else 
+    b = b >> mot_color.bshift;
+
+  r = r & iupmot_visual->red_mask;
+  g = g & iupmot_visual->green_mask;
+  b = b & iupmot_visual->blue_mask;
+
+  return r | g | b;
+}
+
+static int motColorHighBit(unsigned long ul)
+{
+/* returns position of highest set bit in 'ul' as an integer (0-31),
+  or -1 if none */
+  int i;  unsigned long hb;
+
+  hb = 0x80;  hb = hb << 24;   /* hb = 0x80000000UL */
+  for (i=31; ((ul & hb) == 0) && i>=0;  i--, ul<<=1);
+  return i;
+}
+
+static void motColorMakeDirectCmap(Colormap cmap)
+{
+  int    i, cmaplen, numgot;
+  unsigned char   origgot[256];
+  XColor c;
+  unsigned long rmask, gmask, bmask;
+  int    rshift, gshift, bshift;
+
+  rmask = iupmot_visual->red_mask;
+  gmask = iupmot_visual->green_mask;
+  bmask = iupmot_visual->blue_mask;
+
+  rshift = motColorHighBit(rmask) - 15;
+  gshift = motColorHighBit(gmask) - 15;
+  bshift = motColorHighBit(bmask) - 15;
+
+  if (rshift<0) rmask = rmask << (-rshift);
+  else rmask = rmask >> rshift;
+
+  if (gshift<0) gmask = gmask << (-gshift);
+  else gmask = gmask >> gshift;
+
+  if (bshift<0) bmask = bmask << (-bshift);
+  else bmask = bmask >> bshift;
+
+  cmaplen = iupmot_visual->map_entries;
+  if (cmaplen>256) cmaplen=256;
+
+  /* try to alloc a 'cmaplen' long grayscale colormap.  May not get all
+  entries for whatever reason.  Build table 'mot_color.direct_conv[]' that
+  maps range [0..(cmaplen-1)] into set of colors we did get */
+
+  for (i=0; i<256; i++) {  origgot[i] = 0;  mot_color.direct_conv[i] = i; }
+
+  for (i=numgot=0; i<cmaplen; i++) 
+  {
+    c.red = c.green = c.blue = (unsigned short)((i * 0xffff) / (cmaplen - 1));
+    c.red   = (unsigned short)(c.red   & rmask);
+    c.green = (unsigned short)(c.green & gmask);
+    c.blue  = (unsigned short)(c.blue  & bmask);
+    c.flags = DoRed | DoGreen | DoBlue;
+
+    if (XAllocColor(iupmot_display, cmap, &c)) 
+    {
+      origgot[i] = 1;
+      numgot++;
+    }
+  }
+
+  if (numgot == 0) 
+    return;
+
+  /* mot_color.direct_conv may or may not have holes in it. */
+  for (i=0; i<cmaplen; i++) 
+  {
+    if (!origgot[i]) 
+    {
+      int numbak, numfwd;
+      numbak = numfwd = 0;
+      while ((i - numbak) >= 0       && !origgot[i-numbak]) numbak++;
+      while ((i + numfwd) <  cmaplen && !origgot[i+numfwd]) numfwd++;
+
+      if (i-numbak<0        || !origgot[i-numbak]) numbak = 999;
+      if (i+numfwd>=cmaplen || !origgot[i+numfwd]) numfwd = 999;
+
+      if      (numbak<numfwd) mot_color.direct_conv[i] = mot_color.direct_conv[i-numbak];
+      else if (numfwd<999)    mot_color.direct_conv[i] = mot_color.direct_conv[i+numfwd];
+    }
+  }
+}
+
+
+/*******************************************
+              Exported Functions
+*******************************************/
+
+unsigned long (* iupmotColorGetPixel)(unsigned char r, unsigned char g, unsigned char b) = 0; 
+void (* iupmotColorGetRGB)(unsigned long pixel, unsigned char* red, unsigned char* green, unsigned char* blue) = 0;
+
+void iupmotColorInit(void)
+{
+  int depth = iupdrvGetScreenDepth();
+
+  if (depth > 8)
+  {
+    iupmotColorGetRGB = motColorGetRGB_TrueColor;
+    iupmotColorGetPixel = motColorGetPixel_TrueColor;
+
+     /* make linear colormap for DirectColor visual */
+    if (iupmot_visual->class == DirectColor)
+      motColorMakeDirectCmap(DefaultColormap(iupmot_display, iupmot_screen));
+
+    mot_color.rshift = 15 - motColorHighBit(iupmot_visual->red_mask);
+    mot_color.gshift = 15 - motColorHighBit(iupmot_visual->green_mask);
+    mot_color.bshift = 15 - motColorHighBit(iupmot_visual->blue_mask);
+
+    mot_color.num_colors = 0;
+    mot_color.colormap = 0;
+  }
+  else
+  {
+    int i;
+    iupmotColorGetRGB = motColorGetRGB_NotTrueColor;
+    iupmotColorGetPixel = motColorGetPixel_NotTrueColor;
+
+    mot_color.colormap = DefaultColormap(iupmot_display, iupmot_screen);
+    mot_color.num_colors = 1L << depth;
+
+    for (i=0; i<mot_color.num_colors; i++)
+      mot_color.color_table[i].pixel = i;
+
+    XQueryColors(iupmot_display, mot_color.colormap, mot_color.color_table, mot_color.num_colors);
+    XSetErrorHandler(motColor8BppErrorHandler);
+
+    motColorReserveColors();
+  }
+}
+
+void iupmotColorFinish(void)
+{
+  if (mot_color.colormap)
+  {
+    unsigned long pixels[256];
+    int i;
+
+    /* release colors */
+    for (i = 0; i < mot_color.num_colors; i++)
+      pixels[i] = mot_color.color_table[i].pixel;
+
+    XFreeColors(iupmot_display, mot_color.colormap, pixels, mot_color.num_colors, 0);
+
+    /* release palette */
+    if (mot_color.colormap != DefaultColormap(iupmot_display, iupmot_screen))
+      XFreeColormap(iupmot_display, mot_color.colormap);
+  }
+}
+
+Colormap iupmotColorMap(void)
+{
+  return mot_color.colormap;
+}
+
+unsigned long iupmotColorGetPixelStr(const char* color)
+{
+  unsigned char r, g, b;
+  if (!iupStrToRGB(color, &r, &g, &b))
+    return (unsigned long)-1;
+
+  return iupmotColorGetPixel(r, g, b);
+}
diff --git a/iup/src/mot/iupmot_color.h b/iup/src/mot/iupmot_color.h
new file mode 100755
index 0000000..a306fd3
--- /dev/null
+++ b/iup/src/mot/iupmot_color.h
@@ -0,0 +1,36 @@
+/** \file
+ * \brief Motif Color Management
+ *
+ * See Copyright Notice in "iup.h"
+ */
+ 
+#ifndef __IUPMOT_COLOR_H 
+#define __IUPMOT_COLOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Returns a pixel value from a RGB triple. */
+extern unsigned long (* iupmotColorGetPixel)(unsigned char r, unsigned char g, unsigned char b);
+
+/* Returns a RGB triple from a pixel value. */
+extern void (* iupmotColorGetRGB)(unsigned long pixel, unsigned char *r, unsigned char *g, unsigned char *b);
+
+/* initialize the toplevel colormap and the iupmotColorGet* functions */
+void iupmotColorInit(void);
+void iupmotColorFinish(void);
+
+/* returns the toplevel colormap */
+Colormap iupmotColorMap(void);
+
+/* Returns a pixel value from a IUP color description. */
+unsigned long iupmotColorGetPixelStr(const char* color);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/iup/src/mot/iupmot_colordlg.c b/iup/src/mot/iupmot_colordlg.c
new file mode 100755
index 0000000..7a949bf
--- /dev/null
+++ b/iup/src/mot/iupmot_colordlg.c
@@ -0,0 +1,31 @@
+/** \file
+ * \brief IupColorDlg pre-defined dialog
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_drvinfo.h"
+#include "iup_dialog.h"
+
+#include "iupmot_drv.h"
+
+
+static int motColorDlgPopup(Ihandle* ih, int x, int y)
+{
+  (void)ih;
+  (void)x;
+  (void)y;
+  return IUP_ERROR;
+}
+
+void iupdrvColorDlgInitClass(Iclass* ic)
+{
+  ic->DlgPopup = motColorDlgPopup;
+}
diff --git a/iup/src/mot/iupmot_common.c b/iup/src/mot/iupmot_common.c
new file mode 100755
index 0000000..7b3f8b7
--- /dev/null
+++ b/iup/src/mot/iupmot_common.c
@@ -0,0 +1,630 @@
+/** \file
+ * \brief Motif Base Functions
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <Xm/Xm.h>
+#include <Xm/ScrollBar.h>
+#include <X11/cursorfont.h>
+
+#include "iup.h"
+#include "iupkey.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_key.h"
+#include "iup_str.h"
+#include "iup_class.h"
+#include "iup_attrib.h"
+#include "iup_focus.h"
+#include "iup_key.h"
+#include "iup_drv.h"
+#include "iup_image.h"
+#include "iup_drv.h"
+
+#include "iupmot_color.h"
+#include "iupmot_drv.h"
+
+
+
+void iupdrvActivate(Ihandle* ih)
+{
+  if (iupStrEqual(ih->iclass->name, "text") || iupStrEqual(ih->iclass->name, "multiline"))
+    XmProcessTraversal(ih->handle, XmTRAVERSE_CURRENT);
+  else
+    XtCallActionProc(ih->handle, "ArmAndActivate", 0, 0, 0 );
+}
+
+static int motActivateMnemonic(Ihandle *dialog, int c)
+{
+  Ihandle *ih;
+  char attrib[19] = "_IUPMOT_MNEMONIC_ ";
+  attrib[17] = (char)c;
+  ih = (Ihandle*)iupAttribGet(dialog, attrib);
+  if (iupObjectCheck(ih))
+  {
+    iupdrvActivate(ih);
+    return IUP_IGNORE;
+  }
+  return IUP_CONTINUE;
+}
+
+void iupmotSetMnemonicTitle(Ihandle *ih, const char* value)
+{
+  char c;
+  char* str;
+
+  if (!value) 
+    value = "";
+
+  str = iupStrProcessMnemonic(value, &c, -1);  /* remove & and return in c */
+  if (str != value)
+  {
+    KeySym keysym = iupmotKeyCharToKeySym(c);
+    XtVaSetValues(ih->handle, XmNmnemonic, keysym, NULL);   /* works only for menus, but underlines the letter */
+
+    if (ih->iclass->nativetype != IUP_TYPEMENU)
+    {
+      Ihandle* dialog = IupGetDialog(ih);
+      char attrib[22] = "_IUPMOT_MNEMONIC_ \0CB";
+      attrib[17] = (char)toupper(c);
+
+      /* used by motActivateMnemonic */
+      if (iupStrEqual(ih->iclass->name, "label"))
+        iupAttribSetStr(dialog, attrib, (char*)iupFocusNextInteractive(ih));
+      else
+        iupAttribSetStr(dialog, attrib, (char*)ih);
+
+      /* used by iupmotKeyPressEvent */
+      attrib[18] = '_';
+      IupSetCallback(dialog, attrib, (Icallback)motActivateMnemonic);
+    }
+
+    iupmotSetString(ih->handle, XmNlabelString, str);
+    free(str);
+  }
+  else
+  {
+    XtVaSetValues (ih->handle, XmNmnemonic, NULL, NULL);
+    iupmotSetString(ih->handle, XmNlabelString, str);
+  }
+}
+
+void iupmotSetString(Widget w, const char *resource, const char* value)
+{
+  XmString xm_str = XmStringCreateLocalized((String)value);
+  XtVaSetValues(w, resource, xm_str, NULL);
+  XmStringFree(xm_str);
+}
+
+char* iupmotConvertString(XmString str)
+{
+  char* text = (char*)XmStringUnparse(str, NULL, XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0, XmOUTPUT_ALL);
+  char* buf = iupStrGetMemoryCopy(text);
+  XtFree(text);
+  return buf;
+}
+
+#ifdef OLD_CONVERT
+char* iupmotConvertString(XmString str)
+{
+  XmStringContext context;
+  char *text, *p, *buf;
+  unsigned int length;
+  XmStringComponentType type;
+
+  if (!XmStringInitContext (&context, str))
+    return NULL;
+
+  buf = iupStrGetMemory(XmStringLength(str));  /* always greatter than strlen */
+
+  /* p keeps a running pointer through buf as text is read */
+  p = buf;
+  while ((type = XmStringGetNextTriple(context, &length, (XtPointer)&text)) != XmSTRING_COMPONENT_END) 
+  {
+    switch (type) 
+    {
+    case XmSTRING_COMPONENT_TEXT:
+      memcpy(p, text, length);
+      p += length;
+      *p = 0;
+      break;
+    case XmSTRING_COMPONENT_TAB:
+      *p++ = '\t';
+      *p = 0;
+      break;
+    case XmSTRING_COMPONENT_SEPARATOR:
+      *p++ = '\n';
+      *p = 0;
+      break;
+    }
+    XtFree(text);
+  }
+
+  XmStringFreeContext(context);
+
+  return buf;
+}
+#endif
+
+void iupdrvReparent(Ihandle* ih)
+{
+  Widget native_parent = iupChildTreeGetNativeParentHandle(ih);
+  Widget widget = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (!widget) widget = ih->handle;
+  XReparentWindow(iupmot_display, XtWindow(widget), XtWindow(native_parent), 0, 0);
+}
+
+void iupdrvBaseLayoutUpdateMethod(Ihandle *ih)
+{
+  Widget widget = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (!widget) widget = ih->handle;
+
+  XtVaSetValues(widget,
+    XmNx, (XtArgVal)ih->x,
+    XmNy, (XtArgVal)ih->y,
+    XmNwidth, (XtArgVal)ih->currentwidth,
+    XmNheight, (XtArgVal)ih->currentheight,
+    NULL);
+}
+
+void iupdrvBaseUnMapMethod(Ihandle* ih)
+{
+  Widget widget = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (!widget) widget = ih->handle;
+
+  XtUnrealizeWidget(widget); /* To match the call to XtRealizeWidget */
+  XtDestroyWidget(widget);   /* To match the call to XtCreateManagedWidget */
+}
+
+void iupdrvDisplayUpdate(Ihandle *ih)
+{
+  XExposeEvent evt;
+  Dimension w, h;
+
+  XtVaGetValues(ih->handle, XmNwidth, &w, 
+                            XmNheight, &h, 
+                            NULL);
+
+  evt.type = Expose;
+  evt.display = iupmot_display;
+  evt.send_event = True;
+  evt.window = XtWindow(ih->handle);
+
+  evt.x = 0;
+  evt.y = 0;
+  evt.width = w;
+  evt.height = h;
+
+  evt.count = 0;
+
+  /* POST a Redraw */
+  XSendEvent(iupmot_display, XtWindow(ih->handle), False, ExposureMask, (XEvent*)&evt);
+}
+
+void iupdrvDisplayRedraw(Ihandle *ih)
+{
+  Widget w;
+
+  /* POST a Redraw */
+  iupdrvDisplayUpdate(ih);
+
+  /* if this element has an inner native parent (like IupTabs), 
+     then redraw that native parent if different from the element. */
+  w = (Widget)iupClassObjectGetInnerNativeContainerHandle(ih, (Ihandle*)IupGetAttribute(ih, "VALUE_HANDLE"));
+  if (w && w != ih->handle)
+  {
+    Widget handle = ih->handle;
+    ih->handle = w;
+    iupdrvDisplayUpdate(ih);
+    ih->handle = handle;
+  }
+
+  /* flush exposure events. */
+  XmUpdateDisplay(ih->handle);
+}
+
+void iupdrvScreenToClient(Ihandle* ih, int *x, int *y)
+{
+  Window child;
+  XTranslateCoordinates(iupmot_display, RootWindow(iupmot_display, iupmot_screen),
+                                        XtWindow(ih->handle),
+                                        *x, *y, x, y, &child);
+}
+
+void iupmotHelpCallback(Widget w, Ihandle *ih, XtPointer call_data)
+{
+  Icallback cb = IupGetCallback(ih, "HELP_CB");
+  if (cb && cb(ih) == IUP_CLOSE)
+    IupExitLoop();
+
+  (void)call_data;
+  (void)w;
+}
+
+void iupmotEnterLeaveWindowEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont)
+{
+  Icallback cb = NULL;
+  (void)cont;
+  (void)w;
+
+  if (evt->type == EnterNotify)
+  {
+    iupmotTipEnterNotify(ih);
+
+    cb = IupGetCallback(ih, "ENTERWINDOW_CB");
+  }
+  else  if (evt->type == LeaveNotify)
+  {
+    iupmotTipLeaveNotify();
+
+    cb = IupGetCallback(ih, "LEAVEWINDOW_CB");
+  }
+
+  if (cb)
+    cb(ih);
+}
+
+int iupdrvBaseSetZorderAttrib(Ihandle* ih, const char* value)
+{
+  if (iupdrvIsVisible(ih))
+  {
+    if (iupStrEqualNoCase(value, "TOP"))
+      XRaiseWindow(iupmot_display, XtWindow(ih->handle));
+    else
+      XLowerWindow(iupmot_display, XtWindow(ih->handle));
+  }
+
+  return 0;
+}
+
+void iupdrvSetVisible(Ihandle* ih, int visible)
+{
+  Widget widget = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (!widget) widget = ih->handle;
+
+  if (visible)
+    XtMapWidget(widget);
+  else
+    XtUnmapWidget(widget);
+}
+
+int iupdrvIsVisible(Ihandle* ih)
+{
+  XWindowAttributes wa;
+  XGetWindowAttributes(iupmot_display, XtWindow(ih->handle), &wa);
+  return (wa.map_state == IsViewable);
+}
+
+int iupdrvIsActive(Ihandle* ih)
+{
+  return XtIsSensitive(ih->handle);
+}
+
+void iupdrvSetActive(Ihandle* ih, int enable)
+{
+  Widget widget = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (!widget) widget = ih->handle;
+
+  XtSetSensitive(widget, enable);
+}
+
+char* iupmotGetXWindowAttrib(Ihandle *ih)
+{
+  return (char*)XtWindow(ih->handle);
+}
+
+char* iupdrvBaseGetXAttrib(Ihandle *ih)
+{
+  int x, y;
+  Window child;
+  char* str = iupStrGetMemory(20);
+  Widget widget = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (!widget) widget = ih->handle;
+
+  /* Translating to absolute screen coordinates */
+                     /* source            destination */
+  XTranslateCoordinates(iupmot_display, 
+                        XtWindow(widget), RootWindow(iupmot_display, iupmot_screen), 
+                        0, 0,             &x, &y, 
+                        &child);
+
+  sprintf(str, "%d", x);
+  return str;
+}
+
+char* iupdrvBaseGetYAttrib(Ihandle *ih)
+{
+  int x, y;
+  Window child;
+  char* str = iupStrGetMemory(20);
+  Widget widget = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (!widget) widget = ih->handle;
+
+  /* Translating to absolute screen coordinates */
+                     /* source            destination */
+  XTranslateCoordinates(iupmot_display, 
+                        XtWindow(widget), RootWindow(iupmot_display, iupmot_screen), 
+                        0, 0,             &x, &y, 
+                        &child);
+
+  sprintf(str, "%d", y);
+  return str;
+}
+
+void iupmotSetBgColor(Widget w, Pixel color)
+{
+  Pixel fgcolor;
+  XtVaGetValues(w, XmNforeground, &fgcolor, NULL);
+  XmChangeColor(w, color);
+  /* XmChangeColor also sets the XmNforeground color, so we must reset to the previous one. */
+  XtVaSetValues(w, XmNforeground, fgcolor, NULL);
+  XtVaSetValues(w, XmNbackgroundPixmap, XmUNSPECIFIED_PIXMAP, NULL);
+}
+
+int iupdrvBaseSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    iupmotSetBgColor(ih->handle, color);
+
+    /* update internal image cache for controls that have the IMAGE attribute */
+    iupImageUpdateParent(ih);
+  }
+  return 1;
+}
+
+char* iupmotGetBgColorAttrib(Ihandle* ih)
+{
+  unsigned char r, g, b;
+  Pixel color;
+  char* str = iupStrGetMemory(20);
+  XtVaGetValues(ih->handle, XmNbackground, &color, NULL); 
+  iupmotColorGetRGB(color, &r, &g, &b);
+  sprintf(str, "%d %d %d", (int)r, (int)g, (int)b);
+  return str;
+}
+
+int iupdrvBaseSetFgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+    XtVaSetValues(ih->handle, XmNforeground, color, NULL);
+  return 1;
+}
+
+void iupmotGetWindowSize(Ihandle *ih, int *width, int *height)
+{
+  Dimension w, h;
+  XtVaGetValues(ih->handle, XmNwidth, &w, 
+                            XmNheight, &h, 
+                            NULL);
+  *width = w;
+  *height = h;
+}
+
+static Cursor motEmptyCursor(Ihandle* ih)
+{
+  /* creates an empty cursor */
+  XColor cursor_color = {0L,0,0,0,0,0};
+  char bitsnull[1] = {0x00};
+  Pixmap pixmapnull;
+  Cursor cur;
+
+  pixmapnull = XCreateBitmapFromData(iupmot_display,
+    XtWindow(ih->handle),
+    bitsnull,
+    1,1);
+
+  cur = XCreatePixmapCursor(iupmot_display,
+    pixmapnull,
+    pixmapnull,
+    &cursor_color,
+    &cursor_color,
+    0,0);
+
+  XFreePixmap(iupmot_display, pixmapnull);
+
+  return cur;
+}
+
+static Cursor motGetCursor(Ihandle* ih, const char* name)
+{
+  static struct {
+    const char* iupname;
+    int         sysname;
+  } table[] = {
+    { "NONE",      0}, 
+    { "NULL",      0}, 
+    { "ARROW",     XC_left_ptr},
+    { "BUSY",      XC_watch},
+    { "CROSS",     XC_crosshair},
+    { "HAND",      XC_hand2},
+    { "HELP",      XC_question_arrow},
+    { "IUP",       XC_question_arrow},
+    { "MOVE",      XC_fleur},
+    { "PEN",       XC_pencil},
+    { "RESIZE_N",  XC_top_side},
+    { "RESIZE_S",  XC_bottom_side},
+    { "RESIZE_NS", XC_sb_v_double_arrow},
+    { "RESIZE_W",  XC_left_side},
+    { "RESIZE_E",  XC_right_side},
+    { "RESIZE_WE", XC_sb_h_double_arrow},
+    { "RESIZE_NE", XC_top_right_corner},
+    { "RESIZE_SE", XC_bottom_right_corner},
+    { "RESIZE_NW", XC_top_left_corner},
+    { "RESIZE_SW", XC_bottom_left_corner},
+    { "TEXT",      XC_xterm}, 
+    { "UPARROW",   XC_center_ptr} 
+  };
+
+  Cursor cur;
+  char str[50];
+  int i, count = sizeof(table)/sizeof(table[0]);
+
+  /* check the cursor cache first (per control)*/
+  sprintf(str, "_IUPMOT_CURSOR_%s", name);
+  cur = (Cursor)iupAttribGet(ih, str);
+  if (cur)
+    return cur;
+
+  /* check the pre-defined IUP names first */
+  for (i = 0; i < count; i++)
+  {
+    if (iupStrEqualNoCase(name, table[i].iupname)) 
+    {
+      if (table[i].sysname)
+        cur = XCreateFontCursor(iupmot_display, table[i].sysname);
+      else
+        cur = motEmptyCursor(ih);
+
+      break;
+    }
+  }
+
+  if (i == count)
+  {
+    /* check for a name defined cursor */
+    cur = (Cursor)iupImageGetCursor(name);
+  }
+
+  iupAttribSetStr(ih, str, (char*)cur);
+  return cur;
+}
+
+int iupdrvBaseSetCursorAttrib(Ihandle* ih, const char* value)
+{
+  Cursor cur = motGetCursor(ih, value);
+  if (cur)
+  {
+    XDefineCursor(iupmot_display, XtWindow(ih->handle), cur);
+    return 1;
+  }
+  return 0;
+}
+
+#include <Xm/XmP.h>
+#include <Xm/DrawP.h>
+
+void iupdrvDrawFocusRect(Ihandle* ih, void* _gc, int x, int y, int w, int h)
+{
+  Drawable wnd = (Drawable)IupGetAttribute(ih, "XWINDOW");  /* Use IupGetAttribute to consult the native implemetation */
+  GC gc = (GC)_gc;
+  XmeDrawHighlight(iupmot_display, wnd, gc, x, y, w, h, 1);
+}
+
+void iupdrvBaseRegisterCommonAttrib(Iclass* ic)
+{
+  iupClassRegisterAttribute(ic, "XMFONTLIST", iupmotGetFontListAttrib, NULL, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT|IUPAF_NO_STRING);
+  iupClassRegisterAttribute(ic, "XFONTSTRUCT", iupmotGetFontStructAttrib, NULL, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT|IUPAF_NO_STRING);
+  iupClassRegisterAttribute(ic, "XFONTID", iupmotGetFontIdAttrib, NULL, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT|IUPAF_NO_STRING);
+}
+
+static void motDoNothing(Widget w, XEvent*  evt, String* params, Cardinal* num_params)
+{
+  (void)w;
+  (void)evt;
+  (void)params;
+  (void)num_params;
+}
+
+void iupmotDisableDragSource(Widget w)
+{
+  char dragTranslations[] = "#override <Btn2Down>: iupDoNothing()";
+  static int do_nothing_rec = 0;
+  if (!do_nothing_rec)
+  {
+    XtActionsRec rec = {"iupDoNothing", (XtActionProc)motDoNothing};
+    XtAppAddActions(iupmot_appcontext, &rec, 1);
+    do_nothing_rec = 1;
+  }
+  XtOverrideTranslations(w, XtParseTranslationTable(dragTranslations));
+}
+
+int iupdrvGetScrollbarSize(void)
+{
+  return 15;
+}
+
+void iupmotSetPixmap(Ihandle* ih, const char* name, const char* prop, int make_inactive)
+{
+  if (name)
+  {
+    Pixmap old_pixmap;
+    Pixmap pixmap = (Pixmap)iupImageGetImage(name, ih, make_inactive);
+    if (!pixmap) 
+      pixmap = XmUNSPECIFIED_PIXMAP;
+    XtVaGetValues(ih->handle, prop, &old_pixmap, NULL);
+    if (pixmap != old_pixmap)
+      XtVaSetValues(ih->handle, prop, pixmap, NULL);
+    return;
+  }
+
+  /* if not defined */
+  XtVaSetValues(ih->handle, prop, XmUNSPECIFIED_PIXMAP, NULL);
+}
+
+void iupmotButtonPressReleaseEvent(Widget w, Ihandle* ih, XEvent* evt, Boolean* cont)
+{
+  unsigned long elapsed;
+  static Time last = 0;
+  char status[IUPKEY_STATUS_SIZE] = IUPKEY_STATUS_INIT;
+  IFniiiis cb;
+
+  XButtonEvent *but_evt = (XButtonEvent*)evt;
+  if (but_evt->button!=Button1 &&
+      but_evt->button!=Button2 &&
+      but_evt->button!=Button3 &&
+      but_evt->button!=Button4 &&
+      but_evt->button!=Button5) 
+    return;
+
+  cb = (IFniiiis) IupGetCallback(ih,"BUTTON_CB");
+  if (cb)
+  {
+    int ret, doubleclick = 0;
+    int b = IUP_BUTTON1+(but_evt->button-1);
+
+    /* Double/Single Click */
+    if (but_evt->type==ButtonPress)
+    {
+      elapsed = but_evt->time - last;
+      last = but_evt->time;
+      if ((int)elapsed <= XtGetMultiClickTime(iupmot_display))
+        doubleclick = 1;
+    }
+
+    iupmotButtonKeySetStatus(but_evt->state, but_evt->button, status, doubleclick);
+
+    ret = cb(ih, b, (but_evt->type==ButtonPress), but_evt->x, but_evt->y, status);
+    if (ret==IUP_CLOSE)
+      IupExitLoop();
+    else if (ret==IUP_IGNORE)
+      *cont=False;
+  }         
+
+  (void)w;
+}
+
+void iupmotPointerMotionEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont)
+{
+  IFniis cb = (IFniis)IupGetCallback(ih,"MOTION_CB");
+  if (cb)
+  {
+    XMotionEvent *motion_evt = (XMotionEvent*)evt;
+    char status[IUPKEY_STATUS_SIZE] = IUPKEY_STATUS_INIT;
+    iupmotButtonKeySetStatus(motion_evt->state, 0, status, 0);
+    cb(ih, motion_evt->x, motion_evt->y, status);
+  }
+
+  (void)w;
+  (void)cont;
+}
diff --git a/iup/src/mot/iupmot_dialog.c b/iup/src/mot/iupmot_dialog.c
new file mode 100755
index 0000000..4eeb834
--- /dev/null
+++ b/iup/src/mot/iupmot_dialog.c
@@ -0,0 +1,1069 @@
+/** \file
+ * \brief IupDialog class
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/BulletinB.h>
+#include <Xm/MwmUtil.h>
+#include <Xm/AtomMgr.h>
+#include <Xm/Protocols.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+#include <limits.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_class.h"
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_dlglist.h"
+#include "iup_attrib.h"
+#include "iup_drv.h"
+#include "iup_drvfont.h"
+#include "iup_drvinfo.h"
+#include "iup_focus.h"
+#include "iup_str.h"
+#define _IUPDLG_PRIVATE
+#include "iup_dialog.h"
+#include "iup_image.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+Atom iupmot_wm_deletewindow = 0;  /* used also by IupMessageDlg */
+
+static int motDialogSetBgColorAttrib(Ihandle* ih, const char* value);
+
+/****************************************************************
+                     Utilities
+****************************************************************/
+
+
+int iupdrvDialogIsVisible(Ihandle* ih)
+{
+  return iupdrvIsVisible(ih) || ih->data->show_state == IUP_MINIMIZE;
+}
+
+void iupdrvDialogUpdateSize(Ihandle* ih)
+{
+  Dimension width, height;
+  XtVaGetValues(ih->handle, XmNwidth, &width, XmNheight, &height, NULL);
+  ih->currentwidth = width;
+  ih->currentheight = height;
+}
+
+void iupdrvDialogGetSize(InativeHandle* handle, int *w, int *h)
+{
+  Dimension width, height;
+  XtVaGetValues(handle, XmNwidth, &width, XmNheight, &height, NULL);
+  if (w) *w = width;
+  if (h) *h = height;
+}
+
+void iupmotDialogSetVisual(Ihandle* ih, void* visual)
+{
+  Ihandle *dialog = IupGetDialog(ih);
+  XtVaSetValues(dialog->handle, XmNvisual, visual, NULL);
+}
+
+void iupmotDialogResetVisual(Ihandle* ih)
+{
+  Ihandle *dialog = IupGetDialog(ih);
+  XtVaSetValues(dialog->handle, XmNvisual, iupmot_visual, NULL);
+}
+
+void iupdrvDialogSetVisible(Ihandle* ih, int visible)
+{
+  if (visible)
+  {
+    XtMapWidget(ih->handle);
+    XRaiseWindow(iupmot_display, XtWindow(ih->handle));
+    while (!iupdrvDialogIsVisible(ih)); /* waits until window get mapped */
+  }
+  else
+  {
+    /* if iupdrvIsVisible reports hidden, then it should be minimized */ 
+    if (!iupdrvIsVisible(ih))  /* can NOT hide a minimized window, so map it first. */
+    {
+      XtMapWidget(ih->handle);
+      XRaiseWindow(iupmot_display, XtWindow(ih->handle));
+      while (!iupdrvDialogIsVisible(ih)); /* waits until window get mapped */
+    }
+
+    XtUnmapWidget(ih->handle);
+    while (iupdrvDialogIsVisible(ih)); /* waits until window gets unmapped */
+  }
+}
+
+void iupdrvDialogGetPosition(InativeHandle* handle, int *x, int *y)
+{
+  Dimension cur_x, cur_y;
+  XtVaGetValues(handle, XmNx, &cur_x, 
+                        XmNy, &cur_y, 
+                        NULL);
+  if (x) *x = cur_x;
+  if (y) *y = cur_y;
+}
+
+void iupdrvDialogSetPosition(Ihandle *ih, int x, int y)
+{
+  XtVaSetValues(ih->handle,
+    XmNx, (XtArgVal)x,
+    XmNy, (XtArgVal)y,
+    NULL);
+}
+
+static int motDialogGetMenuSize(Ihandle* ih)
+{
+  if (ih->data->menu)
+    return iupdrvMenuGetMenuBarSize(ih->data->menu);
+  else
+    return 0;
+}
+
+void iupdrvDialogGetDecoration(Ihandle* ih, int *border, int *caption, int *menu)
+{
+  static int native_border = 0;
+  static int native_caption = 0;
+
+  int has_caption = iupAttribGetBoolean(ih, "MAXBOX")  ||
+                    iupAttribGetBoolean(ih, "MINBOX")  ||
+                    iupAttribGetBoolean(ih, "MENUBOX") || 
+                    IupGetAttribute(ih, "TITLE");  /* must use IupGetAttribute to check from the native implementation */
+
+  int has_border = has_caption ||
+                   iupAttribGetBoolean(ih, "RESIZE") ||
+                   iupAttribGetBoolean(ih, "BORDER");
+
+  *menu = motDialogGetMenuSize(ih);
+
+  if (ih->handle && iupdrvDialogIsVisible(ih))
+  {
+    int win_border, win_caption;
+    if (iupdrvGetWindowDecor((void*)XtWindow(ih->handle), &win_border, &win_caption))
+    {
+      *border = 0;
+      if (has_border)
+        *border = win_border;
+
+      *caption = 0;
+      if (has_caption)
+        *caption = win_caption;
+
+      if (!native_border && *border)
+        native_border = win_border;
+
+      if (!native_caption && *caption)
+        native_caption = win_caption;
+
+      return;
+    }
+  }
+
+  /* I could not set the size of the window including the decorations when the dialog is hidden */
+  /* So we have to estimate the size of borders and caption when the dialog is hidden           */
+
+  *border = 0;
+  if (has_border)
+  {
+    if (native_border)
+      *border = native_border;
+    else
+      *border = 5;
+  }
+
+  *caption = 0;
+  if (has_caption)
+  {
+    if (native_caption)
+      *caption = native_caption;
+    else
+      *caption = 20;
+  }
+}
+
+static int motDialogQueryWMspecSupport(Atom feature)
+{
+  static Atom netsuppport = 0;
+  Atom type;
+  Atom *atoms;
+  int format;
+  unsigned long after, natoms, i;
+
+  if (!netsuppport)
+    netsuppport = XmInternAtom(iupmot_display, "_NET_SUPPORTED", False);
+
+  /* get all the features */
+  XGetWindowProperty(iupmot_display, RootWindow(iupmot_display, iupmot_screen),
+                     netsuppport, 0, LONG_MAX, False, XA_ATOM, &type, &format, &natoms,
+                     &after, (unsigned char **)&atoms);
+  if (type != XA_ATOM || atoms == NULL)
+  {
+    if (atoms) XFree(atoms);
+    return 0;
+  }
+
+  /* Lookup the feature we want */
+  for (i = 0; i < natoms; i++)
+  {
+    if (atoms[i] == feature)
+    {
+      XFree(atoms);
+      return 1;
+    }
+  }
+
+  XFree(atoms);
+  return 0;
+}
+
+static void motDialogSetWindowManagerStyle(Ihandle* ih)
+{
+  MwmHints hints;
+  static Atom xwmhint = 0;
+  if (!xwmhint)
+    xwmhint = XmInternAtom(iupmot_display, "_MOTIF_WM_HINTS", False);
+
+  hints.flags = (MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS);
+  hints.functions = 0;
+  hints.decorations = 0;
+  hints.input_mode = 0;
+  hints.status = 0;
+
+  if (IupGetAttribute(ih, "TITLE")) {  /* must use IupGetAttribute to check from the native implementation */
+    hints.functions   |= MWM_FUNC_MOVE;
+    hints.decorations |= MWM_DECOR_TITLE;
+  }
+
+  if (iupAttribGetBoolean(ih, "MENUBOX")) {
+    hints.functions   |= MWM_FUNC_CLOSE;
+    hints.decorations |= MWM_DECOR_MENU;
+  }
+
+  if (iupAttribGetBoolean(ih, "MINBOX")) {
+    hints.functions   |= MWM_FUNC_MINIMIZE;
+    hints.decorations |= MWM_DECOR_MINIMIZE;
+  }
+
+  if (iupAttribGetBoolean(ih, "MAXBOX")) {
+    hints.functions   |= MWM_FUNC_MAXIMIZE;
+    hints.decorations |= MWM_DECOR_MAXIMIZE;
+  }
+
+  if (iupAttribGetBoolean(ih, "RESIZE")) {
+    hints.functions   |= MWM_FUNC_RESIZE;
+    hints.decorations |= MWM_DECOR_RESIZEH;
+  }
+
+  if (iupAttribGetBoolean(ih, "BORDER"))
+    hints.decorations |= MWM_DECOR_BORDER;
+
+  XChangeProperty(iupmot_display, XtWindow(ih->handle),
+      xwmhint, xwmhint,
+      32, PropModeReplace,
+      (const unsigned char *) &hints,
+      PROP_MOTIF_WM_HINTS_ELEMENTS);
+}
+
+static void motDialogChangeWMState(Ihandle* ih, Atom state1, Atom state2, int operation)
+{
+  static Atom wmstate = 0;
+  if (!wmstate)
+    wmstate = XmInternAtom(iupmot_display, "_NET_WM_STATE", False);
+
+  if (iupdrvDialogIsVisible(ih))
+  {
+    XEvent evt;
+    evt.type = ClientMessage;
+    evt.xclient.type = ClientMessage;
+    evt.xclient.serial = 0;
+    evt.xclient.send_event = True;
+    evt.xclient.display = iupmot_display;
+    evt.xclient.window = XtWindow(ih->handle);
+    evt.xclient.message_type = wmstate;
+    evt.xclient.format = 32;
+    evt.xclient.data.l[0] = operation;
+    evt.xclient.data.l[1] = state1;
+    evt.xclient.data.l[2] = state2;
+    evt.xclient.data.l[3] = 0;
+    evt.xclient.data.l[4] = 0;
+    
+    XSendEvent(iupmot_display, RootWindow(iupmot_display, iupmot_screen), False,
+               SubstructureRedirectMask | SubstructureNotifyMask, &evt);
+  }
+  else
+  {
+    if (operation)
+    {
+      if (state1 && state2)
+      {
+        Atom atoms[2];
+        atoms[0] = state1;
+        atoms[0] = state2;
+
+        XChangeProperty(iupmot_display, XtWindow(ih->handle),
+            wmstate, XA_ATOM,
+            32, PropModeReplace,
+            (const unsigned char *)&atoms, 2);
+      }
+      else
+      {
+        XChangeProperty(iupmot_display, XtWindow(ih->handle),
+            wmstate, XA_ATOM,
+            32, PropModeReplace,
+            (const unsigned char *)&state1, 1);
+      }
+    }
+    else
+    {
+      /* TODO: This is not working. The property is not correctly removed. */
+      /* XDeleteProperty(iupmot_display, XtWindow(ih->handle), wmstate); */
+
+      /* Maybe the right way to do it is to retrieve all the atoms               */
+      /* and change again with all atoms except the one to remove                */
+    }
+  }
+}
+
+static int motDialogSetFullScreen(Ihandle* ih, int fullscreen)
+{
+  static int support_fullscreen = -1;  /* WARNING: The WM can be changed dinamically */
+
+  static Atom xwmfs = 0;
+  if (!xwmfs)
+    xwmfs = XmInternAtom(iupmot_display, "_NET_WM_STATE_FULLSCREEN", False);
+
+  if (support_fullscreen == -1)
+    support_fullscreen = motDialogQueryWMspecSupport(xwmfs);
+
+  if (support_fullscreen)
+  {
+    motDialogChangeWMState(ih, xwmfs, 0, fullscreen);
+    return 1;
+  }
+
+  return 0;
+}
+
+int iupdrvDialogSetPlacement(Ihandle* ih)
+{
+  char* placement;
+  ih->data->show_state = IUP_SHOW;
+
+  if (iupAttribGetBoolean(ih, "FULLSCREEN"))
+    return 1;
+  
+  placement = iupAttribGet(ih, "PLACEMENT");
+  if (!placement)
+    return 0;
+
+  if (iupStrEqualNoCase(placement, "MINIMIZED"))
+  {
+    if (iupdrvDialogIsVisible(ih))
+      XIconifyWindow(iupmot_display, XtWindow(ih->handle), iupmot_screen);
+    else
+    {
+      /* TODO: This is not working, so force a minimize after visible.  */
+      /*XWMHints wm_hints;                                               */
+      /*wm_hints.flags = StateHint;                                      */
+      /*wm_hints.initial_state = IconicState;                            */
+      /*XSetWMHints(iupmot_display, XtWindow(ih->handle), &wm_hints);  */
+
+      XtMapWidget(ih->handle);
+      XIconifyWindow(iupmot_display, XtWindow(ih->handle), iupmot_screen);
+    }
+  }
+  else if (iupStrEqualNoCase(placement, "MAXIMIZED"))
+  {
+    static Atom maxatoms[2] = {0, 0};
+    if (!(maxatoms[0]))
+    {
+      maxatoms[0] = XmInternAtom(iupmot_display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
+      maxatoms[1] = XmInternAtom(iupmot_display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
+    }
+
+    motDialogChangeWMState(ih, maxatoms[0], maxatoms[1], 1);
+  }
+  else if (iupStrEqualNoCase(placement, "FULL"))
+  {
+    int width, height, x, y;
+    int border, caption, menu;
+    iupdrvDialogGetDecoration(ih, &border, &caption, &menu);
+
+    /* position the decoration outside the screen */
+    x = -(border);
+    y = -(border+caption+menu);
+
+    /* the dialog client area will cover the task bar */
+    iupdrvGetFullSize(&width, &height);
+
+    height += menu; /* the menu is included in the client area size in Motif. */
+
+    /* set the new size and position */
+    /* The resize event will update the layout */
+    XtVaSetValues(ih->handle,
+      XmNx, (XtArgVal)x,  /* outside border */
+      XmNy, (XtArgVal)y,
+      XmNwidth, (XtArgVal)width,  /* client size */
+      XmNheight, (XtArgVal)height,
+      NULL);
+  }
+
+  iupAttribSetStr(ih, "PLACEMENT", NULL); /* reset to NORMAL */
+
+  return 1;
+}
+
+/****************************************************************************
+                                   Attributes
+****************************************************************************/
+
+
+static int motDialogSetMinSizeAttrib(Ihandle* ih, const char* value)
+{
+  int decorwidth = 0, decorheight = 0;
+  int min_w = 1, min_h = 1;          /* MINSIZE default value */
+  iupStrToIntInt(value, &min_w, &min_h, 'x');
+
+  /* The minmax size restricts the client area */
+  iupDialogGetDecorSize(ih, &decorwidth, &decorheight);
+
+  if (min_w > decorwidth)
+    XtVaSetValues(ih->handle, XmNminWidth, min_w-decorwidth, NULL);
+  if (min_h > decorheight)
+    XtVaSetValues(ih->handle, XmNminHeight, min_h-decorheight, NULL);  
+
+  return 1;
+}
+
+static int motDialogSetMaxSizeAttrib(Ihandle* ih, const char* value)
+{
+  int decorwidth = 0, decorheight = 0;
+  int max_w = 65535, max_h = 65535;  /* MAXSIZE default value */
+  iupStrToIntInt(value, &max_w, &max_h, 'x');
+
+  /* The minmax size restricts the client area */
+  iupDialogGetDecorSize(ih, &decorwidth, &decorheight);
+
+  if (max_w > decorwidth)
+    XtVaSetValues(ih->handle, XmNmaxWidth, max_w-decorwidth, NULL);  
+  if (max_h > decorheight)
+    XtVaSetValues(ih->handle, XmNmaxHeight, max_h-decorheight, NULL);  
+
+  return 1;
+}
+
+static char* motDialogGetXAttrib(Ihandle *ih)
+{
+  char* str = iupStrGetMemory(20);
+ 
+  int x;
+  iupdrvDialogGetPosition(ih->handle, &x, NULL);
+
+  sprintf(str, "%d", x);
+  return str;
+}
+
+static char* motDialogGetYAttrib(Ihandle *ih)
+{
+  char* str = iupStrGetMemory(20);
+ 
+  int y;
+  iupdrvDialogGetPosition(ih->handle, &y, NULL);
+
+  sprintf(str, "%d", y);
+  return str;
+}
+
+static int motDialogSetTitleAttrib(Ihandle* ih, const char* value)
+{
+  if (!value)
+    value = "";
+
+  XtVaSetValues(ih->handle, XmNtitle, value, 
+                                    XmNiconName, value, 
+                                    NULL);
+  return 0;
+}
+
+static char* motDialogGetTitleAttrib(Ihandle* ih)
+{
+  char* title;
+  XtVaGetValues(ih->handle, XmNtitle, &title, NULL);
+
+  if (!title || title[0] == 0)
+    return NULL;
+  else
+  {
+    char* str = iupStrGetMemory(200);
+    strcpy(str, title);
+    return str;
+  }
+}    
+
+static char* motDialogGetClientSizeAttrib(Ihandle *ih)
+{
+  char* str = iupStrGetMemory(20);
+ 
+  Dimension manager_width, manager_height;
+  Widget dialog_manager = XtNameToWidget(ih->handle, "*dialog_manager");
+  XtVaGetValues(dialog_manager, XmNwidth,  &manager_width,
+                         XmNheight, &manager_height, 
+                         NULL);
+
+  sprintf(str, "%dx%d", (int)manager_width, (int)manager_height - motDialogGetMenuSize(ih));
+  return str;
+}
+
+static int motDialogSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    Widget dialog_manager = XtNameToWidget(ih->handle, "*dialog_manager");
+    XtVaSetValues(dialog_manager, XmNbackground, color, NULL);
+    XtVaSetValues(dialog_manager, XmNbackgroundPixmap, XmUNSPECIFIED_PIXMAP, NULL);
+    return 1;
+  }
+  return 0; 
+}
+
+static int motDialogSetBackgroundAttrib(Ihandle* ih, const char* value)
+{
+  if (motDialogSetBgColorAttrib(ih, value))
+    return 1;
+  else                                     
+  {
+    Pixmap pixmap = (Pixmap)iupImageGetImage(value, ih, 0);
+    if (pixmap)
+    {
+      Widget dialog_manager = XtNameToWidget(ih->handle, "*dialog_manager");
+      XtVaSetValues(dialog_manager, XmNbackgroundPixmap, pixmap, NULL);
+      return 1;
+    }
+  }
+  return 0; 
+}
+
+static int motDialogSetFullScreenAttrib(Ihandle* ih, const char* value)
+{                       
+  if (iupStrBoolean(value))
+  {
+    if (!iupAttribGet(ih, "_IUPMOT_FS_STYLE"))
+    {
+      int visible = iupdrvDialogIsVisible(ih);
+      if (visible)
+        iupAttribSetStr(ih, "_IUPMOT_FS_STYLE", "VISIBLE");
+      else
+        iupAttribSetStr(ih, "_IUPMOT_FS_STYLE", "HIDDEN");
+
+      /* save the previous decoration attributes */
+      /* during fullscreen these attributes can be consulted by the application */
+      iupAttribStoreStr(ih, "_IUPMOT_FS_MAXBOX", iupAttribGet(ih, "MAXBOX"));
+      iupAttribStoreStr(ih, "_IUPMOT_FS_MINBOX", iupAttribGet(ih, "MINBOX"));
+      iupAttribStoreStr(ih, "_IUPMOT_FS_MENUBOX",iupAttribGet(ih, "MENUBOX"));
+      iupAttribStoreStr(ih, "_IUPMOT_FS_RESIZE", iupAttribGet(ih, "RESIZE"));
+      iupAttribStoreStr(ih, "_IUPMOT_FS_BORDER", iupAttribGet(ih, "BORDER"));
+      iupAttribStoreStr(ih, "_IUPMOT_FS_TITLE",  IupGetAttribute(ih, "TITLE"));  /* must use IupGetAttribute to check from the native implementation */
+
+      /* remove the decorations attributes */
+      iupAttribSetStr(ih, "MAXBOX", "NO");
+      iupAttribSetStr(ih, "MINBOX", "NO");
+      iupAttribSetStr(ih, "MENUBOX", "NO");
+      IupSetAttribute(ih, "TITLE", NULL); iupAttribSetStr(ih, "TITLE", NULL); /* remove from the hash table if we are during IupMap */
+      iupAttribSetStr(ih, "RESIZE", "NO");
+      iupAttribSetStr(ih, "BORDER", "NO");
+
+      /* use WM fullscreen support */
+      if (!motDialogSetFullScreen(ih, 1))
+      {
+        /* or configure fullscreen manually */
+        int decor;
+        int width, height;
+
+        /* hide before changing decorations */
+        if (visible)
+        {
+          iupAttribSetStr(ih, "_IUPMOT_SHOW_STATE", NULL);  /* To avoid a SHOW_CB notification */
+          XtUnmapWidget(ih->handle);
+        }
+
+        /* save the previous position and size */
+        iupAttribStoreStr(ih, "_IUPMOT_FS_X", IupGetAttribute(ih, "X"));  /* must use IupGetAttribute to check from the native implementation */
+        iupAttribStoreStr(ih, "_IUPMOT_FS_Y", IupGetAttribute(ih, "Y"));
+        iupAttribStoreStr(ih, "_IUPMOT_FS_SIZE", IupGetAttribute(ih, "RASTERSIZE"));
+
+        /* save the previous decoration */
+        XtVaGetValues(ih->handle, XmNmwmDecorations, &decor, NULL);
+        iupAttribSetStr(ih, "_IUPMOT_FS_DECOR", (char*)decor);
+
+        /* remove the decorations */
+        XtVaSetValues(ih->handle, XmNmwmDecorations, (XtArgVal)0, NULL);
+        motDialogSetWindowManagerStyle(ih);
+
+        /* get full screen size */
+        iupdrvGetFullSize(&width, &height);
+
+        /* set position and size */
+        XtVaSetValues(ih->handle, XmNwidth,  (XtArgVal)width,
+                                          XmNheight, (XtArgVal)height, 
+                                          XmNx,      (XtArgVal)0,
+                                          XmNy,      (XtArgVal)0,
+                                          NULL);
+
+        /* layout will be updated in motDialogConfigureNotify */
+        if (visible)
+          XtMapWidget(ih->handle);
+      }
+    }
+  }
+  else
+  {
+    char* fs_style = iupAttribGet(ih, "_IUPMOT_FS_STYLE");
+    if (fs_style)
+    {
+      /* can only switch back from full screen if window was visible */
+      /* when fullscreen was set */
+      if (iupStrEqualNoCase(fs_style, "VISIBLE"))
+      {
+        iupAttribSetStr(ih, "_IUPMOT_FS_STYLE", NULL);
+
+        /* restore the decorations attributes */
+        iupAttribStoreStr(ih, "MAXBOX", iupAttribGet(ih, "_IUPMOT_FS_MAXBOX"));
+        iupAttribStoreStr(ih, "MINBOX", iupAttribGet(ih, "_IUPMOT_FS_MINBOX"));
+        iupAttribStoreStr(ih, "MENUBOX",iupAttribGet(ih, "_IUPMOT_FS_MENUBOX"));
+        IupSetAttribute(ih, "TITLE",  iupAttribGet(ih, "_IUPMOT_FS_TITLE"));   /* TITLE is not stored in the HashTable */
+        iupAttribStoreStr(ih, "RESIZE", iupAttribGet(ih, "_IUPMOT_FS_RESIZE"));
+        iupAttribStoreStr(ih, "BORDER", iupAttribGet(ih, "_IUPMOT_FS_BORDER"));
+
+        if (!motDialogSetFullScreen(ih, 0))
+        {
+          int border, caption, menu, x, y;
+          int visible = iupdrvDialogIsVisible(ih);
+          if (visible)
+            XtUnmapWidget(ih->handle);
+
+          /* restore the decorations */
+          XtVaSetValues(ih->handle, XmNmwmDecorations, (XtArgVal)(int)iupAttribGet(ih, "_IUPMOT_FS_DECOR"), NULL);
+          motDialogSetWindowManagerStyle(ih);
+
+          /* the dialog decoration will not be considered yet in the next XtVaSetValues */
+          /* so compensate the decoration when restoring the position and size */
+          iupdrvDialogGetDecoration(ih, &border, &caption, &menu);
+          x = iupAttribGetInt(ih, "_IUPMOT_FS_X") - (border);
+          y = iupAttribGetInt(ih, "_IUPMOT_FS_Y") - (border+caption+menu);
+
+          /* restore position and size */
+          XtVaSetValues(ih->handle, 
+                      XmNx,      (XtArgVal)x, 
+                      XmNy,      (XtArgVal)y, 
+                      XmNwidth,  (XtArgVal)(IupGetInt(ih, "_IUPMOT_FS_SIZE") - (2*border)), 
+                      XmNheight, (XtArgVal)(IupGetInt2(ih, "_IUPMOT_FS_SIZE") - (2*border+caption)), 
+                      NULL);
+
+          /* layout will be updated in motDialogConfigureNotify */
+          if (visible)
+            XtMapWidget(ih->handle);
+
+          /* remove auxiliar attributes */
+          iupAttribSetStr(ih, "_IUPMOT_FS_X", NULL);
+          iupAttribSetStr(ih, "_IUPMOT_FS_Y", NULL);
+          iupAttribSetStr(ih, "_IUPMOT_FS_SIZE", NULL);
+          iupAttribSetStr(ih, "_IUPMOT_FS_DECOR", NULL);
+        }
+
+        /* remove auxiliar attributes */
+        iupAttribSetStr(ih, "_IUPMOT_FS_MAXBOX", NULL);
+        iupAttribSetStr(ih, "_IUPMOT_FS_MINBOX", NULL);
+        iupAttribSetStr(ih, "_IUPMOT_FS_MENUBOX",NULL);
+        iupAttribSetStr(ih, "_IUPMOT_FS_RESIZE", NULL);
+        iupAttribSetStr(ih, "_IUPMOT_FS_BORDER", NULL);
+        iupAttribSetStr(ih, "_IUPMOT_FS_TITLE",  NULL);
+      }
+    }
+  }
+  return 1;
+}
+
+static int motDialogSetIconAttrib(Ihandle* ih, const char *value)
+{
+  if (!value)
+    XtVaSetValues(ih->handle, XmNiconPixmap, NULL, NULL);
+  else
+  {
+    Pixmap icon = (Pixmap)iupImageGetIcon(value);
+    Pixmap icon_mask = (Pixmap)iupImageGetMask(value);
+    if (icon)
+      XtVaSetValues(ih->handle, XmNiconPixmap, icon, NULL);
+    if (icon_mask)
+      XtVaSetValues(ih->handle, XmNiconMask, icon, NULL);
+  }
+  return 1;
+}
+
+/****************************************************************
+                     Callbacks and Events
+****************************************************************/
+
+
+static void motDialogCBclose(Widget w, XtPointer client_data, XtPointer call_data)
+{
+  Icallback cb;
+  Ihandle *ih = (Ihandle*)client_data;
+  if (!ih) return;
+  (void)call_data;
+  (void)w;
+
+  /* even when ACTIVE=NO the dialog gets this event */
+  if (!iupdrvIsActive(ih))
+    return;
+
+  cb = IupGetCallback(ih, "CLOSE_CB");
+  if (cb)
+  {
+    int ret = cb(ih);
+    if (ret == IUP_IGNORE)
+      return;
+    if (ret == IUP_CLOSE)
+      IupExitLoop();
+  }
+
+  IupHide(ih); /* default: close the window */
+}
+
+static void motDialogConfigureNotify(Widget w, XEvent *evt, String* s, Cardinal *card)
+{
+  IFnii cb;
+  int border, caption, menu;
+  XConfigureEvent *cevent = (XConfigureEvent *)evt;
+  Ihandle* ih;
+  (void)s;
+  (void)card;
+
+  XtVaGetValues(w, XmNuserData, &ih, NULL);
+  if (!ih) return;
+
+  if (ih->data->menu && ih->data->menu->handle)
+  {
+    XtVaSetValues(ih->data->menu->handle,
+      XmNwidth, (XtArgVal)(cevent->width),
+      NULL);
+  }
+
+  if (ih->data->ignore_resize) return; 
+
+  iupdrvDialogGetDecoration(ih, &border, &caption, &menu);
+
+  /* update dialog size */
+  ih->currentwidth = cevent->width + 2*border;
+  ih->currentheight = cevent->height + 2*border + caption; /* menu is inside the dialog_manager */
+
+  cb = (IFnii)IupGetCallback(ih, "RESIZE_CB");
+  if (!cb || cb(ih, cevent->width, cevent->height - menu)!=IUP_IGNORE)  /* width and height here are for the client area */
+  {
+    ih->data->ignore_resize = 1;
+    IupRefresh(ih);
+    ih->data->ignore_resize = 0;
+  }
+}
+
+static void motDialogCBStructureNotifyEvent(Widget w, XtPointer data, XEvent *evt, Boolean *cont)
+{
+  Ihandle *ih = (Ihandle*)data;
+  int state = -1;
+  (void)cont;
+  (void)w;
+
+  switch(evt->type)
+  {
+    case MapNotify:
+    {
+      if (ih->data->show_state == IUP_MINIMIZE) /* it is a RESTORE. */
+        state = IUP_RESTORE;
+      break;
+    }
+    case UnmapNotify:
+    {
+      if (ih->data->show_state != IUP_HIDE) /* it is a MINIMIZE. */
+        state = IUP_MINIMIZE;
+      break;
+    }
+  }
+
+  if (state < 0)
+    return;
+
+  if (ih->data->show_state != state)
+  {
+    IFni cb;
+    ih->data->show_state = state;
+
+    cb = (IFni)IupGetCallback(ih, "SHOW_CB");
+    if (cb && cb(ih, state) == IUP_CLOSE) 
+      IupExitLoop();
+  }
+}
+
+static void motDialogDestroyCallback(Widget w, Ihandle *ih, XtPointer call_data)
+{
+  /* If the IUP dialog was not destroyed, destroy it here. */
+  if (iupObjectCheck(ih))
+    IupDestroy(ih);
+
+  /* this callback is usefull to destroy children dialogs when the parent is destroyed. */
+  /* The application is responsable for destroying the children before this happen.     */
+  (void)w;
+  (void)call_data;
+}
+
+
+/****************************************************************
+                     Idialog
+****************************************************************/
+
+/* replace the common dialog SetChildrenPosition method because of 
+   the menu that it is inside the dialog. */
+static void motDialogSetChildrenPositionMethod(Ihandle* ih, int x, int y)
+{
+  int menu_h = motDialogGetMenuSize(ih);
+  (void)x;
+  (void)y;
+
+  /* Child coordinates are relative to client left-top corner. */
+  iupBaseSetPosition(ih->firstchild, 0, menu_h);
+}
+
+static void* motDialogGetInnerNativeContainerHandleMethod(Ihandle* ih, Ihandle* child)
+{
+  (void)child;
+  return XtNameToWidget(ih->handle, "*dialog_manager");
+}
+
+static int motDialogMapMethod(Ihandle* ih)
+{
+  Widget dialog_manager;
+  InativeHandle* parent;
+  int mwm_decor = 0;
+  int num_args = 0;
+  Arg args[20];
+
+  if (iupAttribGetBoolean(ih, "DIALOGFRAME")) 
+  {
+    iupAttribSetStr(ih, "RESIZE", "NO");
+    iupAttribSetStr(ih, "MAXBOX", "NO");
+    iupAttribSetStr(ih, "MINBOX", "NO");
+  }
+
+  /****************************/
+  /* Create the dialog shell  */
+  /****************************/
+
+  if (iupAttribGet(ih, "TITLE"))
+      mwm_decor |= MWM_DECOR_TITLE;
+  if (iupAttribGetBoolean(ih, "MENUBOX"))
+      mwm_decor |= MWM_DECOR_MENU;
+  if (iupAttribGetBoolean(ih, "MINBOX"))
+      mwm_decor |= MWM_DECOR_MINIMIZE;
+  if (iupAttribGetBoolean(ih, "MAXBOX"))
+      mwm_decor |= MWM_DECOR_MAXIMIZE;
+  if (iupAttribGetBoolean(ih, "RESIZE"))
+      mwm_decor |= MWM_DECOR_RESIZEH;
+  if (iupAttribGetBoolean(ih, "BORDER"))
+      mwm_decor |= MWM_DECOR_BORDER;
+
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* so XtRealizeWidget will not show the dialog */
+  iupmotSetArg(args, num_args, XmNdeleteResponse, XmDO_NOTHING);
+  iupmotSetArg(args, num_args, XmNallowShellResize, True); /* Used so the BulletinBoard can control the shell size */
+  iupmotSetArg(args, num_args, XmNtitle, "");
+  iupmotSetArg(args, num_args, XmNvisual, iupmot_visual);
+  
+  if (iupmotColorMap()) 
+    iupmotSetArg(args, num_args, XmNcolormap, iupmotColorMap());
+
+  if (mwm_decor != 0x7E) 
+    iupmotSetArg(args, num_args, XmNmwmDecorations, mwm_decor);
+
+  if (iupAttribGetBoolean(ih, "SAVEUNDER"))
+    iupmotSetArg(args, num_args, XmNsaveUnder, True);
+
+  parent = iupDialogGetNativeParent(ih);
+  if (parent)
+    ih->handle = XtCreatePopupShell(NULL, topLevelShellWidgetClass, (Widget)parent, args, num_args);
+  else
+    ih->handle = XtAppCreateShell(NULL, "dialog", topLevelShellWidgetClass, iupmot_display, args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  XmAddWMProtocolCallback(ih->handle, iupmot_wm_deletewindow, motDialogCBclose, (XtPointer)ih);
+
+  XtAddEventHandler(ih->handle, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent,      (XtPointer)ih);
+  XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, StructureNotifyMask, False, (XtEventHandler)motDialogCBStructureNotifyEvent, (XtPointer)ih);
+
+  XtAddCallback(ih->handle, XmNdestroyCallback, (XtCallbackProc)motDialogDestroyCallback, (XtPointer)ih);
+
+  /*****************************/
+  /* Create the dialog manager */
+  /*****************************/
+
+  dialog_manager = XtVaCreateManagedWidget(
+              "dialog_manager",
+              xmBulletinBoardWidgetClass,
+              ih->handle,
+              XmNmarginWidth, 0,
+              XmNmarginHeight, 0,
+              XmNwidth, 100,     /* set this to avoid size calculation problems */
+              XmNheight, 100,
+              XmNborderWidth, 0,
+              XmNshadowThickness, 0,
+              XmNnoResize, iupAttribGetBoolean(ih, "RESIZE")? False: True,
+              XmNresizePolicy, XmRESIZE_NONE, /* no automatic resize of children */
+              XmNuserData, ih, /* used only in motDialogConfigureNotify                   */
+              XmNnavigationType, XmTAB_GROUP,
+              NULL);
+
+  XtOverrideTranslations(dialog_manager, XtParseTranslationTable("<Configure>: iupDialogConfigure()"));
+  XtAddCallback(dialog_manager, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+  XtAddEventHandler(dialog_manager, KeyPressMask, False,(XtEventHandler)iupmotKeyPressEvent, (XtPointer)ih);
+
+  /* initialize the widget */
+  XtRealizeWidget(ih->handle);
+
+  /* child dialogs must be always on top of the parent */
+  if (parent)
+    XSetTransientForHint(iupmot_display, XtWindow(ih->handle), XtWindow(parent));
+
+  if (mwm_decor != 0x7E)  /* some decoration was changed */
+    motDialogSetWindowManagerStyle(ih);
+
+  /* Ignore VISIBLE before mapping */
+  iupAttribSetStr(ih, "VISIBLE", NULL);
+
+  if (IupGetGlobal("_IUP_RESET_DLGBGCOLOR"))
+  {
+    iupmotSetGlobalColorAttrib(dialog_manager, XmNbackground, "DLGBGCOLOR");
+    iupmotSetGlobalColorAttrib(dialog_manager, XmNforeground, "DLGFGCOLOR");
+    IupSetGlobal("_IUP_RESET_DLGBGCOLOR", NULL);
+  }
+
+  return IUP_NOERROR;
+}
+
+static void motDialogUnMapMethod(Ihandle* ih)
+{
+  Widget dialog_manager;
+  if (ih->data->menu) 
+  {
+    ih->data->menu->handle = NULL; /* the dialog will destroy the native menu */
+    IupDestroy(ih->data->menu);  
+  }
+
+  dialog_manager = XtNameToWidget(ih->handle, "*dialog_manager");
+  XtVaSetValues(dialog_manager, XmNuserData, NULL, NULL);
+
+  XtRemoveEventHandler(ih->handle, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent, (XtPointer)ih);
+  XtRemoveEventHandler(ih->handle, KeyPressMask, False, (XtEventHandler)iupmotKeyPressEvent, (XtPointer)ih);
+  XtRemoveEventHandler(ih->handle, StructureNotifyMask, False, (XtEventHandler)motDialogCBStructureNotifyEvent, (XtPointer)ih);
+  XtRemoveCallback(ih->handle, XmNdestroyCallback, (XtCallbackProc)motDialogDestroyCallback, (XtPointer)ih);
+
+  XtRemoveEventHandler(dialog_manager, KeyPressMask, False, (XtEventHandler)iupmotKeyPressEvent, (XtPointer)ih);
+  XtRemoveCallback(dialog_manager, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+  
+  iupdrvBaseUnMapMethod(ih);
+}
+
+static void motDialogLayoutUpdateMethod(Ihandle *ih)
+{
+  int border, caption, menu;
+
+  if (ih->data->ignore_resize ||
+      iupAttribGet(ih, "_IUPMOT_FS_STYLE"))
+    return;
+
+  /* for dialogs the position is not updated here */
+  ih->data->ignore_resize = 1;
+
+  iupdrvDialogGetDecoration(ih, &border, &caption, &menu);
+
+  if (!iupAttribGetBoolean(ih, "RESIZE"))
+  {
+    int width = ih->currentwidth - 2*border;
+    int height = ih->currentheight - 2*border - caption;
+    XtVaSetValues(ih->handle,
+      XmNwidth, width,
+      XmNheight, height,
+      XmNminWidth, width, 
+      XmNminHeight, height, 
+      XmNmaxWidth, width, 
+      XmNmaxHeight, height, 
+      NULL);
+  }
+  else
+  {
+    XtVaSetValues(ih->handle,
+      XmNwidth, (XtArgVal)(ih->currentwidth - 2*border),     /* excluding the border */
+      XmNheight, (XtArgVal)(ih->currentheight - 2*border - caption),
+      NULL);
+  }
+
+  ih->data->ignore_resize = 0;
+}
+
+/***************************************************************/
+
+void iupdrvDialogInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class methods */
+  ic->Map = motDialogMapMethod;
+  ic->UnMap = motDialogUnMapMethod;
+  ic->LayoutUpdate = motDialogLayoutUpdateMethod;
+  ic->SetChildrenPosition = motDialogSetChildrenPositionMethod;
+  ic->GetInnerNativeContainerHandle = motDialogGetInnerNativeContainerHandleMethod;
+
+  if (!iupmot_wm_deletewindow)
+  {
+    /* Set up a translation table that captures "Resize" events
+      (also called ConfigureNotify or Configure events). */
+    XtActionsRec rec = {"iupDialogConfigure", motDialogConfigureNotify};
+    XtAppAddActions(iupmot_appcontext, &rec, 1);
+
+    /* register atom to intercept the close button in the window frame */
+    iupmot_wm_deletewindow = XmInternAtom(iupmot_display, "WM_DELETE_WINDOW", False);
+  }
+
+  /* Driver Dependent Attribute functions */
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, motDialogSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+
+  /* Overwrite Visual */
+  iupClassRegisterAttribute(ic, "X", motDialogGetXAttrib, NULL, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_READONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "Y", motDialogGetYAttrib, NULL, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_READONLY|IUPAF_NO_INHERIT);
+
+  /* Base Container */
+  iupClassRegisterAttribute(ic, "CLIENTSIZE", motDialogGetClientSizeAttrib, NULL, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_READONLY|IUPAF_NO_INHERIT);
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "TITLE", motDialogGetTitleAttrib, motDialogSetTitleAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+
+  /* IupDialog only */
+  iupClassRegisterAttribute(ic, "BACKGROUND", NULL, motDialogSetBackgroundAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "ICON", NULL, motDialogSetIconAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "FULLSCREEN", NULL, motDialogSetFullScreenAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "MINSIZE", NULL, motDialogSetMinSizeAttrib, IUPAF_SAMEASSYSTEM, "1x1", IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "MAXSIZE", NULL, motDialogSetMaxSizeAttrib, IUPAF_SAMEASSYSTEM, "65535x65535", IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SAVEUNDER", NULL, NULL, "YES", NULL, IUPAF_NO_INHERIT);
+
+  /* IupDialog X Only */
+  iupClassRegisterAttribute(ic, "XWINDOW", iupmotGetXWindowAttrib, NULL, NULL, NULL, IUPAF_NO_INHERIT|IUPAF_NO_STRING);
+}
diff --git a/iup/src/mot/iupmot_drv.h b/iup/src/mot/iupmot_drv.h
new file mode 100755
index 0000000..8a536ef
--- /dev/null
+++ b/iup/src/mot/iupmot_drv.h
@@ -0,0 +1,75 @@
+/** \file
+ * \brief Motif Driver 
+ *
+ * See Copyright Notice in "iup.h"
+ */
+ 
+#ifndef __IUPMOT_DRV_H 
+#define __IUPMOT_DRV_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* global variables, declared in iupmot_open.c */
+extern Widget         iupmot_appshell;         
+extern Display*       iupmot_display;          
+extern int            iupmot_screen;           
+extern XtAppContext   iupmot_appcontext;       
+extern Visual*        iupmot_visual;
+extern Atom           iupmot_wm_deletewindow;
+
+/* dialog */
+void iupmotDialogSetVisual(Ihandle* ih, void* visual);
+void iupmotDialogResetVisual(Ihandle* ih);
+
+/* focus */
+void iupmotFocusChangeEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont);
+
+/* key */
+void iupmotCanvasKeyReleaseEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont);
+void iupmotKeyPressEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont);
+KeySym iupmotKeyCharToKeySym(char c);
+void iupmotButtonKeySetStatus(unsigned int state, unsigned int but, char* status, int doubleclick);
+void iupmotKeyEncode(int key, unsigned int *keyval, unsigned int *state);
+
+/* font */
+char* iupmotGetFontListAttrib(Ihandle *ih);
+XmFontList iupmotGetFontList(const char* foundry, const char* value);
+char* iupmotFindFontList(XmFontList fontlist);
+char* iupmotGetFontStructAttrib(Ihandle *ih);
+char* iupmotGetFontIdAttrib(Ihandle *ih);
+
+/* tips */
+/* called from Enter/Leave events to check if a TIP is present. */
+void iupmotTipEnterNotify(Ihandle* ih);
+void iupmotTipLeaveNotify(void);
+void iupmotTipsFinish(void);
+
+/* common */
+void iupmotPointerMotionEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont);
+void iupmotButtonPressReleaseEvent(Widget w, Ihandle* ih, XEvent* evt, Boolean* cont);
+void iupmotEnterLeaveWindowEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont);
+void iupmotHelpCallback(Widget w, Ihandle *ih, XtPointer call_data);
+void iupmotSetString(Widget w, const char *resource, const char* value);
+char* iupmotConvertString(XmString str);
+void iupmotSetMnemonicTitle(Ihandle *ih, const char* value);
+void iupmotDisableDragSource(Widget w);
+void iupmotSetPixmap(Ihandle* ih, const char* name, const char* prop, int make_inactive);
+void iupmotSetGlobalColorAttrib(Widget w, const char* xmname, const char* name);
+void iupmotSetBgColor(Widget w, Pixel color);
+char* iupmotGetBgColorAttrib(Ihandle* ih);
+
+void iupmotGetWindowSize(Ihandle *ih, int *width, int *height);
+
+char* iupmotGetXWindowAttrib(Ihandle *ih);
+
+#define iupmotSetArg(_a, _i, _n, _d) ((_a)[(_i)].name = (_n), (_a)[(_i)].value = (XtArgVal)(_d), (_i)++)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/iup/src/mot/iupmot_filedlg.c b/iup/src/mot/iupmot_filedlg.c
new file mode 100755
index 0000000..768dd2b
--- /dev/null
+++ b/iup/src/mot/iupmot_filedlg.c
@@ -0,0 +1,578 @@
+/** \file
+ * \brief Motif IupFileDlg pre-defined dialog
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <Xm/Xm.h>
+#include <Xm/MwmUtil.h>
+#include <Xm/FileSB.h>
+#include <Xm/Protocols.h>
+#include <Xm/SelectioB.h>
+#include <Xm/MessageB.h>
+#include <Xm/DrawingA.h>
+#include <Xm/PushB.h>
+#include <Xm/Frame.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_drvinfo.h"
+#include "iup_dialog.h"
+#include "iup_strmessage.h"
+#include "iup_drvinfo.h"
+
+#include "iupmot_drv.h"
+
+
+enum {IUP_DIALOGOPEN, IUP_DIALOGSAVE, IUP_DIALOGDIR};
+
+static void motFileDlgAskUserCallback(Widget w, int* ret_code, XmSelectionBoxCallbackStruct* cbs)
+{
+  if (cbs->reason == XmCR_OK)
+    *ret_code = 1;
+  else
+    *ret_code = -1;
+  XtDestroyWidget(XtParent(w));
+}
+
+static int motFileDlgAskUser(Widget parent, const char* message)
+{
+  Widget questionbox;
+  Arg args[3];
+  int ret_code = 0;
+  XmString title;
+
+  XtSetArg(args[0], XmNautoUnmanage, False);
+  XtSetArg(args[1], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL);
+  XtSetArg(args[2], XmNnoResize, True);
+  questionbox = XmCreateQuestionDialog(parent, "filedlg_question", args, 3);
+  iupmotSetString(questionbox, XmNmessageString, message);
+  XtVaGetValues(parent, XmNdialogTitle, &title, NULL);
+  XtVaSetValues(questionbox, XmNdialogTitle, title, NULL);
+
+  XtAddCallback(questionbox, XmNokCallback, (XtCallbackProc)motFileDlgAskUserCallback, (XtPointer)&ret_code);
+  XtAddCallback(questionbox, XmNcancelCallback, (XtCallbackProc)motFileDlgAskUserCallback, (XtPointer)&ret_code);
+  XtUnmanageChild(XmMessageBoxGetChild(questionbox, XmDIALOG_HELP_BUTTON));
+  XtManageChild(questionbox);
+
+  while (ret_code == 0)
+    XtAppProcessEvent(iupmot_appcontext, XtIMAll);
+
+  XtUnmanageChild(questionbox);
+
+  if (ret_code == 1)
+    return 1;
+  else
+    return 0;
+}
+
+static int motFileDlgCheckValue(Ihandle* ih, Widget w)
+{
+  char* value = iupAttribGet(ih, "VALUE");
+  int dialogtype = iupAttribGetInt(ih, "_IUPDLG_DIALOGTYPE");
+
+  if (dialogtype == IUP_DIALOGDIR)
+  {
+    if (!iupdrvIsDirectory(value))               /* if does not exist or not a directory */
+    {
+      iupStrMessageShowError(ih, "IUP_INVALIDDIR");
+      return 0;
+    }
+  }
+  else
+  {
+    if (iupdrvIsDirectory(value))  /* selected a directory */
+    {
+      iupStrMessageShowError(ih, "IUP_INVALIDDIR");
+      return 0;
+    }
+    else if (!iupdrvIsFile(value))      /* new file */
+    {
+      value = iupAttribGet(ih, "ALLOWNEW");
+      if (!value)
+      {
+        if (dialogtype == IUP_DIALOGSAVE)
+          value = "YES";
+        else
+          value = "NO";
+      }
+
+      if (!iupStrBoolean(value))
+      {
+        iupStrMessageShowError(ih, "IUP_FILENOTEXIST");
+        return 0;
+      }
+    }
+    else if (dialogtype == IUP_DIALOGSAVE && !iupAttribGetInt(ih, "NOOVERWRITEPROMPT"))
+    {
+      if (!motFileDlgAskUser(w, iupStrMessageGet("IUP_FILEOVERWRITE")))
+        return 0;
+    }
+  }
+
+  return 1;
+}
+
+static void motFileDlgCBclose(Widget w, XtPointer client_data, XtPointer call_data)
+{
+  Ihandle *ih = (Ihandle*)client_data;
+  if (!ih) return;
+  (void)call_data;
+  (void)w;
+  iupAttribSetStr(ih, "VALUE", NULL);
+  iupAttribSetStr(ih, "STATUS", "-1");
+  iupAttribSetStr(ih, "_IUP_WM_DELETE", "1");
+}
+
+static void motFileDlgCallback(Widget w, Ihandle* ih, XmFileSelectionBoxCallbackStruct* call_data)
+{
+  (void)w;
+  if (call_data->reason == XmCR_OK)
+  {
+    int dialogtype = iupAttribGetInt(ih, "_IUPDLG_DIALOGTYPE");
+    char* filename;
+    XmStringGetLtoR(call_data->value, XmSTRING_DEFAULT_CHARSET, &filename);
+    iupAttribStoreStr(ih, "VALUE", filename);
+    XtFree(filename);
+
+    if (!motFileDlgCheckValue(ih, w))
+      return;
+
+    if (dialogtype == IUP_DIALOGDIR)
+    {
+      iupAttribSetStr(ih, "STATUS", "0");
+      iupAttribSetStr(ih, "FILEEXIST", NULL);
+    }
+    else
+    {
+      IFnss file_cb = (IFnss)IupGetCallback(ih, "FILE_CB");
+      if (file_cb && file_cb(ih, iupAttribGet(ih, "VALUE"), "OK") == IUP_IGNORE)
+        return;
+
+      if (iupdrvIsFile(iupAttribGet(ih, "VALUE")))  /* check if file exists */
+      {
+        iupAttribSetStr(ih, "FILEEXIST", "YES");
+        iupAttribSetStr(ih, "STATUS", "0");
+      }
+      else
+      {
+        iupAttribSetStr(ih, "FILEEXIST", "NO");
+        iupAttribSetStr(ih, "STATUS", "1");
+      }
+    }
+
+    if (!iupAttribGetBoolean(ih, "NOCHANGEDIR"))  /* do change the current directory */
+    {
+      /* XmFileSelection does not change the current directory */
+      XmString xm_dir;
+      char* dir;
+      XtVaGetValues(w, XmNdirectory, &xm_dir, NULL);
+      XmStringGetLtoR(xm_dir, XmSTRING_DEFAULT_CHARSET, &dir);
+      iupdrvSetCurrentDirectory(dir);
+      XtFree(dir);
+    }
+  }
+  else if (call_data->reason == XmCR_CANCEL)
+  {
+    iupAttribSetStr(ih, "VALUE", NULL);
+    iupAttribSetStr(ih, "FILEEXIST", NULL);
+    iupAttribSetStr(ih, "STATUS", "-1");
+  }
+}
+
+static void motFileDlgHelpCallback(Widget w, XtPointer client_data, XtPointer call_data)
+{
+  Ihandle *ih = (Ihandle*)client_data;
+  Icallback cb = IupGetCallback(ih, "HELP_CB");
+  if (cb && cb(ih) == IUP_CLOSE)
+  {
+    iupAttribSetStr(ih, "VALUE", NULL);
+    iupAttribSetStr(ih, "FILEEXIST", NULL);
+    iupAttribSetStr(ih, "STATUS", "-1");
+  }
+
+  (void)call_data;
+  (void)w;
+}
+
+typedef struct _ImotPromt
+{
+  XmString xm_dir;
+  int ret_code;
+} ImotPromt;
+
+static void motFileDlgPromptCallback(Widget w, ImotPromt* prompt, XmSelectionBoxCallbackStruct* cbs)
+{
+  if (cbs->reason == XmCR_OK)
+    prompt->xm_dir = XmStringCopy(cbs->value);
+
+  prompt->ret_code = 1;
+  XtDestroyWidget(XtParent(w));
+}
+
+static XmString motFileDlgPrompt(Widget parent, const char* message)
+{
+  Widget promptbox;
+  Arg args[2];
+  ImotPromt prompt;
+  XmString title;
+
+  XtSetArg(args[0], XmNautoUnmanage, False);
+  XtSetArg(args[1], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL);
+  promptbox = XmCreatePromptDialog(parent, "filedlg_prompt", args, 2);
+  iupmotSetString(promptbox, XmNselectionLabelString, message);
+  XtVaGetValues(parent, XmNdialogTitle, &title, NULL);
+  XtVaSetValues(promptbox, XmNdialogTitle, title, NULL);
+
+  prompt.ret_code = 0;
+  prompt.xm_dir = NULL;
+
+  XtAddCallback(promptbox, XmNokCallback, (XtCallbackProc)motFileDlgPromptCallback, (XtPointer)&prompt);
+  XtAddCallback(promptbox, XmNcancelCallback, (XtCallbackProc)motFileDlgPromptCallback, (XtPointer)&prompt);
+  XtUnmanageChild(XmSelectionBoxGetChild(promptbox, XmDIALOG_HELP_BUTTON));
+  XtManageChild(promptbox);
+
+  while (prompt.ret_code == 0)
+    XtAppProcessEvent(iupmot_appcontext, XtIMAll);
+
+  XtUnmanageChild(promptbox);
+
+  return prompt.xm_dir;
+}
+
+static void motFileDlgNewFolderCallback(Widget w, Widget filebox, XtPointer call_data)
+{
+  XmString xm_new_dir = motFileDlgPrompt(filebox, iupStrMessageGet("IUP_NAMENEWFOLDER"));
+  if (xm_new_dir)
+  {
+    XmString xm_dir;
+    XtVaGetValues(filebox, XmNdirectory, &xm_dir, NULL);
+    xm_dir = XmStringConcat(xm_dir, xm_new_dir);
+
+    {
+      char* dir;
+      XmStringGetLtoR(xm_dir, XmSTRING_DEFAULT_CHARSET, &dir);
+      iupdrvMakeDirectory(dir);
+      XtFree(dir);
+    }
+
+    XtVaSetValues(filebox, XmNdirectory, xm_dir, NULL);
+
+    XmStringFree(xm_dir);
+    XmStringFree(xm_new_dir);
+  }
+
+  (void)call_data;
+  (void)w;
+}
+
+static void motFileDlgPreviewCanvasResizeCallback(Widget w, Ihandle *ih, XtPointer call_data)
+{
+  Dimension width, height;
+  XtVaGetValues(w, XmNwidth, &width,
+                   XmNheight, &height,
+                   NULL);
+
+  iupAttribSetInt(ih, "PREVIEWWIDTH", width);
+  iupAttribSetInt(ih, "PREVIEWHEIGHT", height);
+
+  (void)call_data;
+}
+
+static void motFileDlgUpdatePreviewGLCanvas(Ihandle* ih)
+{
+  Ihandle* glcanvas = IupGetAttributeHandle(ih, "PREVIEWGLCANVAS");
+  if (glcanvas)
+  {
+    iupAttribSetStr(glcanvas, "XWINDOW", iupAttribGet(ih, "XWINDOW"));
+    glcanvas->iclass->Map(glcanvas);
+  }
+}
+
+static void motFileDlgPreviewCanvasInit(Ihandle *ih, Widget w)
+{
+  XSetWindowAttributes attrs;
+  GC gc = XCreateGC(iupmot_display, XtWindow(w), 0, NULL);
+  iupAttribSetStr(ih, "PREVIEWDC", (char*)gc);
+  iupAttribSetStr(ih, "WID", (char*)w);
+
+  iupAttribSetStr(ih, "XWINDOW", (char*)XtWindow(w));
+  iupAttribSetStr(ih, "XDISPLAY", (char*)iupmot_display);
+  motFileDlgUpdatePreviewGLCanvas(ih);
+
+  attrs.bit_gravity = ForgetGravity; /* For the DrawingArea widget gets Expose events when you resize it to be smaller. */
+  attrs.background_pixmap = None;
+  XChangeWindowAttributes(iupmot_display, XtWindow(w), CWBitGravity|CWBackPixmap, &attrs);
+}
+
+static void motFileDlgPreviewCanvasExposeCallback(Widget w, Ihandle *ih, XtPointer call_data)
+{
+  Widget filebox = (Widget)iupAttribGet(ih, "_IUPDLG_FILEBOX");
+  char* filename;
+  XmString xm_file;
+  IFnss cb;
+
+  if (!iupAttribGet(ih, "PREVIEWDC"))
+    motFileDlgPreviewCanvasInit(ih, w);
+
+  XtVaGetValues(filebox, XmNdirSpec, &xm_file, NULL);
+  XmStringGetLtoR(xm_file, XmSTRING_DEFAULT_CHARSET, &filename);
+
+  cb = (IFnss)IupGetCallback(ih, "FILE_CB");
+  if (iupdrvIsFile(filename))
+    cb(ih, filename, "PAINT");
+  else
+    cb(ih, NULL, "PAINT");
+
+  XtFree(filename);
+  (void)call_data;
+  (void)w;
+}
+
+static void motFileDlgBrowseSelectionCallback(Widget w, Ihandle* ih, XmListCallbackStruct* list_data)
+{
+  char* filename;
+
+  XmStringGetLtoR(list_data->item, XmSTRING_DEFAULT_CHARSET, &filename);
+
+  if (iupdrvIsFile(filename))
+  {
+    IFnss cb = (IFnss)IupGetCallback(ih, "FILE_CB");
+    cb(ih, filename, "SELECT");
+  }
+
+  XtFree(filename);
+  (void)w;
+}
+
+static int motFileDlgPopup(Ihandle* ih, int x, int y)
+{
+  InativeHandle* parent = iupDialogGetNativeParent(ih);
+  Widget filebox, dialog;
+  int dialogtype, style = XmDIALOG_FULL_APPLICATION_MODAL;
+  IFnss file_cb = NULL;
+  Widget preview_canvas = NULL;
+  char* value;
+
+  iupAttribSetInt(ih, "_IUPDLG_X", x);   /* used in iupDialogUpdatePosition */
+  iupAttribSetInt(ih, "_IUPDLG_Y", y);
+
+  value = iupAttribGetStr(ih, "DIALOGTYPE");
+  if (iupStrEqualNoCase(value, "SAVE"))
+    dialogtype = IUP_DIALOGSAVE;
+  else if (iupStrEqualNoCase(value, "DIR"))
+    dialogtype = IUP_DIALOGDIR;
+  else
+    dialogtype = IUP_DIALOGOPEN;
+  iupAttribSetInt(ih, "_IUPDLG_DIALOGTYPE", dialogtype);
+
+  if (parent)
+  {
+    filebox = XmCreateFileSelectionDialog(parent, "filedialog", NULL, 0);
+    dialog = XtParent(filebox);
+  }
+  else
+  {
+    dialog = XtAppCreateShell(NULL, "filedialog", topLevelShellWidgetClass, iupmot_display, NULL, 0);
+    filebox = XmCreateFileSelectionBox(dialog, "filebox", NULL, 0);
+    style = XmDIALOG_MODELESS;
+    XtVaSetValues(dialog,
+      XmNmwmInputMode, MWM_INPUT_FULL_APPLICATION_MODAL,
+      XmNmappedWhenManaged, False,
+      XmNsaveUnder, True,
+      NULL);
+  }
+  if (!filebox)
+    return IUP_NOERROR;
+
+  if (!iupAttribGetBoolean(ih, "SHOWHIDDEN"))
+    XtVaSetValues(filebox, XmNfileFilterStyle, XmFILTER_HIDDEN_FILES, NULL);
+
+  value = iupAttribGet(ih, "TITLE");
+  if (!value)
+  {
+    if (dialogtype == IUP_DIALOGSAVE)
+      value = "IUP_SAVEAS";
+    else if (dialogtype == IUP_DIALOGOPEN)
+      value = "IUP_OPEN";
+    else
+      value = "IUP_SELECTDIR";
+    iupAttribSetStr(ih, "TITLE", iupStrMessageGet(value));
+  }
+  iupmotSetString(filebox, XmNdialogTitle, value);
+
+  XtVaSetValues(filebox,
+                XmNdialogStyle, style,
+                XmNautoUnmanage, False,
+                NULL);
+
+  if (dialogtype == IUP_DIALOGDIR)
+    XtVaSetValues(filebox, XmNfileTypeMask, XmFILE_DIRECTORY, NULL);
+
+  /* just check for the path inside FILE */
+  value = iupAttribGet(ih, "FILE");
+  if (value && value[0] == '/')
+  {
+    char* dir = iupStrFileGetPath(value);
+    iupAttribStoreStr(ih, "DIRECTORY", dir);
+    free(dir);
+  }
+
+  /* set XmNdirectory before XmNpattern and before XmNdirSpec */
+
+  value = iupAttribGet(ih, "DIRECTORY");
+  if (value)
+    iupmotSetString(filebox, XmNdirectory, value);
+
+  value = iupAttribGet(ih, "FILTER");
+  if (value)
+  {
+    char *filter = value;
+    char *p = strchr(value, ';');
+    if (p) 
+    {
+      int size = p-value;
+      filter = (char*)malloc(size+1);
+      memcpy(filter, value, size);
+      filter[size] = 0;
+    }
+
+    iupmotSetString(filebox, XmNpattern, filter);
+
+    if (filter != value) 
+      free(filter);
+  }
+
+  value = iupAttribGet(ih, "FILE");
+  if (value)
+  {
+    char* file = value;
+
+    if (value[0] != '/')  /* if does not contains a full path, then add the directory */
+    {
+      char* cur_dir = NULL;
+      char* dir = iupAttribGet(ih, "DIRECTORY");
+      if (!dir)
+      {
+        cur_dir = iupdrvGetCurrentDirectory();
+        dir = cur_dir;
+      }
+
+      file = iupStrFileMakeFileName(dir, value);
+
+      if (cur_dir)
+        free(cur_dir);
+    }
+
+  /* clear value before setting. Do not know why we have to do this, 
+     but if not cleared it will fail to set the XmNdirSpec value. */
+    iupmotSetString(filebox, XmNdirSpec, "");
+    iupmotSetString(filebox, XmNdirSpec, file);
+
+    if (file != value)
+      free(file);
+  }
+
+  if (!IupGetCallback(ih, "HELP_CB"))
+    XtUnmanageChild(XmFileSelectionBoxGetChild(filebox, XmDIALOG_HELP_BUTTON));
+
+  XtAddCallback(filebox, XmNokCallback, (XtCallbackProc)motFileDlgCallback, (XtPointer)ih);
+  XtAddCallback(filebox, XmNcancelCallback, (XtCallbackProc)motFileDlgCallback, (XtPointer)ih);
+  XtAddCallback(filebox, XmNhelpCallback, (XtCallbackProc)motFileDlgHelpCallback, (XtPointer)ih);
+
+  if (dialogtype == IUP_DIALOGDIR)
+  {
+    Widget new_folder = XtVaCreateManagedWidget("new_folder", xmPushButtonWidgetClass, filebox, 
+                                                XmNlabelType, XmSTRING, 
+                                                NULL);
+    iupmotSetString(new_folder, XmNlabelString, iupStrMessageGet("IUP_CREATEFOLDER"));
+    XtAddCallback(new_folder, XmNactivateCallback, (XtCallbackProc)motFileDlgNewFolderCallback, (XtPointer)filebox);
+  }
+  else
+  {
+    file_cb = (IFnss)IupGetCallback(ih, "FILE_CB");
+    if (file_cb)
+    {
+      Widget file_list = XmFileSelectionBoxGetChild(filebox, XmDIALOG_LIST);
+      XtAddCallback(file_list, XmNbrowseSelectionCallback, (XtCallbackProc)motFileDlgBrowseSelectionCallback, (XtPointer)ih);
+
+      if (iupAttribGetBoolean(ih, "SHOWPREVIEW"))
+      {
+        Widget frame = XtVaCreateManagedWidget("preview_canvas", xmFrameWidgetClass, filebox, 
+                                                        XmNshadowType, XmSHADOW_ETCHED_IN,
+                                                        NULL);
+
+        preview_canvas = XtVaCreateManagedWidget("preview_canvas", xmDrawingAreaWidgetClass, frame, 
+                                                        XmNwidth, 180, 
+                                                        XmNheight, 150,
+                                                        XmNresizePolicy, XmRESIZE_GROW,
+                                                        NULL);
+
+        XtAddCallback(preview_canvas, XmNexposeCallback, (XtCallbackProc)motFileDlgPreviewCanvasExposeCallback, (XtPointer)ih);
+        XtAddCallback(preview_canvas, XmNresizeCallback, (XtCallbackProc)motFileDlgPreviewCanvasResizeCallback,  (XtPointer)ih);
+
+        iupAttribSetStr(ih, "_IUPDLG_FILEBOX", (char*)filebox);
+      }
+    }
+  }
+
+  XmAddWMProtocolCallback(dialog, iupmot_wm_deletewindow, motFileDlgCBclose, (XtPointer)ih);
+  XtManageChild(filebox);
+
+  XtRealizeWidget(dialog);
+  ih->handle = dialog;
+  iupDialogUpdatePosition(ih);
+  ih->handle = NULL;  /* reset handle */
+
+  if (file_cb)
+  {
+    if (preview_canvas)
+      motFileDlgPreviewCanvasInit(ih, preview_canvas);
+
+    file_cb(ih, NULL, "INIT");
+  }
+
+  if (style == XmDIALOG_MODELESS)
+    XtPopup(dialog, XtGrabExclusive);
+
+  /* while the user hasn't provided an answer, simulate main loop.
+  ** The answer changes as soon as the user selects one of the
+  ** buttons and the callback routine changes its value. */
+  iupAttribSetStr(ih, "STATUS", NULL);
+  while (iupAttribGet(ih, "STATUS") == NULL)
+    XtAppProcessEvent(iupmot_appcontext, XtIMAll);
+
+  if (file_cb)
+  {
+    if (preview_canvas)
+      XFreeGC(iupmot_display, (GC)iupAttribGet(ih, "PREVIEWDC"));
+
+    file_cb(ih, NULL, "FINISH");
+  }
+
+  if (!iupAttribGet(ih, "_IUP_WM_DELETE"))
+  {
+    XtUnmanageChild(filebox);
+
+    if (style == XmDIALOG_MODELESS)
+    {
+      XtPopdown(dialog);
+      XtDestroyWidget(dialog);
+    }
+  }
+
+  return IUP_NOERROR;
+}
+
+void iupdrvFileDlgInitClass(Iclass* ic)
+{
+  ic->DlgPopup = motFileDlgPopup;
+}
diff --git a/iup/src/mot/iupmot_focus.c b/iup/src/mot/iupmot_focus.c
new file mode 100755
index 0000000..5b09bd9
--- /dev/null
+++ b/iup/src/mot/iupmot_focus.c
@@ -0,0 +1,35 @@
+/** \file
+ * \brief Motif Focus
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+
+#include <stdio.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_focus.h"
+#include "iup_attrib.h"
+#include "iup_assert.h" 
+#include "iup_drv.h" 
+
+#include "iupmot_drv.h"
+
+void iupdrvSetFocus(Ihandle *ih)
+{
+  XmProcessTraversal(ih->handle, XmTRAVERSE_CURRENT);
+}
+
+void iupmotFocusChangeEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont)
+{
+  (void)w;
+  (void)cont;
+
+  if (evt->type == FocusIn)
+    iupCallGetFocusCb(ih);
+  else if (evt->type == FocusOut)
+    iupCallKillFocusCb(ih);
+}
diff --git a/iup/src/mot/iupmot_font.c b/iup/src/mot/iupmot_font.c
new file mode 100755
index 0000000..8da06dd
--- /dev/null
+++ b/iup/src/mot/iupmot_font.c
@@ -0,0 +1,443 @@
+/** \file
+ * \brief Motif Font mapping
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <Xm/Xm.h>
+#include <Xm/XmP.h>
+
+#include "iup.h"
+
+#include "iup_str.h"
+#include "iup_attrib.h"
+#include "iup_array.h"
+#include "iup_object.h"
+#include "iup_drv.h"
+#include "iup_drvfont.h"
+#include "iup_assert.h"
+
+#include "iupmot_drv.h"
+
+
+typedef struct _ImotFont 
+{
+  char standardfont[1024];
+  char xlfd[1024];  /* X-Windows Font Description */
+  XmFontList fontlist;  /* same as XmRenderTable */
+  XFontStruct *fontstruct;
+  int charwidth, charheight;
+} ImotFont;
+
+static Iarray* mot_fonts = NULL;
+
+static int motGetFontSize(char* font_name)
+{
+  int i = 0;
+  while (i < 8)
+  {
+    font_name = strchr(font_name, '-')+1;
+    i++;
+  }
+
+  *(strchr(font_name, '-')) = 0;
+  return atoi(font_name);
+}
+
+static XFontStruct* motLoadFont(const char* foundry, const char *typeface, int size, int bold, int italic, char *xlfd)
+{
+  XFontStruct* fontstruct;
+  char font_name[1024];
+  char **font_names_list;
+  char *weight, *slant;
+  int i, num_fonts, font_size, near_size;
+              
+  /* no underline or strikeout support */
+
+  if (iupStrEqualNoCase(typeface, "System"))
+    typeface = "fixed";
+
+  if (!foundry) foundry = "*";
+
+  if (iupStrEqualNoCase(typeface, "fixed"))
+    foundry = "misc";
+
+  if (bold)
+    weight = "bold";
+  else
+    weight = "medium";
+
+  if (italic)
+    slant = "i";
+  else
+    slant = "r";
+
+  sprintf(font_name,"-%s-%s-%s-%s-*-*-*-*-*-*-*-*-*-*", foundry, typeface, weight, slant);
+
+  font_names_list = XListFonts(iupmot_display, font_name, 32767, &num_fonts);
+  if (!num_fonts)
+  {
+    /* try changing 'i' to 'o', for italic */
+    if (italic)
+    {
+      slant = "o";
+      strstr(font_name, "-i-")[1] = 'o';
+      font_names_list = XListFonts(iupmot_display, font_name, 32767, &num_fonts);
+    }
+
+    if (!num_fonts)
+      return NULL;
+  }
+
+  if (size < 0) /* if in pixels convert to points */
+  {
+    double res = ((double)DisplayWidth(iupmot_display, iupmot_screen) / (double)DisplayWidthMM(iupmot_display, iupmot_screen)); /* pixels/mm */
+    /* 1 point = 1/72 inch     1 inch = 25.4 mm */
+    /* pixel = ((point/72)*25.4)*pixel/mm */
+    size = (int)((-size/res)*2.83464567 + 0.5); /* from pixels to points */
+  }
+
+  size *= 10; /* convert to deci-points */
+
+  near_size = -1000;
+  for (i=0; i<num_fonts; i++)
+  {
+    font_size = motGetFontSize(font_names_list[i]);
+
+    if (font_size == size)
+    {
+      near_size = font_size;
+      break;
+    }
+
+    if (abs(font_size-size) < abs(near_size-size))
+      near_size = font_size;
+  }
+
+  XFreeFontNames(font_names_list);
+
+  sprintf(font_name,"-%s-%s-%s-%s-*-*-*-%d-*-*-*-*-*-*", foundry, typeface, weight, slant, near_size);
+  fontstruct = XLoadQueryFont(iupmot_display, font_name);
+
+  if (fontstruct)
+    strcpy(xlfd, font_name); 
+
+  return fontstruct;
+}
+
+static XmFontList motFontCreateRenderTable(XFontStruct* fontstruct, int is_underline, int is_strikeout)
+{
+  XmFontList fontlist;
+  XmRendition rendition;
+  Arg args[10];
+  int num_args = 0;
+
+  iupmotSetArg(args, num_args, XmNfontType, XmFONT_IS_FONT);
+  iupmotSetArg(args, num_args, XmNfont, (XtPointer)fontstruct);
+  iupmotSetArg(args, num_args, XmNloadModel, XmLOAD_IMMEDIATE);
+
+  if (is_underline)
+    iupmotSetArg(args, num_args, XmNunderlineType, XmSINGLE_LINE);
+  else
+    iupmotSetArg(args, num_args, XmNunderlineType, XmNO_LINE);
+
+  if (is_strikeout)
+    iupmotSetArg(args, num_args, XmNstrikethruType, XmSINGLE_LINE);
+  else
+    iupmotSetArg(args, num_args, XmNstrikethruType, XmNO_LINE);
+
+  rendition = XmRenditionCreate(NULL, "", args, num_args);
+
+  fontlist = XmRenderTableAddRenditions(NULL, &rendition, 1, XmDUPLICATE);
+
+  XmRenditionFree(rendition);
+
+  return fontlist;
+}
+
+static int motFontCalcCharWidth(XFontStruct *fontstruct)
+{
+  if (fontstruct->per_char)
+  {
+    int i, all=0;
+    int first = fontstruct->min_char_or_byte2;
+    int last  = fontstruct->max_char_or_byte2;
+    if (first < 32)  first = 32;  /* space */
+    if (last  > 126) last  = 126; /* tilde */
+    for (i=first; i<=last; i++)
+      all += fontstruct->per_char[i].width;
+    return all/(last-first + 1);   /* average character width */
+  }
+  else
+    return fontstruct->max_bounds.width;
+}
+
+static ImotFont* motFindFont(const char* foundry, const char *standardfont)
+{
+  char xlfd[1024];
+  XFontStruct* fontstruct;
+  int i, count = iupArrayCount(mot_fonts);
+  int is_underline = 0, is_strikeout = 0;
+
+  ImotFont* fonts = (ImotFont*)iupArrayGetData(mot_fonts);
+
+  /* Check if the standardfont already exists in cache */
+  for (i = 0; i < count; i++)
+  {
+    if (iupStrEqualNoCase(standardfont, fonts[i].standardfont))
+      return &fonts[i];
+  }
+
+  /* not found, create a new one */
+  if (standardfont[0] == '-')
+  {
+    fontstruct = XLoadQueryFont(iupmot_display, standardfont);
+    if (!fontstruct) return NULL;
+    strcpy(xlfd, standardfont);
+  }
+  else
+  {
+    int size = 0,
+        is_bold = 0,
+        is_italic = 0;
+    char typeface[1024];
+    const char* mapped_name;
+
+    if (!iupFontParsePango(standardfont, typeface, &size, &is_bold, &is_italic, &is_underline, &is_strikeout))
+      return NULL;
+
+    mapped_name = iupFontGetXName(typeface);
+    if (mapped_name)
+      strcpy(typeface, mapped_name);
+
+    fontstruct = motLoadFont(foundry, typeface, size, is_bold, is_italic, xlfd);
+    if (!fontstruct) return NULL;
+  }
+
+  /* create room in the array */
+  fonts = (ImotFont*)iupArrayInc(mot_fonts);
+
+  strcpy(fonts[i].standardfont, standardfont);
+  strcpy(fonts[i].xlfd, xlfd);
+  fonts[i].fontstruct = fontstruct;
+  fonts[i].fontlist = motFontCreateRenderTable(fontstruct, is_underline, is_strikeout);
+  fonts[i].charwidth = motFontCalcCharWidth(fontstruct);
+  fonts[i].charheight = fontstruct->ascent + fontstruct->descent;
+
+  return &fonts[i];
+}
+
+char* iupdrvGetSystemFont(void)
+{
+  static char systemfont[200] = "";
+  ImotFont* motfont = NULL;
+  char* font = XGetDefault(iupmot_display, "Iup", "fontList");
+  if (font)
+    motfont = motFindFont(NULL, font);
+
+  if (!motfont)
+  {
+    font = "Fixed, 11";
+    motfont = motFindFont("misc", font);
+  }
+
+  strcpy(systemfont, font);
+  return systemfont;
+}
+
+char* iupmotFindFontList(XmFontList fontlist)
+{
+  int i, count = iupArrayCount(mot_fonts);
+  ImotFont* fonts = (ImotFont*)iupArrayGetData(mot_fonts);
+
+  /* Check if the standardfont already exists in cache */
+  for (i = 0; i < count; i++)
+  {
+    if (fontlist == fonts[i].fontlist)
+      return fonts[i].standardfont;
+  }
+
+  return NULL;
+}
+
+XmFontList iupmotGetFontList(const char* foundry, const char* value)
+{
+  ImotFont *motfont = motFindFont(foundry, value);
+  if (!motfont) 
+  {
+    iupERROR1("Failed to create Font: %s", value); 
+    return NULL;
+  }
+
+  return motfont->fontlist;
+}
+
+static ImotFont* motFontCreateNativeFont(Ihandle* ih, const char* value)
+{
+  ImotFont *motfont = motFindFont(iupAttribGet(ih, "FOUNDRY"), value);
+  if (!motfont) 
+  {
+    iupERROR1("Failed to create Font: %s", value); 
+    return NULL;
+  }
+
+  iupAttribSetStr(ih, "_IUPMOT_FONT", (char*)motfont);
+  iupAttribSetStr(ih, "XLFD", motfont->xlfd);
+  return motfont;
+}
+
+static ImotFont* motGetFont(Ihandle *ih)
+{
+  ImotFont* motfont = (ImotFont*)iupAttribGet(ih, "_IUPMOT_FONT");
+  if (!motfont)
+    motfont = motFontCreateNativeFont(ih, iupGetFontAttrib(ih));
+  return motfont;
+}
+
+char* iupmotGetFontListAttrib(Ihandle *ih)
+{
+  ImotFont* motfont = motGetFont(ih);
+  if (!motfont)
+    return NULL;
+  else
+    return (char*)motfont->fontlist;
+}
+
+char* iupmotGetFontStructAttrib(Ihandle *ih)
+{
+  ImotFont* motfont = motGetFont(ih);
+  if (!motfont)
+    return NULL;
+  else
+    return (char*)motfont->fontstruct;
+}
+
+char* iupmotGetFontIdAttrib(Ihandle *ih)
+{
+  ImotFont* motfont = motGetFont(ih);
+  if (!motfont)
+    return NULL;
+  else
+    return (char*)motfont->fontstruct->fid;
+}
+
+int iupdrvSetStandardFontAttrib(Ihandle* ih, const char* value)
+{
+  ImotFont *motfont = motFontCreateNativeFont(ih, value);
+  if (!motfont) 
+    return 1;
+
+  /* If FONT is changed, must update the SIZE attribute */
+  iupBaseUpdateSizeFromFont(ih);
+
+  /* FONT attribute must be able to be set before mapping, 
+    so the font is enable for size calculation. */
+  if (ih->handle && (ih->iclass->nativetype != IUP_TYPEVOID))
+    XtVaSetValues(ih->handle, XmNrenderTable, motfont->fontlist, NULL);
+
+  return 1;
+}
+
+int iupdrvFontGetStringWidth(Ihandle* ih, const char* str)
+{
+  XFontStruct* fontstruct;
+  int len;
+  char* line_end;
+
+  if (!str || str[0]==0)
+    return 0;
+
+  fontstruct = (XFontStruct*)iupmotGetFontStructAttrib(ih);
+  if (!fontstruct)
+    return 0;
+
+  line_end = strchr(str, '\n');
+  if (line_end)
+    len = line_end-str;
+  else
+    len = strlen(str);
+
+  return XTextWidth(fontstruct, str, len);
+}
+
+void iupdrvFontGetMultiLineStringSize(Ihandle* ih, const char* str, int *w, int *h)
+{
+  int num_lin, max_w;
+
+  ImotFont* motfont = motGetFont(ih);
+  if (!motfont)
+  {
+    if (w) *w = 0;
+    if (h) *h = 0;
+    return;
+  }
+
+  if (!str)
+  {
+    if (w) *w = 0;
+    if (h) *h = motfont->charheight * 1;
+    return;
+  }
+  
+  max_w = 0;
+  num_lin = 1;
+  if (str[0])
+  {
+    int len, lw;
+    const char *nextstr;
+    const char *curstr = str;
+    do
+    {
+      nextstr = iupStrNextLine(curstr, &len);
+      lw = XTextWidth(motfont->fontstruct, curstr, len);
+      max_w = iupMAX(max_w, lw);
+
+      curstr = nextstr;
+      if (*nextstr)
+        num_lin++;
+    } while(*nextstr);
+  }
+
+  if (w) *w = max_w;
+  if (h) *h = motfont->charheight * num_lin;
+}
+
+
+void iupdrvFontGetCharSize(Ihandle* ih, int *charwidth, int *charheight)
+{
+  ImotFont* motfont = motGetFont(ih);
+  if (!motfont)
+  {
+    if (charwidth)  *charwidth = 0;
+    if (charheight) *charheight = 0;
+    return;
+  }
+
+  if (charheight) 
+    *charheight = motfont->charheight;
+
+  if (charwidth)
+    *charwidth = motfont->charwidth;
+}
+
+void iupdrvFontInit(void)
+{
+  mot_fonts = iupArrayCreate(50, sizeof(ImotFont));
+}
+
+void iupdrvFontFinish(void)
+{
+  int i, count = iupArrayCount(mot_fonts);
+  ImotFont* fonts = (ImotFont*)iupArrayGetData(mot_fonts);
+  for (i = 0; i < count; i++)
+  {
+    XmFontListFree(fonts[i].fontlist);
+    fonts[i].fontlist = NULL;
+    XFreeFont(iupmot_display, fonts[i].fontstruct);
+    fonts[i].fontstruct = NULL;
+  }
+  iupArrayDestroy(mot_fonts);
+}
diff --git a/iup/src/mot/iupmot_fontdlg.c b/iup/src/mot/iupmot_fontdlg.c
new file mode 100755
index 0000000..42767b2
--- /dev/null
+++ b/iup/src/mot/iupmot_fontdlg.c
@@ -0,0 +1,31 @@
+/** \file
+ * \brief IupFontDlg pre-defined dialog
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_drvinfo.h"
+#include "iup_dialog.h"
+
+#include "iupmot_drv.h"
+
+
+static int motFontDlgPopup(Ihandle* ih, int x, int y)
+{
+  (void)ih;
+  (void)x;
+  (void)y;
+  return IUP_ERROR;
+}
+
+void iupdrvFontDlgInitClass(Iclass* ic)
+{
+  ic->DlgPopup = motFontDlgPopup;
+}
diff --git a/iup/src/mot/iupmot_frame.c b/iup/src/mot/iupmot_frame.c
new file mode 100755
index 0000000..39de5d8
--- /dev/null
+++ b/iup/src/mot/iupmot_frame.c
@@ -0,0 +1,257 @@
+/** \file
+ * \brief Frame Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/Frame.h>
+#include <Xm/Label.h>
+#include <Xm/BulletinB.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_dialog.h"
+#include "iup_image.h"
+#include "iup_drv.h"
+#include "iup_drvfont.h"
+#include "iup_stdcontrols.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+void iupdrvFrameGetDecorOffset(Ihandle* ih, int *x, int *y)
+{
+  (void)ih;
+  *x = 0;
+  *y = 0;
+}
+
+static int motFrameSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color;
+
+  /* ignore given value, must use only from parent */
+  value = iupBaseNativeParentGetBgColor(ih);
+
+  color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    Widget title_label, child_manager;
+
+    iupmotSetBgColor(ih->handle, color);
+
+    child_manager = XtNameToWidget(ih->handle, "*child_manager");
+    iupmotSetBgColor(child_manager, color);
+
+    title_label = XtNameToWidget(ih->handle, "*title_label");
+    if (!title_label) return 1;
+    iupmotSetBgColor(title_label, color);
+
+    return 1;
+  }
+  return 0; 
+}
+
+static int motFrameSetBackgroundAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color;
+
+  /* ignore given value, must use only from parent */
+  value = iupAttribGetInheritNativeParent(ih, "BACKGROUND");
+
+  color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    Widget title_label, child_manager;
+
+    iupmotSetBgColor(ih->handle, color);
+
+    child_manager = XtNameToWidget(ih->handle, "*child_manager");
+    iupmotSetBgColor(child_manager, color);
+
+    title_label = XtNameToWidget(ih->handle, "*title_label");
+    if (!title_label) return 1;
+    iupmotSetBgColor(title_label, color);
+
+    return 1;
+  }
+  else
+  {
+    Pixmap pixmap = (Pixmap)iupImageGetImage(value, ih, 0);
+    if (pixmap)
+    {
+      Widget child_manager = XtNameToWidget(ih->handle, "*child_manager");
+      Widget title_label = XtNameToWidget(ih->handle, "*title_label");
+
+      XtVaSetValues(child_manager, XmNbackgroundPixmap, pixmap, NULL);
+      if (title_label)
+        XtVaSetValues(title_label, XmNbackgroundPixmap, pixmap, NULL);
+
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static int motFrameSetFgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    Widget title_label = XtNameToWidget(ih->handle, "*title_label");
+    if (!title_label) return 0;
+    XtVaSetValues(title_label, XmNforeground, color, NULL);
+    return 1;
+  }
+  return 0; 
+}
+
+static int motFrameSetStandardFontAttrib(Ihandle* ih, const char* value)
+{
+  iupdrvSetStandardFontAttrib(ih, value);
+
+  if (ih->handle)
+  {
+    XmFontList fontlist;
+    Widget title_label = XtNameToWidget(ih->handle, "*title_label");
+    if (!title_label) return 1;
+
+    fontlist = (XmFontList)iupmotGetFontListAttrib(ih);
+    XtVaSetValues(title_label, XmNrenderTable, fontlist, NULL);
+  }
+
+  return 1;
+}
+
+static int motFrameSetTitleAttrib(Ihandle* ih, const char* value)
+{
+  Widget title_label = XtNameToWidget(ih->handle, "*title_label");
+  if (title_label)
+  {
+    if (!value) value = "";
+    iupmotSetString(title_label, XmNlabelString, value);
+    return 1;
+  }
+  return 0;
+}
+
+static void* motFrameGetInnerNativeContainerHandleMethod(Ihandle* ih, Ihandle* child)
+{
+  (void)child;
+  return XtNameToWidget(ih->handle, "*child_manager");
+}
+
+static int motFrameMapMethod(Ihandle* ih)
+{
+  char *title;
+  int num_args = 0;
+  Arg args[20];
+  Widget child_manager;
+
+  if (!ih->parent)
+    return IUP_ERROR;
+
+  title = iupAttribGet(ih, "TITLE");
+
+  if (title)
+    iupAttribSetStr(ih, "_IUPFRAME_HAS_TITLE", "1");
+  else
+  {
+    char* value = iupAttribGetStr(ih, "SUNKEN");
+    if (iupStrBoolean(value))
+      iupmotSetArg(args, num_args, XmNshadowType, XmSHADOW_IN); 
+    else
+      iupmotSetArg(args, num_args, XmNshadowType, XmSHADOW_ETCHED_IN); 
+  }
+
+  /* Core */
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+  /* Manager */
+  iupmotSetArg(args, num_args, XmNshadowThickness, 2);
+  /* Frame */
+  iupmotSetArg(args, num_args, XmNmarginHeight, 0);  /* no shadow margins */
+  iupmotSetArg(args, num_args, XmNmarginWidth, 0);  /* no shadow margins */
+  
+  ih->handle = XtCreateManagedWidget(
+    iupDialogGetChildIdStr(ih),  /* child identifier */
+    xmFrameWidgetClass,          /* widget class */
+    iupChildTreeGetNativeParentHandle(ih), /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  if (title)
+  {
+    Widget title_label;
+    num_args = 0;
+    /* Label */
+    iupmotSetArg(args, num_args, XmNlabelType, XmSTRING); 
+    iupmotSetArg(args, num_args, XmNmarginHeight, 0);  /* default padding */
+    iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+    /* Frame Constraint */
+    iupmotSetArg(args, num_args, XmNchildType, XmFRAME_TITLE_CHILD);
+    title_label = XtCreateManagedWidget("title_label", xmLabelWidgetClass, ih->handle, args, num_args);
+    iupmotSetString(title_label, XmNlabelString, title);
+  }
+
+  child_manager = XtVaCreateManagedWidget(
+              "child_manager",
+              xmBulletinBoardWidgetClass,
+              ih->handle,
+              /* Core */
+              XmNborderWidth, 0,
+              /* Manager */
+              XmNshadowThickness, 0,
+              XmNnavigationType, XmTAB_GROUP,
+              /* BulletinBoard */
+              XmNmarginWidth, 0,
+              XmNmarginHeight, 0,
+              XmNresizePolicy, XmRESIZE_NONE, /* no automatic resize of children */
+              /* Frame Constraint */
+              XmNchildType, XmFRAME_WORKAREA_CHILD,
+              NULL);
+
+  /* initialize the widget */
+  XtRealizeWidget(ih->handle);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvFrameInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motFrameMapMethod;
+  ic->GetInnerNativeContainerHandle = motFrameGetInnerNativeContainerHandleMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Overwrite Common */
+  iupClassRegisterAttribute(ic, "STANDARDFONT", NULL, motFrameSetStandardFontAttrib, IUPAF_SAMEASSYSTEM, "DEFAULTFONT", IUPAF_NOT_MAPPED);
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, motFrameSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "BACKGROUND", NULL, motFrameSetBackgroundAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, motFrameSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGFGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "TITLE", NULL, motFrameSetTitleAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+}
diff --git a/iup/src/mot/iupmot_globalattrib.c b/iup/src/mot/iupmot_globalattrib.c
new file mode 100755
index 0000000..9567cf5
--- /dev/null
+++ b/iup/src/mot/iupmot_globalattrib.c
@@ -0,0 +1,155 @@
+/** \file
+ * \brief Motif Driver implementation of iupdrvSetGlobal
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+
+#include <stdio.h>
+
+#include "iup.h"
+
+#include "iup_str.h"
+#include "iup_drv.h"
+#include "iup_drvinfo.h"
+#include "iup_strmessage.h"
+
+#include "iupmot_drv.h"
+
+
+static void motGlobalSendKey(int key, int press)
+{
+  Window focus;
+	int revert_to;
+  XKeyEvent evt;
+  memset(&evt, 0, sizeof(XKeyEvent));
+  evt.display = iupmot_display;
+  evt.send_event = True;
+  evt.root = DefaultRootWindow(iupmot_display);
+
+	XGetInputFocus(iupmot_display, &focus, &revert_to);
+  evt.window = focus;
+
+  iupmotKeyEncode(key, &evt.keycode, &evt.state);
+  if (!evt.keycode)
+    return;
+
+  if (press & 0x01)
+  {
+    evt.type = KeyPress;
+    XSendEvent(iupmot_display, (Window)InputFocus, False, KeyPressMask, (XEvent*)&evt);
+  }
+
+  if (press & 0x02)
+  {
+    evt.type = KeyRelease;
+    XSendEvent(iupmot_display, (Window)InputFocus, False, KeyReleaseMask, (XEvent*)&evt);
+  }
+}
+
+int iupdrvSetGlobal(const char *name, const char *value)
+{
+  if (iupStrEqual(name, "LANGUAGE"))
+  {
+    iupStrMessageUpdateLanguage(value);
+    return 1;
+  }
+  if (iupStrEqual(name, "AUTOREPEAT"))
+  {
+    XKeyboardControl values;
+    if (iupStrBoolean(value))
+      values.auto_repeat_mode = 1;
+    else
+      values.auto_repeat_mode = 0;
+    XChangeKeyboardControl(iupmot_display, KBAutoRepeatMode, &values);
+    return 0;
+  }
+  if (iupStrEqual(name, "CURSORPOS"))
+  {
+    int x, y;
+    if (iupStrToIntInt(value, &x, &y, 'x') == 2)
+      XWarpPointer(iupmot_display,None,RootWindow(iupmot_display, iupmot_screen),0,0,0,0,x,y);
+    return 0;
+  }
+  if (iupStrEqual(name, "KEYPRESS"))
+  {
+    int key;
+    if (iupStrToInt(value, &key))
+      motGlobalSendKey(key, 0x01);
+    return 0;
+  }
+  if (iupStrEqual(name, "KEYRELEASE"))
+  {
+    int key;
+    if (iupStrToInt(value, &key))
+      motGlobalSendKey(key, 0x02);
+    return 0;
+  }
+  if (iupStrEqual(name, "KEY"))
+  {
+    int key;
+    if (iupStrToInt(value, &key))
+      motGlobalSendKey(key, 0x03);
+    return 0;
+  }
+  return 1;
+}
+
+char* iupdrvGetGlobal(const char *name)
+{
+  if (iupStrEqual(name, "CURSORPOS"))
+  {
+    int x, y;
+    char* str = iupStrGetMemory(50);
+    iupdrvGetCursorPos(&x, &y);
+    sprintf(str, "%dx%d", x, y);
+    return str;
+  }
+  if (iupStrEqual(name, "SHIFTKEY"))
+  {
+    char key[5];
+    iupdrvGetKeyState(key);
+    if (key[0] == 'S')
+      return "ON";
+    return "OFF";
+  }
+  if (iupStrEqual(name, "CONTROLKEY"))
+  {
+    char key[5];
+    iupdrvGetKeyState(key);
+    if (key[1] == 'C')
+      return "ON";
+    return "OFF";
+  }
+  if (iupStrEqual(name, "MODKEYSTATE"))
+  {
+    char *str = iupStrGetMemory(5);
+    iupdrvGetKeyState(str);
+    return str;
+  }
+  if (iupStrEqual(name, "SCREENSIZE"))
+  {
+    char *str = iupStrGetMemory(50);
+    int w, h;
+    iupdrvGetScreenSize(&w, &h);
+    sprintf(str, "%dx%d", w, h);
+    return str;
+  }
+  if (iupStrEqual(name, "FULLSIZE"))
+  {
+    char *str = iupStrGetMemory(50);
+    int w, h;
+    iupdrvGetFullSize(&w, &h);
+    sprintf(str, "%dx%d", w, h);
+    return str;
+  }
+  if (iupStrEqual(name, "SCREENDEPTH"))
+  {
+    char *str = iupStrGetMemory(50);
+    int bpp = iupdrvGetScreenDepth();
+    sprintf(str, "%d", bpp);
+    return str;
+  }
+  return NULL;
+}
diff --git a/iup/src/mot/iupmot_image.c b/iup/src/mot/iupmot_image.c
new file mode 100755
index 0000000..b0078d5
--- /dev/null
+++ b/iup/src/mot/iupmot_image.c
@@ -0,0 +1,397 @@
+/** \file
+ * \brief Image Resource.
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+
+#include <stdio.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <memory.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_image.h"
+#include "iup_drvinfo.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+void iupdrvImageGetRawData(void* handle, unsigned char* imgdata)
+{
+  Pixmap pixmap = (Pixmap)handle;
+  int w, h, y, x, bpp;
+  XImage *xi;
+
+  if (!iupdrvImageGetInfo(handle, &w, &h, &bpp))
+    return;
+
+  if (bpp==8)
+    return;
+
+  xi = XGetImage(iupmot_display, pixmap, 0, 0, w, h, ULONG_MAX, ZPixmap);
+  if (xi)
+  {
+    /* planes are separated in imgdata */
+    int planesize = w*h;
+    unsigned char *r = imgdata,
+                  *g = imgdata+planesize,
+                  *b = imgdata+2*planesize;
+    for (y=0; y<h; y++)
+    {
+      int lineoffset = (h-1 - y)*w;  /* imgdata is bottom up */
+      for (x=0; x<w; x++)
+      {
+        iupmotColorGetRGB(XGetPixel(xi, x, y), r + lineoffset+x, g + lineoffset+x, b + lineoffset+x);
+      }
+    }
+    
+    XDestroyImage(xi);
+  }
+}
+
+void* iupdrvImageCreateImageRaw(int width, int height, int bpp, iupColor* colors, int colors_count, unsigned char *imgdata)
+{
+  int y, x;
+  Pixmap pixmap;
+  GC gc;
+
+  pixmap = XCreatePixmap(iupmot_display,
+          RootWindow(iupmot_display,iupmot_screen),
+          width, height, iupdrvGetScreenDepth());
+  if (!pixmap)
+    return NULL;
+
+  gc = XCreateGC(iupmot_display,pixmap,0,NULL);
+
+  /* Pixmap is top-bottom */
+  /* imgdata is bottom up */
+
+  if (bpp == 8)
+  {
+    Pixel color2pixel[256];
+    int i;
+    for (i=0;i<colors_count;i++)
+      color2pixel[i] = iupmotColorGetPixel(colors[i].r, colors[i].g, colors[i].b);
+
+    for (y=0;y<height;y++)
+    {
+      int lineoffset = (height-1 - y)*width;  /* imgdata is bottom up */
+      for(x=0;x<width;x++)
+      {
+        unsigned long p = color2pixel[imgdata[lineoffset+x]];
+        XSetForeground(iupmot_display,gc,p);
+        XDrawPoint(iupmot_display,pixmap,gc,x,y);
+      }
+    }
+  }
+  else
+  {
+    /* planes are separated in imgdata */
+    int planesize = width*height;
+    unsigned char *r = imgdata,
+                  *g = imgdata+planesize,
+                  *b = imgdata+2*planesize;
+    for (y=0;y<height;y++)
+    {
+      int lineoffset = (height-1 - y)*width;  /* imgdata is bottom up */
+      for(x=0;x<width;x++)
+      {
+        unsigned long p = iupmotColorGetPixel(r[lineoffset+x], g[lineoffset+x], b[lineoffset+x]);
+        XSetForeground(iupmot_display,gc,p);
+        XDrawPoint(iupmot_display,pixmap,gc,x,y);
+      }
+    }
+  }
+
+  XFreeGC(iupmot_display,gc);
+
+  return (void*)pixmap;
+}
+
+void* iupdrvImageCreateImage(Ihandle *ih, const char* bgcolor, int make_inactive)
+{
+  int y, x, bpp, bgcolor_depend = 0,
+      width = ih->currentwidth,
+      height = ih->currentheight;
+  unsigned char *imgdata = (unsigned char*)iupAttribGetStr(ih, "WID");
+  Pixmap pixmap;
+  unsigned char bg_r=0, bg_g=0, bg_b=0;
+  GC gc;
+  Pixel color2pixel[256];
+
+  bpp = iupAttribGetInt(ih, "BPP");
+
+  iupStrToRGB(bgcolor, &bg_r, &bg_g, &bg_b);
+
+  if (bpp == 8)
+  {
+    int i, colors_count = 0;
+    iupColor colors[256];
+
+    iupImageInitColorTable(ih, colors, &colors_count);
+
+    for (i=0;i<colors_count;i++)
+    {
+      if (colors[i].a == 0)
+      {
+        colors[i].r = bg_r;
+        colors[i].g = bg_g;
+        colors[i].b = bg_b;
+        colors[i].a = 255;
+        bgcolor_depend = 1;
+      }
+
+      if (make_inactive)
+          iupImageColorMakeInactive(&(colors[i].r), &(colors[i].g), &(colors[i].b), 
+                                    bg_r, bg_g, bg_b);
+
+      color2pixel[i] = iupmotColorGetPixel(colors[i].r, colors[i].g, colors[i].b);
+    }
+  }
+
+  pixmap = XCreatePixmap(iupmot_display,
+          RootWindow(iupmot_display,iupmot_screen),
+          width, height, iupdrvGetScreenDepth());
+  if (!pixmap)
+    return NULL;
+
+  gc = XCreateGC(iupmot_display,pixmap,0,NULL);
+  for (y=0;y<height;y++)
+  {
+    for(x=0;x<width;x++)
+    {
+      unsigned long p;
+      if (bpp == 8)
+        p = color2pixel[imgdata[y*width+x]];
+      else
+      {
+        int channels = (bpp==24)? 3: 4;
+        unsigned char *pixel_data = imgdata + y*width*channels + x*channels;
+        unsigned char r = *(pixel_data),
+                      g = *(pixel_data+1),
+                      b = *(pixel_data+2);
+
+        if (bpp == 32)
+        {
+          unsigned char a = *(pixel_data+3);
+          if (a != 255)
+          {
+            r = iupALPHABLEND(r, bg_r, a);
+            g = iupALPHABLEND(g, bg_g, a);
+            b = iupALPHABLEND(b, bg_b, a);
+            bgcolor_depend = 1;
+          }
+        }
+
+        if (make_inactive)
+          iupImageColorMakeInactive(&r, &g, &b, bg_r, bg_g, bg_b);
+
+        p = iupmotColorGetPixel(r, g, b);
+      }
+
+      XSetForeground(iupmot_display,gc,p);
+      XDrawPoint(iupmot_display,pixmap,gc,x,y);
+    }
+  }
+  XFreeGC(iupmot_display,gc);
+
+  if (bgcolor_depend || make_inactive)
+    iupAttribSetStr(ih, "_IUP_BGCOLOR_DEPEND", "1");
+
+  return (void*)pixmap;
+}
+
+void* iupdrvImageCreateIcon(Ihandle *ih)
+{
+  return iupdrvImageCreateImage(ih, NULL, 0);
+}
+
+void* iupdrvImageCreateCursor(Ihandle *ih)
+{
+  int bpp,y,x,hx,hy,
+      width = ih->currentwidth,
+      height = ih->currentheight,
+      line_size = (width+7)/8,
+      size_bytes = line_size*height;
+  unsigned char *imgdata = (unsigned char*)iupAttribGetStr(ih, "WID");
+  char *sbits, *mbits, *sb, *mb;
+  Pixmap source, mask;
+  XColor fg, bg;
+  unsigned char r, g, b;
+  Cursor cursor;
+
+  bpp = iupAttribGetInt(ih, "BPP");
+  if (bpp > 8)
+    return NULL;
+
+  sbits = (char*)malloc(2*size_bytes);
+  if (!sbits) return NULL;
+  memset(sbits, 0, 2*size_bytes);
+  mbits = sbits + size_bytes;
+
+  sb = sbits;
+  mb = mbits;
+  for (y=0; y<height; y++)
+  {
+    for (x=0; x<width; x++)
+    {
+      int byte = x/8;
+      int bit = x%8;
+      int index = (int)imgdata[y*width+x];
+      /* index==0 is transparent */
+      if (index == 1)
+        sb[byte] = (char)(sb[byte] | (1<<bit));
+      if (index != 0)
+        mb[byte] = (char)(mb[byte] | (1<<bit));
+    }
+
+    sb += line_size;
+    mb += line_size;
+  }
+
+  r = 255; g = 255; b = 255;
+  iupStrToRGB(iupAttribGet(ih, "1"), &r, &g, &b );
+  fg.red   = iupCOLOR8TO16(r);
+  fg.green = iupCOLOR8TO16(g);
+  fg.blue  = iupCOLOR8TO16(b);
+  fg.flags = DoRed | DoGreen | DoBlue;
+
+  r = 0; g = 0; b = 0;
+  iupStrToRGB(iupAttribGet(ih, "2"), &r, &g, &b );
+  bg.red   = iupCOLOR8TO16(r);
+  bg.green = iupCOLOR8TO16(g);
+  bg.blue  = iupCOLOR8TO16(b);
+  bg.flags = DoRed | DoGreen | DoBlue;
+
+  hx=0; hy=0;
+  iupStrToIntInt(iupAttribGet(ih, "HOTSPOT"), &hx, &hy, ':');
+
+  source = XCreateBitmapFromData(iupmot_display, 
+             RootWindow(iupmot_display,iupmot_screen),
+             sbits, width, height);
+  mask   = XCreateBitmapFromData(iupmot_display, 
+             RootWindow(iupmot_display,iupmot_screen),
+             mbits, width, height);
+
+  cursor = XCreatePixmapCursor(iupmot_display, source, mask, &fg, &bg, hx, hy);
+
+  free(sbits);
+  return (void*)cursor;
+}
+
+void* iupdrvImageCreateMask(Ihandle *ih)
+{
+  int bpp,y,x,
+      width = ih->currentwidth,
+      height = ih->currentheight,
+      line_size = (width+7)/8,
+      size_bytes = line_size*height;
+  unsigned char *imgdata = (unsigned char*)iupAttribGetStr(ih, "WID");
+  char *bits, *sb;
+  Pixmap mask;
+  unsigned char colors[256];
+
+  bpp = iupAttribGetInt(ih, "BPP");
+  if (bpp > 8)
+    return NULL;
+
+  bits = (char*)malloc(size_bytes);
+  if (!bits) return NULL;
+  memset(bits, 0, size_bytes);
+
+  iupImageInitNonBgColors(ih, colors);
+
+  sb = bits;
+  for (y=0; y<height; y++)
+  {
+    for (x=0; x<width; x++)
+    {
+      int byte = x/8;
+      int bit = x%8;
+      int index = (int)imgdata[y*width+x];
+      if (colors[index])
+        sb[byte] = (char)(sb[byte] | (1<<bit));
+    }
+
+    sb += line_size;
+  }
+
+  mask = XCreateBitmapFromData(iupmot_display, 
+                               RootWindow(iupmot_display,iupmot_screen),
+                               bits, width, height);
+
+  free(bits);
+  return (void*)mask;
+}
+
+void* iupdrvImageLoad(const char* name, int type)
+{
+  if (type == IUPIMAGE_CURSOR)
+  {
+    Cursor cursor = 0;
+    int id;
+    if (iupStrToInt(name, &id))
+      cursor = XCreateFontCursor(iupmot_display, id);
+    return (void*)cursor;
+  }
+  else /* IUPIMAGE_IMAGE or IUPIMAGE_ICON */
+  {
+    Screen* screen = ScreenOfDisplay(iupmot_display, iupmot_screen);
+  	Pixmap pixmap = XmGetPixmap(screen, (char*)name, BlackPixelOfScreen(screen), WhitePixelOfScreen(screen));
+    if (pixmap == XmUNSPECIFIED_PIXMAP)
+    {
+	    unsigned int width, height;
+	    int hotx, hoty;
+      pixmap = 0;
+    	XReadBitmapFile(iupmot_display, RootWindow(iupmot_display,iupmot_screen), name, &width, &height, &pixmap, &hotx, &hoty);
+    }
+  	return (void*)pixmap;
+  }
+}
+
+int iupdrvImageGetInfo(void* handle, int *w, int *h, int *bpp)
+{
+  Pixmap pixmap = (Pixmap)handle;
+  Window root;
+  int x, y;
+  unsigned int width, height, b, depth;
+  if (!XGetGeometry(iupmot_display, pixmap, &root, &x, &y, &width, &height, &b, &depth))
+  {
+    if (w) *w = 0;
+    if (h) *h = 0;
+    if (bpp) *bpp = 0;
+    return 0;
+  }
+  if (w) *w = width;
+  if (h) *h = height;
+  if (bpp) *bpp = iupImageNormBpp(depth);
+  return 1;
+}
+
+int iupdrvImageGetRawInfo(void* handle, int *w, int *h, int *bpp, iupColor* colors, int *colors_count)
+{
+  /* How to get the pallete? */
+  (void)colors;
+  (void)colors_count;
+  return iupdrvImageGetInfo(handle, w, h, bpp);
+}
+
+void iupdrvImageDestroy(void* handle, int type)
+{
+  if (type == IUPIMAGE_CURSOR)
+    XFreeCursor(iupmot_display, (Cursor)handle);
+  else
+  {
+    Screen* screen = ScreenOfDisplay(iupmot_display, iupmot_screen);
+    if (!XmDestroyPixmap(screen, (Pixmap)handle))
+      XFreePixmap(iupmot_display, (Pixmap)handle);
+  }
+}
+
diff --git a/iup/src/mot/iupmot_key.c b/iup/src/mot/iupmot_key.c
new file mode 100755
index 0000000..835b5d7
--- /dev/null
+++ b/iup/src/mot/iupmot_key.c
@@ -0,0 +1,425 @@
+/** \file
+ * \brief Motif Driver keyboard mapping
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <X11/keysym.h>
+
+#include <stdlib.h>      
+#include <stdio.h>      
+#include <ctype.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+#include "iupkey.h"
+
+#include "iup_object.h"
+#include "iup_key.h"
+#include "iup_str.h"
+
+#include "iupmot_drv.h"
+
+typedef struct Imot2iupkey
+{
+  KeySym motcode;
+  int iupcode;
+  int s_iupcode;
+  int c_iupcode;
+  int m_iupcode;
+  int y_iupcode;
+} Imot2iupkey;
+
+static Imot2iupkey motkey_map[] = {
+
+{ XK_Escape,    K_ESC,   K_sESC,    K_cESC,   K_mESC   ,K_yESC   },
+{ XK_Pause,     K_PAUSE, K_sPAUSE,  K_cPAUSE, K_mPAUSE ,K_yPAUSE },
+{ XK_Print,     K_Print, K_sPrint,  K_cPrint, K_mPrint ,K_yPrint },
+{ XK_Menu,      K_Menu,  K_sMenu,   K_cMenu,  K_mMenu  ,K_yMenu  },
+                                                       
+{ XK_Home,      K_HOME,  K_sHOME,   K_cHOME,  K_mHOME  ,K_yHOME  },
+{ XK_Up,        K_UP,    K_sUP,     K_cUP,    K_mUP    ,K_yUP    },
+{ XK_Prior,     K_PGUP,  K_sPGUP,   K_cPGUP,  K_mPGUP  ,K_yPGUP  },
+{ XK_Left,      K_LEFT,  K_sLEFT,   K_cLEFT,  K_mLEFT  ,K_yLEFT  },
+{ XK_Begin,     K_MIDDLE,K_sMIDDLE, K_cMIDDLE,K_mMIDDLE,K_yMIDDLE},
+{ XK_Right,     K_RIGHT, K_sRIGHT,  K_cRIGHT, K_mRIGHT ,K_yRIGHT },
+{ XK_End,       K_END,   K_sEND,    K_cEND,   K_mEND   ,K_yEND   },
+{ XK_Down,      K_DOWN,  K_sDOWN,   K_cDOWN,  K_mDOWN  ,K_yDOWN  },
+{ XK_Next,      K_PGDN,  K_sPGDN,   K_cPGDN,  K_mPGDN  ,K_yPGDN  },
+{ XK_Insert,    K_INS,   K_sINS,    K_cINS,   K_mINS   ,K_yINS   },
+{ XK_Delete,    K_DEL,   K_sDEL,    K_cDEL,   K_mDEL   ,K_yDEL   },
+{ XK_space,     K_SP,    K_sSP,     K_cSP,    K_mSP    ,K_ySP    },
+{ XK_Tab,       K_TAB,   K_sTAB,    K_cTAB,   K_mTAB   ,K_yTAB   },
+{ XK_Return,    K_CR,    K_sCR,     K_cCR,    K_mCR    ,K_yCR    },
+{ XK_BackSpace, K_BS,    K_sBS,     K_cBS,    K_mBS    ,K_yBS    },
+
+{ XK_1,   K_1, K_exclam,      K_c1, K_m1, K_y1 },
+{ XK_2,   K_2, K_at,          K_c2, K_m2, K_y2 },
+{ XK_3,   K_3, K_numbersign,  K_c3, K_m3, K_y3 },
+{ XK_4,   K_4, K_dollar,      K_c4, K_m4, K_y4 },
+{ XK_5,   K_5, K_percent,     K_c5, K_m5, K_y5 },
+{ XK_6,   K_6, K_circum,      K_c6, K_m6, K_y6 },
+{ XK_7,   K_7, K_ampersand,   K_c7, K_m7, K_y7 },
+{ XK_8,   K_8, K_asterisk,    K_c8, K_m8, K_y8 },
+{ XK_9,   K_9, K_parentleft,  K_c9, K_m9, K_y9 },
+{ XK_0,   K_0, K_parentright, K_c0, K_m0, K_y0 },
+
+{ XK_a,   K_a, K_A, K_cA, K_mA, K_yA },
+{ XK_b,   K_b, K_B, K_cB, K_mB, K_yB },
+{ XK_c,   K_c, K_C, K_cC, K_mC, K_yC },
+{ XK_d,   K_d, K_D, K_cD, K_mD, K_yD },
+{ XK_e,   K_e, K_E, K_cE, K_mE, K_yE },
+{ XK_f,   K_f, K_F, K_cF, K_mF, K_yF },
+{ XK_g,   K_g, K_G, K_cG, K_mG, K_yG },
+{ XK_h,   K_h, K_H, K_cH, K_mH, K_yH },
+{ XK_i,   K_i, K_I, K_cI, K_mI, K_yI },
+{ XK_j,   K_j, K_J, K_cJ, K_mJ, K_yJ },
+{ XK_k,   K_k, K_K, K_cK, K_mK, K_yK },
+{ XK_l,   K_l, K_L, K_cL, K_mL, K_yL },
+{ XK_m,   K_m, K_M, K_cM, K_mM, K_yM },
+{ XK_n,   K_n, K_N, K_cN, K_mN, K_yN },
+{ XK_o,   K_o, K_O, K_cO, K_mO, K_yO },
+{ XK_p,   K_p, K_P, K_cP, K_mP, K_yP },
+{ XK_q,   K_q, K_Q, K_cQ, K_mQ, K_yQ },
+{ XK_r,   K_r, K_R, K_cR, K_mR, K_yR },
+{ XK_s,   K_s, K_S, K_cS, K_mS, K_yS },
+{ XK_t,   K_t, K_T, K_cT, K_mT, K_yT },
+{ XK_u,   K_u, K_U, K_cU, K_mU, K_yU },
+{ XK_v,   K_v, K_V, K_cV, K_mV, K_yV },
+{ XK_w,   K_w, K_W, K_cW, K_mW, K_yW },
+{ XK_x,   K_x, K_X, K_cX, K_mX, K_yX },
+{ XK_y,   K_y, K_Y, K_cY, K_mY, K_yY },
+{ XK_z,   K_z, K_Z, K_cZ, K_mZ, K_yZ },
+
+{ XK_F1,  K_F1,  K_sF1,  K_cF1,  K_mF1,  K_yF1 },
+{ XK_F2,  K_F2,  K_sF2,  K_cF2,  K_mF2,  K_yF2 },
+{ XK_F3,  K_F3,  K_sF3,  K_cF3,  K_mF3,  K_yF3 },
+{ XK_F4,  K_F4,  K_sF4,  K_cF4,  K_mF4,  K_yF4 },
+{ XK_F5,  K_F5,  K_sF5,  K_cF5,  K_mF5,  K_yF5 },
+{ XK_F6,  K_F6,  K_sF6,  K_cF6,  K_mF6,  K_yF6 },
+{ XK_F7,  K_F7,  K_sF7,  K_cF7,  K_mF7,  K_yF7 },
+{ XK_F8,  K_F8,  K_sF8,  K_cF8,  K_mF8,  K_yF8 },
+{ XK_F9,  K_F9,  K_sF9,  K_cF9,  K_mF9,  K_yF9 },
+{ XK_F10, K_F10, K_sF10, K_cF10, K_mF10, K_yF10 },
+{ XK_F11, K_F11, K_sF11, K_cF11, K_mF11, K_yF11 },
+{ XK_F12, K_F12, K_sF12, K_cF12, K_mF12, K_yF12 },
+
+{ XK_semicolon,   K_semicolon,    K_colon,      K_cSemicolon, K_mSemicolon, K_ySemicolon },
+{ XK_equal,       K_equal,        K_plus,       K_cEqual,     K_mEqual,  K_yEqual },
+{ XK_comma,       K_comma,        K_less,       K_cComma,     K_mComma,  K_yComma },
+{ XK_minus,       K_minus,        K_underscore, K_cMinus,     K_mMinus,  K_yMinus },
+{ XK_period,      K_period,       K_greater,    K_cPeriod,    K_mPeriod, K_yPeriod },
+{ XK_slash,       K_slash,        K_question,   K_cSlash,     K_mSlash,  K_ySlash },
+{ XK_grave,       K_grave,        K_tilde,      0, 0, 0 },
+{ XK_bracketleft, K_bracketleft,  K_braceleft,  K_cBracketleft, K_mBracketleft, K_yBracketleft },
+{ XK_backslash,   K_backslash,    K_bar,        K_cBackslash,   K_mBackslash,   K_yBackslash },
+{ XK_bracketright,K_bracketright, K_braceright, K_cBracketright,K_mBracketright,K_yBracketright },
+{ XK_apostrophe,  K_apostrophe,   K_quotedbl,   0, 0, 0 },
+
+{ XK_KP_0,   K_0, K_0,  K_c0, K_m0, K_y0 },
+{ XK_KP_1,   K_1, K_1,  K_c1, K_m1, K_y1 },
+{ XK_KP_2,   K_2, K_2,  K_c2, K_m2, K_y2 },
+{ XK_KP_3,   K_3, K_3,  K_c3, K_m3, K_y3 },
+{ XK_KP_4,   K_4, K_4,  K_c4, K_m4, K_y4 },
+{ XK_KP_5,   K_5, K_5,  K_c5, K_m5, K_y5 },
+{ XK_KP_6,   K_6, K_6,  K_c6, K_m6, K_y6 },
+{ XK_KP_7,   K_7, K_7,  K_c7, K_m7, K_y7 },
+{ XK_KP_8,   K_8, K_8,  K_c8, K_m8, K_y8 },
+{ XK_KP_9,   K_9, K_9,  K_c9, K_m9, K_y9 },
+{ XK_KP_Multiply,  K_asterisk, K_sAsterisk, K_cAsterisk, K_mAsterisk, K_yAsterisk },
+{ XK_KP_Add,       K_plus,     K_sPlus,     K_cPlus,     K_mPlus,     K_yPlus },
+{ XK_KP_Subtract,  K_minus,    K_sMinus,    K_cMinus,    K_mMinus,    K_yMinus },
+{ XK_KP_Decimal,   K_period,   K_sPeriod,   K_cPeriod,   K_mPeriod,   K_yPeriod },
+{ XK_KP_Divide,    K_slash,    K_sSlash,    K_cSlash,    K_mSlash,    K_ySlash },
+{ XK_KP_Separator, K_comma,    K_sComma,    K_cComma,    K_mComma,    K_yComma },
+
+{ XK_ccedilla,     K_ccedilla, K_Ccedilla, K_cCcedilla, K_mCcedilla, K_yCcedilla },
+
+{ XK_dead_tilde,   K_tilde, K_circum, 0, 0, 0 },
+{ XK_dead_acute,   K_acute, K_grave,  0, 0, 0 },
+{ XK_dead_grave,   K_grave, K_tilde,  0, 0, 0 },
+
+{ XK_KP_F1,  K_F1,  K_sF1,  K_cF1,  K_mF1,  K_yF1 },
+{ XK_KP_F2,  K_F2,  K_sF2,  K_cF2,  K_mF2,  K_yF2 },
+{ XK_KP_F3,  K_F3,  K_sF3,  K_cF3,  K_mF3,  K_yF3 },
+{ XK_KP_F4,  K_F4,  K_sF4,  K_cF4,  K_mF4,  K_yF4 },
+{ XK_KP_Space,     K_SP,    K_sSP,     K_cSP,    K_mSP    ,K_ySP    },
+{ XK_KP_Tab,       K_TAB,   K_sTAB,    K_cTAB,   K_mTAB   ,K_yTAB   },
+{ XK_KP_Equal,     K_equal,  0,       K_cEqual,     K_mEqual,  K_yEqual },
+
+{ XK_KP_Enter,     K_CR,    K_sCR,     K_cCR,    K_mCR,    K_yCR    },
+{ XK_KP_Home,      K_HOME,  K_sHOME,   K_cHOME,  K_mHOME,  K_yHOME  },
+{ XK_KP_Up,        K_UP,    K_sUP,     K_cUP,    K_mUP,    K_yUP    },
+{ XK_KP_Page_Up,   K_PGUP,  K_sPGUP,   K_cPGUP,  K_mPGUP,  K_yPGUP  },
+{ XK_KP_Left,      K_LEFT,  K_sLEFT,   K_cLEFT,  K_mLEFT,  K_yLEFT  },
+{ XK_KP_Begin,     K_MIDDLE,K_sMIDDLE, K_cMIDDLE,K_mMIDDLE,K_yMIDDLE},
+{ XK_KP_Right,     K_RIGHT, K_sRIGHT,  K_cRIGHT, K_mRIGHT, K_yRIGHT },
+{ XK_KP_End,       K_END,   K_sEND,    K_cEND,   K_mEND,   K_yEND   },
+{ XK_KP_Down,      K_DOWN,  K_sDOWN,   K_cDOWN,  K_mDOWN,  K_yDOWN  },
+{ XK_KP_Page_Down, K_PGDN,  K_sPGDN,   K_cPGDN,  K_mPGDN,  K_yPGDN  },
+{ XK_KP_Insert,    K_INS,   K_sINS,    K_cINS,   K_mINS,   K_yINS   },
+{ XK_KP_Delete,    K_DEL,   K_sDEL,    K_cDEL,   K_mDEL,   K_yDEL   }
+
+};
+
+void iupmotKeyEncode(int key, unsigned int *keyval, unsigned int *state)
+{
+  int i, iupcode = key & 0xFF; /* 0-255 interval */
+  int count = sizeof(motkey_map)/sizeof(motkey_map[0]);
+  for (i = 0; i < count; i++)
+  {
+    Imot2iupkey* key_map = &(motkey_map[i]);
+    if (key_map->iupcode == iupcode)
+    {
+      *keyval = XKeysymToKeycode(iupmot_display, key_map->motcode);
+      *state = 0;
+
+      if (iupcode != key)
+      {
+        if (key_map->c_iupcode == key)
+          *state = ControlMask;
+        else if (key_map->m_iupcode == key)
+          *state = Mod1Mask;
+        else if (key_map->y_iupcode == key)
+          *state = Mod4Mask;
+        else if (key_map->s_iupcode == key)
+          *state = ShiftMask;
+      }
+      return;
+    }
+    else if (key_map->s_iupcode == key)   /* There are Shift keys bellow 256 */
+    {
+      *keyval = XKeysymToKeycode(iupmot_display, key_map->motcode);
+      *state = ShiftMask;
+      return;
+    }
+  }
+}
+
+static int motKeyMap2Iup(unsigned int state, int i)
+{
+  int code = 0;
+  if (state & ControlMask)   /* Ctrl */
+    code = motkey_map[i].c_iupcode;
+  else if (state & Mod1Mask || 
+           state & Mod5Mask) /* Alt */
+    code = motkey_map[i].m_iupcode;
+  else if (state & Mod4Mask) /* Apple/Win */
+    code = motkey_map[i].y_iupcode;
+  else if (state & LockMask) /* CapsLock */
+  {
+    if ((state & ShiftMask) || !iupKeyCanCaps(motkey_map[i].iupcode))
+      return motkey_map[i].iupcode;
+    else
+      code = motkey_map[i].s_iupcode;
+  }
+  else if (state & ShiftMask) /* Shift */
+    code = motkey_map[i].s_iupcode;
+  else
+    return motkey_map[i].iupcode;
+
+  if (!code)
+    code = motkey_map[i].iupcode;
+
+  return code;
+}
+
+static int motKeyDecode(XKeyEvent *evt)
+{
+  int i;
+  KeySym motcode = XKeycodeToKeysym(iupmot_display, evt->keycode, 0);
+  int count = sizeof(motkey_map)/sizeof(motkey_map[0]);
+
+  if ((evt->state & Mod2Mask) && /* NumLock */
+      (motcode >= XK_KP_Home) &&
+      (motcode <= XK_KP_Delete))
+  {
+    /* remap to numeric keys */
+    KeySym remap_numkey[] = {XK_KP_7, XK_KP_4, XK_KP_8, XK_KP_6, XK_KP_2, XK_KP_9, XK_KP_3, XK_KP_1, XK_KP_5, XK_KP_0, XK_KP_Decimal};
+    motcode = remap_numkey[motcode-XK_KP_Home];
+  }
+
+  for (i = 0; i < count; i++)
+  {
+    if (motkey_map[i].motcode == motcode)
+      return motKeyMap2Iup(evt->state, i);
+  }
+
+  return 0;
+}
+
+KeySym iupmotKeyCharToKeySym(char c)
+{
+  int i;
+  int count = sizeof(motkey_map)/sizeof(motkey_map[0]);
+
+  for (i = 0; i < count; i++)
+  {
+    if (motkey_map[i].iupcode == c)
+      return motkey_map[i].motcode;
+    if (motkey_map[i].s_iupcode == c)
+    {
+      if (motkey_map[i].motcode >= XK_a &&
+          motkey_map[i].motcode <= XK_z)
+        return motkey_map[i].motcode - (XK_a-XK_A);
+    }
+  }
+
+  return 0;
+}
+
+/* Discards keyrepeat by removing the keypress event from the queue.
+ * The pair keyrelease/keypress is always put together in the queue,
+ * by removing the keypress, we only worry about keyrelease. In case
+ * of a keyrelease, we ignore it if the next event is a keypress (which
+ * means repetition. Otherwise it is a real keyrelease.
+ *
+ * Returns 1 if the keypress is found in the queue and 0 otherwise.
+ */
+static int motKeyDiscardKeypressRepeat(XEvent *evt)
+{
+  XEvent ahead;
+  if (XEventsQueued(iupmot_display, QueuedAfterReading))
+  {
+    XPeekEvent(iupmot_display, &ahead);
+    if (ahead.type == KeyPress && ahead.xkey.window == evt->xkey.window
+        && ahead.xkey.keycode == evt->xkey.keycode && ahead.xkey.time == evt->xkey.time)
+    {
+      /* Pop off the repeated KeyPress and ignore */
+      XNextEvent(iupmot_display, evt);
+      /* Ignore the auto repeated KeyRelease/KeyPress pair */
+      return 1;
+    }
+  }
+  /* No KeyPress found */
+  return 0;
+}
+
+/* this is called only for canvas */
+void iupmotCanvasKeyReleaseEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont)
+{
+  if (motKeyDiscardKeypressRepeat(evt))
+  {
+    /* call key_press because it was removed from the queue */
+    iupmotKeyPressEvent(w, ih, evt, cont);
+  }
+  else
+  {
+    int result;
+    int code = motKeyDecode((XKeyEvent*)evt);
+    if (code == 0) 
+      return;
+    result = iupKeyCallKeyPressCb(ih, code, 0);
+    if (result == IUP_CLOSE)
+    {
+      IupExitLoop();
+      return;
+    }
+    if (result == IUP_IGNORE)
+    {
+      *cont = False;
+      return;
+    }
+  }
+}
+
+void iupmotKeyPressEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont)
+{
+  int result;
+  int code = motKeyDecode((XKeyEvent*)evt);
+  if (code == 0) 
+      return;
+
+  if ((((XKeyEvent*)evt)->state & Mod1Mask || ((XKeyEvent*)evt)->state & Mod5Mask))  /* Alt */
+  {
+    KeySym motcode = XKeycodeToKeysym(iupmot_display, ((XKeyEvent*)evt)->keycode, 0);
+    if (motcode < 128)
+    {
+      IFni cb;
+      Ihandle* dialog = IupGetDialog(ih);
+      char attrib[22] = "_IUPMOT_MNEMONIC_ _CB";
+      attrib[17] = (char)toupper(motcode);
+      cb = (IFni)IupGetCallback(dialog, attrib);
+      if (cb) 
+      {
+        cb(dialog, attrib[17]);
+        return;
+      }
+    }
+  }
+
+  result = iupKeyCallKeyCb(ih, code);
+  if (result == IUP_CLOSE)
+  {
+    IupExitLoop();
+    return;
+  }
+  if (result == IUP_IGNORE)
+  {
+    *cont = False;
+    return;
+  }
+
+  /* in the previous callback the dialog could be destroyed */
+  if (iupObjectCheck(ih))
+  {
+    /* this is called only for canvas */
+    if (ih->iclass->nativetype==IUP_TYPECANVAS) 
+    {
+      result = iupKeyCallKeyPressCb(ih, code, 1);
+      if (result == IUP_CLOSE)
+      {
+        IupExitLoop();
+        return;
+      }
+      if (result == IUP_IGNORE)
+      {
+        *cont = False;
+        return;
+      }
+    }
+
+    if (!iupKeyProcessNavigation(ih, code, ((XKeyEvent*)evt)->state & ShiftMask))
+    {
+      *cont = False;
+      return;
+    }
+  }
+
+  (void)w;
+}
+
+void iupmotButtonKeySetStatus(unsigned int state, unsigned int but, char* status, int doubleclick)
+{
+  if (state & ShiftMask)
+    iupKEYSETSHIFT(status);
+
+  if (state & ControlMask)
+    iupKEYSETCONTROL(status); 
+
+  if ((state & Button1Mask) || but==Button1)
+    iupKEYSETBUTTON1(status);
+
+  if ((state & Button2Mask) || but==Button2)
+    iupKEYSETBUTTON2(status);
+
+  if ((state & Button3Mask) || but==Button3)
+    iupKEYSETBUTTON3(status);
+
+  if ((state & Button4Mask) || but==Button4)
+    iupKEYSETBUTTON4(status);
+
+  if ((state & Button5Mask) || but==Button5)
+    iupKEYSETBUTTON5(status);
+
+  if (state & Mod1Mask || state & Mod5Mask) /* Alt */
+    iupKEYSETALT(status);
+
+  if (state & Mod4Mask) /* Apple/Win */
+    iupKEYSETSYS(status);
+
+  if (doubleclick)
+    iupKEYSETDOUBLE(status);
+}
+
diff --git a/iup/src/mot/iupmot_label.c b/iup/src/mot/iupmot_label.c
new file mode 100755
index 0000000..52dfc9a
--- /dev/null
+++ b/iup/src/mot/iupmot_label.c
@@ -0,0 +1,256 @@
+/** \file
+ * \brief Label Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/Label.h>
+#include <Xm/Separator.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_dialog.h"
+#include "iup_str.h"
+#include "iup_label.h"
+#include "iup_drv.h"
+#include "iup_image.h"
+
+#include "iupmot_drv.h"
+
+
+static int motLabelSetTitleAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_LABEL_TEXT)
+  {
+    iupmotSetMnemonicTitle(ih, value);
+    return 1;
+  }
+
+  return 0;
+}
+
+static int motLabelSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  /* ignore given value, must use only from parent */
+  value = iupBaseNativeParentGetBgColor(ih);
+
+  if (iupdrvBaseSetBgColorAttrib(ih, value))
+    return 1;
+  return 0; 
+}
+
+static int motLabelSetBackgroundAttrib(Ihandle* ih, const char* value)
+{
+  /* ignore given value, must use only from parent */
+  value = iupAttribGetInheritNativeParent(ih, "BACKGROUND");
+
+  if (iupdrvBaseSetBgColorAttrib(ih, value))
+    return 1;
+  else
+  {
+    Pixmap pixmap = (Pixmap)iupImageGetImage(value, ih, 0);
+    if (pixmap)
+    {
+      XtVaSetValues(ih->handle, XmNbackgroundPixmap, pixmap, NULL);
+      return 1;
+    }
+  }
+  return 0; 
+}
+
+static int motLabelSetAlignmentAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type != IUP_LABEL_SEP_HORIZ && ih->data->type != IUP_LABEL_SEP_VERT)
+  {
+    unsigned char align;
+    char value1[30]="", value2[30]="";
+
+    iupStrToStrStr(value, value1, value2, ':');   /* value2 is ignored, NOT supported in Motif */
+
+    if (iupStrEqualNoCase(value1, "ARIGHT"))
+      align = XmALIGNMENT_END;
+    else if (iupStrEqualNoCase(value1, "ACENTER"))
+      align = XmALIGNMENT_CENTER;
+    else /* "ALEFT" */
+      align = XmALIGNMENT_BEGINNING;
+
+    XtVaSetValues(ih->handle, XmNalignment, align, NULL);
+    return 1;
+  }
+  else
+    return 0;
+}
+
+static int motLabelSetImageAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_LABEL_IMAGE)
+  {
+    iupmotSetPixmap(ih, value, XmNlabelPixmap, 0);
+
+    if (!iupdrvIsActive(ih))
+    {
+      if (!iupAttribGet(ih, "IMINACTIVE"))
+      {
+        /* if not active and IMINACTIVE is not defined 
+           then automaticaly create one based on IMAGE */
+        iupmotSetPixmap(ih, value, XmNlabelInsensitivePixmap, 1); /* make_inactive */
+      }
+    }
+    return 1;
+  }
+  else
+    return 0;
+}
+
+static int motLabelSetImInactiveAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_LABEL_IMAGE)
+  {
+    iupmotSetPixmap(ih, value, XmNlabelInsensitivePixmap, 0);
+    return 1;
+  }
+  else
+    return 0;
+}
+
+static int motLabelSetActiveAttrib(Ihandle* ih, const char* value)
+{
+  /* update the inactive image if necessary */
+  if (ih->data->type == IUP_LABEL_IMAGE && !iupStrBoolean(value))
+  {
+    if (!iupAttribGet(ih, "IMINACTIVE"))
+    {
+      /* if not defined then automaticaly create one based on IMAGE */
+      char* name = iupAttribGet(ih, "IMAGE");
+      iupmotSetPixmap(ih, name, XmNlabelInsensitivePixmap, 1); /* make_inactive */
+    }
+  }
+
+  return iupBaseSetActiveAttrib(ih, value);
+}
+
+static int motLabelSetPaddingAttrib(Ihandle* ih, const char* value)
+{
+  iupStrToIntInt(value, &ih->data->horiz_padding, &ih->data->vert_padding, 'x');
+  if (ih->handle && ih->data->type != IUP_LABEL_SEP_HORIZ && ih->data->type != IUP_LABEL_SEP_VERT)
+  {
+    XtVaSetValues(ih->handle, XmNmarginHeight, ih->data->vert_padding,
+                              XmNmarginWidth, ih->data->horiz_padding, NULL);
+  }
+  return 0;
+}
+
+static int motLabelMapMethod(Ihandle* ih)
+{
+  char* value;
+  int num_args = 0;
+  Arg args[20];
+  WidgetClass widget_class;
+
+  value = iupAttribGet(ih, "SEPARATOR");
+  if (value)
+  {
+    widget_class = xmSeparatorWidgetClass;
+    if (iupStrEqualNoCase(value, "HORIZONTAL"))
+    {
+      ih->data->type = IUP_LABEL_SEP_HORIZ;
+      iupmotSetArg(args, num_args, XmNorientation, XmHORIZONTAL);
+    }
+    else /* "VERTICAL" */
+    {
+      ih->data->type = IUP_LABEL_SEP_VERT;
+      iupmotSetArg(args, num_args, XmNorientation, XmVERTICAL);
+    }
+  }
+  else
+  {
+    value = iupAttribGet(ih, "IMAGE");
+    widget_class = xmLabelWidgetClass;
+    if (value)
+    {
+      ih->data->type = IUP_LABEL_IMAGE;
+      iupmotSetArg(args, num_args, XmNlabelType, XmPIXMAP); 
+    }
+    else
+    {
+      ih->data->type = IUP_LABEL_TEXT;
+      iupmotSetArg(args, num_args, XmNlabelType, XmSTRING); 
+    }
+  }
+
+  /* Core */
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+  /* Primitive */
+  iupmotSetArg(args, num_args, XmNtraversalOn, False);
+  iupmotSetArg(args, num_args, XmNhighlightThickness, 0);
+  /* Label */
+  iupmotSetArg(args, num_args, XmNrecomputeSize, False);  /* no automatic resize from text */
+  iupmotSetArg(args, num_args, XmNmarginHeight, 0);  /* default padding */
+  iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+  iupmotSetArg(args, num_args, XmNmarginTop, 0);     /* no extra margins */
+  iupmotSetArg(args, num_args, XmNmarginLeft, 0);
+  iupmotSetArg(args, num_args, XmNmarginBottom, 0);
+  iupmotSetArg(args, num_args, XmNmarginRight, 0);
+  
+  ih->handle = XtCreateManagedWidget(
+    iupDialogGetChildIdStr(ih),  /* child identifier */
+    widget_class,                /* widget class */
+    iupChildTreeGetNativeParentHandle(ih), /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  /* Drag Source is enabled by default in label */
+  iupmotDisableDragSource(ih->handle);
+
+  /* initialize the widget */
+  XtRealizeWidget(ih->handle);
+
+  if (ih->data->type == IUP_LABEL_TEXT)
+    iupmotSetString(ih->handle, XmNlabelString, "");
+
+  return IUP_NOERROR;
+}
+
+void iupdrvLabelInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motLabelMapMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Overwrite Visual */
+  iupClassRegisterAttribute(ic, "ACTIVE", iupBaseGetActiveAttrib, motLabelSetActiveAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "BGCOLOR", iupmotGetBgColorAttrib, motLabelSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "BACKGROUND", NULL, motLabelSetBackgroundAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, iupdrvBaseSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGFGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "TITLE", NULL, motLabelSetTitleAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+
+  /* IupLabel only */
+  iupClassRegisterAttribute(ic, "ALIGNMENT", NULL, motLabelSetAlignmentAttrib, "ALEFT:ACENTER", NULL, IUPAF_NO_INHERIT);  /* force new default value */
+  iupClassRegisterAttribute(ic, "IMAGE", NULL, motLabelSetImageAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "PADDING", iupLabelGetPaddingAttrib, motLabelSetPaddingAttrib, IUPAF_SAMEASSYSTEM, "0x0", IUPAF_NOT_MAPPED);
+
+  /* IupLabel GTK and Motif only */
+  iupClassRegisterAttribute(ic, "IMINACTIVE", NULL, motLabelSetImInactiveAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+}
diff --git a/iup/src/mot/iupmot_list.c b/iup/src/mot/iupmot_list.c
new file mode 100755
index 0000000..f8e73ed
--- /dev/null
+++ b/iup/src/mot/iupmot_list.c
@@ -0,0 +1,1404 @@
+/** \file
+ * \brief List Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/List.h>
+#include <Xm/ComboBox.h>
+#include <Xm/ScrolledW.h>
+#include <Xm/TextF.h>
+#include <X11/keysym.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+#include <time.h>
+#include <limits.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_dialog.h"
+#include "iup_str.h"
+#include "iup_drv.h"
+#include "iup_mask.h"
+#include "iup_key.h"
+#include "iup_list.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+static void motListComboBoxSelectionCallback(Widget w, Ihandle* ih, XmComboBoxCallbackStruct* call_data);
+
+
+void iupdrvListAddItemSpace(Ihandle* ih, int *h)
+{
+  if (ih->data->has_editbox)
+    *h += 1;
+  else
+    *h += 3;
+}
+
+void iupdrvListAddBorders(Ihandle* ih, int *x, int *y)
+{
+  int border_size = 2*4;
+  (*x) += border_size;
+  (*y) += border_size;
+
+  if (ih->data->is_dropdown)
+  {
+    if (ih->data->has_editbox)
+    {
+      /* extra border for the editbox */
+      int internal_border_size = 2*2;
+      (*x) += internal_border_size; 
+      (*y) += internal_border_size;
+    }
+  }
+  else
+  {
+    if (ih->data->has_editbox)
+      (*y) += 2*2; /* internal border between editbox and list */
+    else
+      (*x) += 2; /* extra border for the simple list */
+  }
+}
+
+static int motListConvertXYToPos(Ihandle* ih, int x, int y)
+{
+  (void)x;
+  if (ih->data->has_editbox)
+  {
+    Widget cblist;
+    XtVaGetValues(ih->handle, XmNlist, &cblist, NULL);
+    return XmListYToPos(cblist, (Position)y);   /* XmListYToPos returns start at 1 */
+  }
+  else
+    return XmListYToPos(ih->handle, (Position)y);
+}
+
+int iupdrvListGetCount(Ihandle* ih)
+{
+  int count;
+  XtVaGetValues(ih->handle, XmNitemCount, &count, NULL);
+  return count;
+}
+
+static void motListAddItem(Ihandle* ih, int pos, const char* value)
+{
+  XmString str = XmStringCreateLocalized((String)value);
+  /* The utility functions use 0=last 1=first */
+  if (ih->data->is_dropdown || ih->data->has_editbox)
+    XmComboBoxAddItem(ih->handle, str, pos+1, False);
+  else
+    XmListAddItem(ih->handle, str, pos+1);
+  XmStringFree(str);
+}
+
+static void motListAddSortedItem(Ihandle* ih, const char *value)
+{
+  char *text;
+  XmString *strlist;
+  int u_bound, l_bound = 0;
+
+  XtVaGetValues(ih->handle, XmNitemCount, &u_bound, XmNitems, &strlist, NULL);
+
+  u_bound--;
+  /* perform binary search */
+  while (u_bound >= l_bound) 
+  {
+    int i = l_bound + (u_bound - l_bound)/2;
+    text = (char*)XmStringUnparse(strlist[i], NULL, XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0, XmOUTPUT_ALL);
+    if (!text)
+      break;
+    if (strcmp (text, value) > 0)
+      u_bound = i-1; /* newtext comes before item */
+    else
+      l_bound = i+1; /* newtext comes after item */
+    XtFree(text);
+  }
+
+  motListAddItem(ih, l_bound, value);
+}
+
+void iupdrvListAppendItem(Ihandle* ih, const char* value)
+{
+  if (iupAttribGetBoolean(ih, "SORT"))
+    motListAddSortedItem(ih, value);
+  else
+    motListAddItem(ih, -1, value);
+}
+
+void iupdrvListInsertItem(Ihandle* ih, int pos, const char* value)
+{
+  if (iupAttribGetBoolean(ih, "SORT"))
+    motListAddSortedItem(ih, value);
+  else
+    motListAddItem(ih, pos, value);
+}
+
+void iupdrvListRemoveItem(Ihandle* ih, int pos)
+{
+  /* The utility functions use 0=last 1=first */
+  if (ih->data->is_dropdown || ih->data->has_editbox)
+    XmComboBoxDeletePos(ih->handle, pos+1);
+  else
+    XmListDeletePos(ih->handle, pos+1);
+}
+
+void iupdrvListRemoveAllItems(Ihandle* ih)
+{
+  if (ih->data->is_dropdown || ih->data->has_editbox)
+  {
+    Widget cblist;
+    XtVaGetValues(ih->handle, XmNlist, &cblist, NULL);
+    XmListDeleteAllItems(cblist);
+    XmComboBoxUpdate(ih->handle);
+  }
+  else
+    XmListDeleteAllItems(ih->handle);
+}
+
+
+/*********************************************************************************/
+
+
+static char* motListGetIdValueAttrib(Ihandle* ih, const char* name_id)
+{
+  int pos = iupListGetPos(ih, name_id);
+  if (pos != -1)
+  {
+    XmString* items;
+    XtVaGetValues(ih->handle, XmNitems, &items, NULL);
+    return iupmotConvertString(items[pos]);
+  }
+  return NULL;
+}
+
+static int motListSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  Widget sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (sb_win)
+  {
+    Pixel color;
+
+    /* ignore given value for the scrollbars, must use only from parent */
+    char* parent_value = iupBaseNativeParentGetBgColor(ih);
+
+    color = iupmotColorGetPixelStr(parent_value);
+    if (color != (Pixel)-1)
+    {
+      Widget sb = NULL;
+
+      iupmotSetBgColor(sb_win, color);
+
+      XtVaGetValues(sb_win, XmNverticalScrollBar, &sb, NULL);
+      if (sb) iupmotSetBgColor(sb, color);
+
+      XtVaGetValues(sb_win, XmNhorizontalScrollBar, &sb, NULL);
+      if (sb) iupmotSetBgColor(sb, color);
+    }
+
+    return iupdrvBaseSetBgColorAttrib(ih, value);    /* use given value for contents */
+  }
+  else
+  {
+    char* parent_value;
+
+    /* use given value for Edit and List also */
+    Pixel color = iupmotColorGetPixelStr(value);
+    if (color != (Pixel)-1)
+    {
+      Widget cbedit, cblist, sb;
+
+      iupmotSetBgColor(ih->handle, color);
+
+      XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+      if (cbedit) iupmotSetBgColor(cbedit, color);
+
+      XtVaGetValues(ih->handle, XmNlist, &cblist, NULL);
+      if (cblist) iupmotSetBgColor(cblist, color);
+
+      XtVaGetValues(cblist, XmNverticalScrollBar, &sb, NULL);
+      if (sb) iupmotSetBgColor(sb, color);
+
+      XtVaGetValues(cblist, XmNhorizontalScrollBar, &sb, NULL);
+      if (sb) iupmotSetBgColor(sb, color);
+    }
+
+    /* but reset just the background, so the combobox will look like a button */
+    parent_value = iupBaseNativeParentGetBgColor(ih);
+
+    color = iupmotColorGetPixelStr(parent_value);
+    if (color != (Pixel)-1)
+      XtVaSetValues(ih->handle, XmNbackground, color, NULL);
+
+    return 1;
+  }
+}
+
+static int motListSetFgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    XtVaSetValues(ih->handle, XmNforeground, color, NULL);
+
+    if (ih->data->is_dropdown || ih->data->has_editbox)
+    {
+      Widget w;
+      XtVaGetValues(ih->handle, XmNtextField, &w, NULL);
+      XtVaSetValues(w, XmNforeground, color, NULL);
+
+      XtVaGetValues(ih->handle, XmNlist, &w, NULL);
+      XtVaSetValues(w, XmNforeground, color, NULL);
+    }
+  }
+
+  return 1;
+}
+
+static char* motListGetValueAttrib(Ihandle* ih)
+{
+  if (ih->data->has_editbox)
+  {
+    char *str, *xstr;
+    Widget cbedit;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    xstr = XmTextFieldGetString(cbedit);
+    str = iupStrGetMemoryCopy(xstr);
+    XtFree(xstr);
+    return str;
+  }
+  else 
+  {
+    if (ih->data->is_dropdown)
+    {
+      char* str;
+      int pos;
+      XtVaGetValues(ih->handle, XmNselectedPosition, &pos, NULL);
+      str = iupStrGetMemory(50);
+      sprintf(str, "%d", pos+1);  /* IUP starts at 1 */
+      return str;
+    }
+    else
+    {
+      int *pos, sel_count;
+      if (XmListGetSelectedPos(ih->handle, &pos, &sel_count))  /* XmListGetSelectedPos starts at 1 */
+      {
+        if (!ih->data->is_multiple)
+        {
+          char* str = iupStrGetMemory(50);
+          sprintf(str, "%d", pos[0]);  
+          XtFree((char*)pos);
+          return str;
+        }
+        else
+        {
+          int i, count;
+          char* str;
+          XtVaGetValues(ih->handle, XmNitemCount, &count, NULL);
+          str = iupStrGetMemory(count+1);
+          memset(str, '-', count);
+          str[count]=0;
+          for (i=0; i<sel_count; i++)
+            str[pos[i]-1] = '+';
+          XtFree((char*)pos);
+          return str;
+        }
+      }
+    }
+  }
+
+  return NULL;
+}
+
+static int motListSetValueAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->has_editbox)
+  {
+    Widget cbedit;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    if (!value) value = "";
+
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1"); /* disable callbacks */
+
+    XmTextFieldSetString(cbedit, (char*)value);
+
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+  else 
+  {
+    if (ih->data->is_dropdown)
+    {
+      int pos;
+      if (iupStrToInt(value, &pos)==1)
+      {
+        XtRemoveCallback(ih->handle, XmNselectionCallback, (XtCallbackProc)motListComboBoxSelectionCallback, (XtPointer)ih);
+
+        XtVaSetValues(ih->handle, XmNselectedPosition, pos-1, NULL);  /* IUP starts at 1 */
+        iupAttribSetInt(ih, "_IUPLIST_OLDVALUE", pos);
+
+        XtAddCallback(ih->handle, XmNselectionCallback, (XtCallbackProc)motListComboBoxSelectionCallback, (XtPointer)ih);
+      }
+    }
+    else
+    {
+      if (!ih->data->is_multiple)
+      {
+        int pos;
+        if (iupStrToInt(value, &pos)==1)
+        {
+          XmListSelectPos(ih->handle, pos, FALSE);   /* XmListSelectPos starts at 1 */
+          iupAttribSetInt(ih, "_IUPLIST_OLDVALUE", pos);
+        }
+        else
+        {
+          XmListDeselectAllItems(ih->handle);
+          iupAttribSetStr(ih, "_IUPLIST_OLDVALUE", NULL);
+        }
+      }
+      else
+      {
+        /* User has changed a multiple selection on a simple list. */
+	      int i, count, len;
+
+        /* Clear all selections */
+        XmListDeselectAllItems(ih->handle);
+
+        if (!value)
+        {
+          iupAttribSetStr(ih, "_IUPLIST_OLDVALUE", NULL);
+          return 0;
+        }
+
+        XtVaGetValues(ih->handle, XmNitemCount, &count, NULL);
+        len = strlen(value);
+        if (len < count) 
+          count = len;
+
+        XtVaSetValues(ih->handle, XmNselectionPolicy, XmMULTIPLE_SELECT, NULL);
+
+        /* update selection list */
+        for (i = 0; i<count; i++)
+        {
+          if (value[i]=='+')
+            XmListSelectPos(ih->handle, i+1, False);  /* XmListSelectPos starts at 1 */
+        }
+
+        XtVaSetValues(ih->handle, XmNselectionPolicy, XmEXTENDED_SELECT, 
+                                  XmNselectionMode, XmNORMAL_MODE, NULL);  /* must also restore this */
+        iupAttribStoreStr(ih, "_IUPLIST_OLDVALUE", value);
+      }
+    }
+  }
+
+  return 0;
+}
+
+static int motListSetVisibleItemsAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->is_dropdown)
+  {
+    int count;
+    if (iupStrToInt(value, &count)==1)
+      XtVaSetValues(ih->handle, XmNvisibleItemCount, count, NULL);
+  }
+  return 1;
+}
+
+static int motListSetShowDropdownAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->is_dropdown)
+  {
+    if (iupStrBoolean(value))
+    {
+      XButtonEvent ev;
+      memset(&ev, 0, sizeof(XButtonEvent));
+      ev.type = ButtonPress;
+      ev.display = XtDisplay(ih->handle);
+      ev.send_event = True;
+      ev.root = RootWindow(iupmot_display, iupmot_screen);
+      ev.time = clock()*CLOCKS_PER_SEC;
+      ev.window = XtWindow(ih->handle);
+      ev.state = Button1Mask;
+      ev.button = Button1;
+      ev.same_screen = True;
+      XtCallActionProc(ih->handle, "CBDropDownList", (XEvent*)&ev, 0, 0 ); 
+    }
+    else
+      XtCallActionProc(ih->handle, "CBDisarm", 0, 0, 0 );
+  }
+  return 0;
+}
+
+static int motListSetTopItemAttrib(Ihandle* ih, const char* value)
+{
+  if (!ih->data->is_dropdown)
+  {
+    int pos = 1;
+    if (iupStrToInt(value, &pos))
+    {
+      if (ih->data->has_editbox)
+      {
+        Widget cblist;
+        XtVaGetValues(ih->handle, XmNlist, &cblist, NULL);
+        XtVaSetValues(cblist, XmNtopItemPosition, pos, NULL);
+      }
+      else
+        XtVaSetValues(ih->handle, XmNtopItemPosition, pos, NULL);
+    }
+  }
+  return 0;
+}
+
+static int motListSetSpacingAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->is_dropdown)
+    return 0;
+
+  if (!iupStrToInt(value, &ih->data->spacing))
+    ih->data->spacing = 0;
+
+  if (ih->handle)
+  {
+    if (ih->data->has_editbox)
+    {
+      Widget cblist;
+      XtVaGetValues(ih->handle, XmNlist, &cblist, NULL);
+      XtVaSetValues(cblist, XmNlistSpacing, ih->data->spacing*2, 
+                            XmNlistMarginWidth, ih->data->spacing, 
+                            XmNlistMarginHeight, ih->data->spacing, 
+                            NULL);
+    }
+    else
+      XtVaSetValues(ih->handle, XmNlistSpacing, ih->data->spacing*2, 
+                                XmNlistMarginWidth, ih->data->spacing, 
+                                XmNlistMarginHeight, ih->data->spacing, 
+                                NULL);
+    return 0;
+  }
+  else
+    return 1; /* store until not mapped, when mapped will be set again */
+}
+
+static int motListSetPaddingAttrib(Ihandle* ih, const char* value)
+{
+  if (!ih->data->has_editbox)
+    return 0;
+
+  iupStrToIntInt(value, &ih->data->horiz_padding, &ih->data->vert_padding, 'x');
+  if (ih->handle)
+  {
+    Widget cbedit;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    XtVaSetValues(cbedit, XmNmarginHeight, ih->data->vert_padding,
+                          XmNmarginWidth, ih->data->horiz_padding, NULL);
+    return 0;
+  }
+  else
+    return 1; /* store until not mapped, when mapped will be set again */
+}
+
+static int motListSetReadOnlyAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->has_editbox)
+  {
+    Widget cbedit;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    XtVaSetValues(cbedit, XmNeditable, iupStrBoolean(value)? False: True, NULL);
+  }
+  return 0;
+}
+
+static char* motListGetReadOnlyAttrib(Ihandle* ih)
+{
+  if (ih->data->has_editbox)
+  {
+    Boolean editable;
+    Widget cbedit;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    XtVaGetValues(cbedit, XmNeditable, &editable, NULL);
+    if (editable)
+      return "YES";
+    else
+      return "NO";
+  }
+  else
+    return NULL;
+}
+
+static int motListSetInsertAttrib(Ihandle* ih, const char* value)
+{
+  if (!value)
+    return 0;
+
+  if (ih->data->has_editbox)
+  {
+    Widget cbedit;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1"); /* disable callbacks */
+    XmTextFieldRemove(cbedit);
+    XmTextFieldInsert(cbedit, XmTextFieldGetInsertionPosition(cbedit), (char*)value);
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+
+  return 0;
+}
+
+static int motListSetSelectedTextAttrib(Ihandle* ih, const char* value)
+{
+  XmTextPosition start, end;
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return 0;
+
+  if (!value)
+    return 0;
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+  if (XmTextFieldGetSelectionPosition(cbedit, &start, &end) && start!=end)
+  {
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1"); /* disable callbacks */
+    XmTextFieldReplace(cbedit, start, end, (char*)value);
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+
+  return 0;
+}
+
+static char* motListGetSelectedTextAttrib(Ihandle* ih)
+{
+  if (ih->data->has_editbox)
+  {
+    char* selectedtext, *str;
+    Widget cbedit;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    selectedtext = XmTextFieldGetSelection(cbedit);
+    str = iupStrGetMemoryCopy(selectedtext);
+    XtFree(selectedtext);
+    return str;
+  }
+  else
+    return NULL;
+}
+
+static int motListSetAppendAttrib(Ihandle* ih, const char* value)
+{
+	if (value && ih->data->has_editbox)
+  {
+    XmTextPosition pos;
+    Widget cbedit;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    pos = XmTextFieldGetLastPosition(cbedit);
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1"); /* disable callbacks */
+    XmTextFieldInsert(cbedit, pos+1, (char*)value);
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+  return 0;
+}
+
+static int motListSetSelectionAttrib(Ihandle* ih, const char* value)
+{
+  int start=1, end=1;
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return 0;
+
+  if (!value || iupStrEqualNoCase(value, "NONE"))
+  {
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    XmTextFieldClearSelection(cbedit, CurrentTime);
+    return 0;
+  }
+
+  if (iupStrEqualNoCase(value, "ALL"))
+  {
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    XmTextFieldSetSelection(cbedit, (XmTextPosition)0, (XmTextPosition)XmTextFieldGetLastPosition(cbedit), CurrentTime);
+    return 0;
+  }
+
+  if (iupStrToIntInt(value, &start, &end, ':')!=2) 
+    return 0;
+
+  if(start<1 || end<1) 
+    return 0;
+
+  start--; /* IUP starts at 1 */
+  end--;
+
+  /* end is inside the selection, in IUP is outside */
+  end--;
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+  XmTextFieldSetSelection(cbedit, (XmTextPosition)start, (XmTextPosition)end, CurrentTime);
+
+  return 0;
+}
+
+static char* motListGetSelectionAttrib(Ihandle* ih)
+{
+  XmTextPosition start = 0, end = 0;
+  char* str;
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return NULL;
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+  if (!XmTextFieldGetSelectionPosition(cbedit, &start, &end) || start==end)
+    return NULL;
+
+  str = iupStrGetMemory(100);
+
+  /* end is inside the selection, in IUP is outside */
+  end++;
+
+  start++; /* IUP starts at 1 */
+  end++;
+  sprintf(str, "%d:%d", (int)start, (int)end);
+
+  return str;
+}
+
+static int motListSetSelectionPosAttrib(Ihandle* ih, const char* value)
+{
+  int start=0, end=0;
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return 0;
+
+  if (!value || iupStrEqualNoCase(value, "NONE"))
+  {
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    XmTextFieldClearSelection(cbedit, CurrentTime);
+    return 0;
+  }
+
+  if (iupStrEqualNoCase(value, "ALL"))
+  {
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    XmTextFieldSetSelection(cbedit, (XmTextPosition)0, (XmTextPosition)XmTextFieldGetLastPosition(cbedit), CurrentTime);
+    return 0;
+  }
+
+  if (iupStrToIntInt(value, &start, &end, ':')!=2) 
+    return 0;
+
+  if(start<0 || end<0) 
+    return 0;
+
+  /* end is inside the selection, in IUP is outside */
+  end--;
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+  XmTextFieldSetSelection(cbedit, (XmTextPosition)start, (XmTextPosition)end, CurrentTime);
+
+  return 0;
+}
+
+static char* motListGetSelectionPosAttrib(Ihandle* ih)
+{
+  XmTextPosition start = 0, end = 0;
+  char* str;
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return NULL;
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+  if (!XmTextFieldGetSelectionPosition(cbedit, &start, &end) || start==end)
+    return NULL;
+
+  str = iupStrGetMemory(100);
+
+  /* end is inside the selection, in IUP is outside */
+  end++;
+
+  sprintf(str, "%d:%d", (int)start, (int)end);
+
+  return str;
+}
+
+static int motListSetCaretAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 1;
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return 0;
+
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  pos--; /* IUP starts at 1 */
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+  XmTextFieldSetInsertionPosition(cbedit, (XmTextPosition)pos);
+  XmTextFieldShowPosition(cbedit, (XmTextPosition)pos);
+
+  return 0;
+}
+
+static char* motListGetCaretAttrib(Ihandle* ih)
+{
+  if (ih->data->has_editbox)
+  {
+    XmTextPosition pos;
+    Widget cbedit;
+    char* str = iupStrGetMemory(50);
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    pos = XmTextFieldGetInsertionPosition(cbedit);
+    pos++; /* IUP starts at 1 */
+    sprintf(str, "%d", (int)pos);
+    return str;
+  }
+  else
+    return NULL;
+}
+
+static int motListSetCaretPosAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 0;
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return 0;
+
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  if (pos < 0) pos = 0;
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+  XmTextFieldSetInsertionPosition(cbedit, (XmTextPosition)pos);
+  XmTextFieldShowPosition(cbedit, (XmTextPosition)pos);
+
+  return 0;
+}
+
+static char* motListGetCaretPosAttrib(Ihandle* ih)
+{
+  if (ih->data->has_editbox)
+  {
+    XmTextPosition pos;
+    Widget cbedit;
+    char* str = iupStrGetMemory(50);
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    pos = XmTextFieldGetInsertionPosition(cbedit);
+    sprintf(str, "%d", (int)pos);
+    return str;
+  }
+  else
+    return NULL;
+}
+
+static int motListSetScrollToAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 1;
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return 0;
+
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  if (pos < 1) pos = 1;
+  pos--;  /* return to Motif referece */
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+  XmTextFieldShowPosition(cbedit, (XmTextPosition)pos);
+
+  return 0;
+}
+
+static int motListSetScrollToPosAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 0;
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return 0;
+
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  if (pos < 0) pos = 0;
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+  XmTextFieldShowPosition(cbedit, (XmTextPosition)pos);
+
+  return 0;
+}
+
+static int motListSetNCAttrib(Ihandle* ih, const char* value)
+{
+  if (!ih->data->has_editbox)
+    return 0;
+
+  if (!iupStrToInt(value, &ih->data->nc))
+    ih->data->nc = INT_MAX;
+
+  if (ih->handle)
+  {
+    Widget cbedit;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    XtVaSetValues(cbedit, XmNmaxLength, ih->data->nc, NULL);
+  }
+  return 0;
+}
+
+static int motListSetClipboardAttrib(Ihandle *ih, const char *value)
+{
+  Widget cbedit;
+  if (!ih->data->has_editbox)
+    return 0;
+
+  XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+
+  if (iupStrEqualNoCase(value, "COPY"))
+  {
+    char *str = XmTextFieldGetSelection(cbedit);
+
+    XmTextFieldCopy(cbedit, CurrentTime);
+
+    /* do it also for the X clipboard */
+    XStoreBytes(iupmot_display, str, strlen(str)+1);
+    XtFree(str);
+  }
+  else if (iupStrEqualNoCase(value, "CUT"))
+  {
+    char *str = XmTextFieldGetSelection(cbedit);
+
+    /* disable callbacks */
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+
+    XmTextFieldCut(cbedit, CurrentTime);
+
+    /* do it also for the X clipboard */
+    XStoreBytes(iupmot_display, str, strlen(str)+1);
+    XtFree(str);
+    XmTextFieldRemove(cbedit);
+
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+  else if (iupStrEqualNoCase(value, "PASTE"))
+  {
+    int size;
+    char* str = XFetchBytes(iupmot_display, &size);
+
+    /* disable callbacks */
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+
+    XmTextFieldPaste(cbedit); /* TODO: this could force 2 pastes, check in CDE */
+
+    /* do it also for the X clipboard */
+    XmTextFieldRemove(cbedit);
+    XmTextFieldInsert(cbedit, XmTextFieldGetInsertionPosition(cbedit), str);
+    XFree(str);
+
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+  else if (iupStrEqualNoCase(value, "CLEAR"))
+  {
+    /* disable callbacks */
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+    XmTextFieldRemove(cbedit);
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+  return 0;
+}
+
+
+/*********************************************************************************/
+
+
+static void motListEditModifyVerifyCallback(Widget cbedit, Ihandle *ih, XmTextVerifyPtr text)
+{
+  int start, end, key = 0;
+  char *value, *new_value, *insert_value;
+  KeySym motcode = 0;
+  IFnis cb;
+
+  if (iupAttribGet(ih, "_IUPMOT_DISABLE_TEXT_CB"))
+    return;
+
+  cb = (IFnis)IupGetCallback(ih, "EDIT_CB");
+  if (!cb && !ih->data->mask)
+    return;
+
+  if (text->event && text->event->type == KeyPress)
+  {
+    unsigned int state = ((XKeyEvent*)text->event)->state;
+    if (state & ControlMask ||  /* Ctrl */
+        state & Mod1Mask || 
+        state & Mod5Mask ||  /* Alt */
+        state & Mod4Mask) /* Apple/Win */
+      return;
+
+    motcode = XKeycodeToKeysym(iupmot_display, ((XKeyEvent*)text->event)->keycode, 0);
+  }
+
+  value = XmTextFieldGetString(cbedit);
+  start = text->startPos;
+  end = text->endPos;
+  insert_value = text->text->ptr;
+
+  if (motcode == XK_Delete)
+  {
+    new_value = value;
+    iupStrRemove(value, start, end, 1);
+  }
+  else if (motcode == XK_BackSpace)
+  {
+    new_value = value;
+    iupStrRemove(value, start, end, -1);
+  }
+  else
+  {
+    if (!value)
+      new_value = iupStrDup(insert_value);
+    else if (insert_value)
+      new_value = iupStrInsert(value, insert_value, start, end);
+    else
+      new_value = value;
+  }
+
+  if (insert_value && insert_value[0]!=0 && insert_value[1]==0)
+    key = insert_value[0];
+
+  if (ih->data->mask && iupMaskCheck(ih->data->mask, new_value)==0)
+  {
+    if (new_value != value) free(new_value);
+    XtFree(value);
+    text->doit = False;     /* abort processing */
+    return;
+  }
+
+  if (cb)
+  {
+    int cb_ret = cb(ih, key, (char*)new_value);
+    if (cb_ret==IUP_IGNORE)
+      text->doit = False;     /* abort processing */
+    else if (cb_ret==IUP_CLOSE)
+    {
+      IupExitLoop();
+      text->doit = False;     /* abort processing */
+    }
+    else if (cb_ret!=0 && key!=0 && 
+             cb_ret != IUP_DEFAULT && cb_ret != IUP_CONTINUE)  
+    {
+      insert_value[0] = (char)cb_ret;  /* replace key */
+    }
+  }
+
+  if (new_value != value) free(new_value);
+  XtFree(value);
+}
+
+static void motListEditMotionVerifyCallback(Widget w, Ihandle* ih, XmTextVerifyCallbackStruct* textverify)
+{
+  int pos;
+
+  IFniii cb = (IFniii)IupGetCallback(ih, "CARET_CB");
+  if (!cb) return;
+
+  pos = textverify->newInsert;
+
+  if (pos != ih->data->last_caret_pos)
+  {
+    ih->data->last_caret_pos = pos;
+    cb(ih, 1, pos+1, pos);
+  }
+
+  (void)w;
+}
+
+static void motListEditKeyPressEvent(Widget cbedit, Ihandle *ih, XKeyEvent *evt, Boolean *cont)
+{
+  *cont = True;
+  iupmotKeyPressEvent(cbedit, ih, (XEvent*)evt, cont);
+  if (*cont == False)
+    return;
+
+  if (evt->state & ControlMask)   /* Ctrl */
+  {
+    KeySym motcode = XKeycodeToKeysym(iupmot_display, evt->keycode, 0);
+    if (motcode == XK_c)
+    {
+      motListSetClipboardAttrib(ih, "COPY");
+      *cont = False;
+      return;
+    }
+    else if (motcode == XK_x)
+    {
+      motListSetClipboardAttrib(ih, "CUT");
+      *cont = False;
+      return;
+    }
+    else if (motcode == XK_v)
+    {
+      motListSetClipboardAttrib(ih, "PASTE");
+      *cont = False;
+      return;
+    }
+    else if (motcode == XK_a)
+    {
+      XmTextFieldSetSelection(cbedit, 0, XmTextFieldGetLastPosition(cbedit), CurrentTime);
+      *cont = False;
+      return;
+    }
+  }
+}
+
+static void motListEditValueChangedCallback(Widget w, Ihandle* ih, XmAnyCallbackStruct* valuechanged)
+{
+  if (iupAttribGet(ih, "_IUPMOT_DISABLE_TEXT_CB"))
+    return;
+
+  iupBaseCallValueChangedCb(ih);
+
+  (void)valuechanged;
+  (void)w;
+}
+
+static void motListDropDownPopupCallback(Widget w, Ihandle* ih, XtPointer call_data)
+{
+  IFni cb = (IFni)IupGetCallback(ih, "DROPDOWN_CB");
+  if (cb)
+    cb(ih, 1);
+  (void)w;
+  (void)call_data;
+}
+
+static void motListDropDownPopdownCallback(Widget w, Ihandle* ih, XtPointer call_data)
+{
+  IFni cb = (IFni)IupGetCallback(ih, "DROPDOWN_CB");
+  if (cb)
+    cb(ih, 0);
+  (void)w;
+  (void)call_data;
+}
+
+static void motListDefaultActionCallback(Widget w, Ihandle* ih, XmListCallbackStruct* call_data)
+{         
+  if (call_data->event->type == ButtonPress || call_data->event->type == ButtonRelease)
+  {
+    IFnis cb = (IFnis) IupGetCallback(ih, "DBLCLICK_CB");
+    if (cb)
+    {
+      int pos = call_data->item_position;  /* Here Motif already starts at 1 */
+      iupListSingleCallDblClickCallback(ih, cb, pos);
+    }
+  }
+
+  (void)w;
+}
+
+static void motListComboBoxSelectionCallback(Widget w, Ihandle* ih, XmComboBoxCallbackStruct* call_data)
+{         
+  IFnsii cb = (IFnsii) IupGetCallback(ih, "ACTION");
+  if (cb)
+  {
+    int pos = call_data->item_position;
+    if (pos==0)
+    {
+      /* must check if it is really checked or it is for the edit box */
+      XmString* items;
+      XtVaGetValues(ih->handle, XmNitems, &items, NULL);
+      if (!XmStringCompare(call_data->item_or_text, items[0]))
+       return;
+    }
+    pos++;  /* IUP starts at 1 */
+    iupListSingleCallActionCallback(ih, cb, pos);
+  }
+
+  if (!ih->data->has_editbox)
+    iupBaseCallValueChangedCb(ih);
+
+  (void)w;
+}
+
+static void motListBrowseSelectionCallback(Widget w, Ihandle* ih, XmListCallbackStruct* call_data)
+{         
+  IFnsii cb = (IFnsii) IupGetCallback(ih, "ACTION");
+  if (cb)
+  {
+    int pos = call_data->item_position;  /* Here Motif already starts at 1 */
+    iupListSingleCallActionCallback(ih, cb, pos);
+  }
+
+  if (!ih->data->has_editbox)
+    iupBaseCallValueChangedCb(ih);
+
+  (void)w;
+}
+
+static void motListExtendedSelectionCallback(Widget w, Ihandle* ih, XmListCallbackStruct* call_data)
+{         
+  IFns multi_cb = (IFns)IupGetCallback(ih, "MULTISELECT_CB");
+  IFnsii cb = (IFnsii) IupGetCallback(ih, "ACTION");
+  if (multi_cb || cb)
+  {
+    int* pos = call_data->selected_item_positions;
+    int sel_count = call_data->selected_item_count;
+    int i;
+
+    /* In Motif, the position of item is "plus one".
+       "iupListMultipleCallActionCallback" works with the list of selected items from the zero position.
+       So, "minus one" here. */
+    for (i = 0; i < sel_count; i++)
+      pos[i] -= 1;
+
+    iupListMultipleCallActionCallback(ih, cb, multi_cb, pos, sel_count);
+  }
+
+  if (!ih->data->has_editbox)
+    iupBaseCallValueChangedCb(ih);
+
+  (void)w;
+}
+
+
+/*********************************************************************************/
+
+
+static int motListMapMethod(Ihandle* ih)
+{
+  int num_args = 0;
+  Arg args[30];
+  Widget parent = iupChildTreeGetNativeParentHandle(ih);
+  char* child_id = iupDialogGetChildIdStr(ih);
+
+  if (ih->data->is_dropdown || ih->data->has_editbox)
+  {
+    /* could not set XmNmappedWhenManaged to False because the list and the edit box where not displayed */
+    /* iupmotSetArg(args, num_args, XmNmappedWhenManaged, False); */
+    iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+    iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+    iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+    iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+    iupmotSetArg(args, num_args, XmNmarginHeight, 0);
+    iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+
+    if (iupAttribGetBoolean(ih, "CANFOCUS"))
+      iupmotSetArg(args, num_args, XmNtraversalOn, True);
+    else
+      iupmotSetArg(args, num_args, XmNtraversalOn, False);
+
+    iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+    iupmotSetArg(args, num_args, XmNhighlightThickness, 2);
+    iupmotSetArg(args, num_args, XmNshadowThickness, 2);
+
+    if (ih->data->has_editbox)
+    {
+      if (ih->data->is_dropdown)
+        iupmotSetArg(args, num_args, XmNcomboBoxType, XmDROP_DOWN_COMBO_BOX);  /* hidden-list+edit */
+      else
+        iupmotSetArg(args, num_args, XmNcomboBoxType, XmCOMBO_BOX);  /* visible-list+edit */
+    }
+    else
+      iupmotSetArg(args, num_args, XmNcomboBoxType, XmDROP_DOWN_LIST);   /* hidden-list */
+
+    ih->handle = XtCreateManagedWidget(
+      child_id,  /* child identifier */
+      xmComboBoxWidgetClass, /* widget class */
+      parent,                      /* widget parent */
+      args, num_args);
+  }
+  else
+  {
+    Widget sb_win;
+
+    /* Create the scrolled window */
+
+    iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+    iupmotSetArg(args, num_args, XmNscrollingPolicy, XmAPPLICATION_DEFINED);
+    iupmotSetArg(args, num_args, XmNvisualPolicy, XmVARIABLE);
+    iupmotSetArg(args, num_args, XmNscrollBarDisplayPolicy, XmSTATIC);   /* can NOT be XmAS_NEEDED because XmAPPLICATION_DEFINED */
+    iupmotSetArg(args, num_args, XmNspacing, 0); /* no space between scrollbars and text */
+    iupmotSetArg(args, num_args, XmNborderWidth, 0);
+    iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+    
+    sb_win = XtCreateManagedWidget(
+      child_id,  /* child identifier */
+      xmScrolledWindowWidgetClass, /* widget class */
+      parent,                      /* widget parent */
+      args, num_args);
+
+    if (!sb_win)
+      return IUP_ERROR;
+
+    parent = sb_win;
+    child_id = "list";
+
+    /* Create the list */
+
+    num_args = 0;
+    iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+    iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+    iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+    iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+
+    if (iupAttribGetBoolean(ih, "CANFOCUS"))
+      iupmotSetArg(args, num_args, XmNtraversalOn, True);
+    else
+      iupmotSetArg(args, num_args, XmNtraversalOn, False);
+
+    iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+    iupmotSetArg(args, num_args, XmNhighlightThickness, 2);
+    iupmotSetArg(args, num_args, XmNshadowThickness, 2);
+
+    iupmotSetArg(args, num_args, XmNlistMarginHeight, 0);  /* default padding */
+    iupmotSetArg(args, num_args, XmNlistMarginWidth, 0);
+    iupmotSetArg(args, num_args, XmNlistSpacing, 0);
+    iupmotSetArg(args, num_args, XmNlistSizePolicy, XmCONSTANT);  /* don't grow to fit, add scrollbar */
+
+    if (ih->data->is_multiple)
+      iupmotSetArg(args, num_args, XmNselectionPolicy, XmEXTENDED_SELECT);
+    else
+      iupmotSetArg(args, num_args, XmNselectionPolicy, XmBROWSE_SELECT);
+
+    if (iupAttribGetBoolean(ih, "AUTOHIDE"))
+      iupmotSetArg(args, num_args, XmNscrollBarDisplayPolicy, XmAS_NEEDED);
+    else
+      iupmotSetArg(args, num_args, XmNscrollBarDisplayPolicy, XmSTATIC);
+
+    ih->handle = XtCreateManagedWidget(
+      child_id,          /* child identifier */
+      xmListWidgetClass, /* widget class */
+      parent,            /* widget parent */
+      args, num_args);
+  }
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  if (ih->data->is_dropdown || ih->data->has_editbox)
+  {
+    Widget cbedit, cblist;
+    XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
+    XtVaGetValues(ih->handle, XmNlist, &cblist, NULL);
+
+    XtAddEventHandler(cbedit, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent, (XtPointer)ih);
+    XtAddEventHandler(cbedit, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+    XtAddEventHandler(cbedit, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+    XtAddCallback(cbedit, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+
+    XtAddCallback(ih->handle, XmNselectionCallback, (XtCallbackProc)motListComboBoxSelectionCallback, (XtPointer)ih);
+
+    if (ih->data->has_editbox)
+    {
+      XtAddEventHandler(cbedit, KeyPressMask, False, (XtEventHandler)motListEditKeyPressEvent, (XtPointer)ih);
+      XtAddCallback(cbedit, XmNmodifyVerifyCallback, (XtCallbackProc)motListEditModifyVerifyCallback, (XtPointer)ih);
+      XtAddCallback(cbedit, XmNmotionVerifyCallback, (XtCallbackProc)motListEditMotionVerifyCallback, (XtPointer)ih);
+      XtAddCallback(cbedit, XmNvalueChangedCallback, (XtCallbackProc)motListEditValueChangedCallback, (XtPointer)ih);
+
+      /* Disable Drag Source */
+      iupmotDisableDragSource(cbedit);
+    }
+    else
+      XtAddEventHandler(cbedit, KeyPressMask, False, (XtEventHandler)iupmotKeyPressEvent, (XtPointer)ih);
+
+    if (ih->data->is_dropdown)
+    {
+      XtVaSetValues(ih->handle, XmNvisibleItemCount, 5, NULL);
+      XtAddCallback(XtParent(XtParent(cblist)), XmNpopupCallback, (XtCallbackProc)motListDropDownPopupCallback, (XtPointer)ih);
+      XtAddCallback(XtParent(XtParent(cblist)), XmNpopdownCallback, (XtCallbackProc)motListDropDownPopdownCallback, (XtPointer)ih);
+    }
+    else
+    {
+      XtAddCallback(cblist, XmNdefaultActionCallback, (XtCallbackProc)motListDefaultActionCallback, (XtPointer)ih);
+      XtAddEventHandler(cblist, PointerMotionMask, False, (XtEventHandler)iupmotPointerMotionEvent, (XtPointer)ih);
+      XtAddEventHandler(cblist, ButtonPressMask|ButtonReleaseMask, False, (XtEventHandler)iupmotButtonPressReleaseEvent, (XtPointer)ih);
+
+      /* Disable Drag Source */
+      iupmotDisableDragSource(cblist);
+    }
+  }
+  else
+  {
+    iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)parent);
+    XtVaSetValues(parent, XmNworkWindow, ih->handle, NULL);
+
+    XtAddEventHandler(ih->handle, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent, (XtPointer)ih);
+    XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+    XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+    XtAddEventHandler(ih->handle, KeyPressMask, False, (XtEventHandler)iupmotKeyPressEvent, (XtPointer)ih);
+    XtAddEventHandler(ih->handle, PointerMotionMask, False, (XtEventHandler)iupmotPointerMotionEvent, (XtPointer)ih);
+    XtAddEventHandler(ih->handle, ButtonPressMask|ButtonReleaseMask, False, (XtEventHandler)iupmotButtonPressReleaseEvent, (XtPointer)ih);
+
+    XtAddCallback(ih->handle, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+    XtAddCallback (ih->handle, XmNbrowseSelectionCallback, (XtCallbackProc)motListBrowseSelectionCallback, (XtPointer)ih);
+    XtAddCallback (ih->handle, XmNextendedSelectionCallback, (XtCallbackProc)motListExtendedSelectionCallback, (XtPointer)ih);
+    XtAddCallback (ih->handle, XmNdefaultActionCallback, (XtCallbackProc)motListDefaultActionCallback, (XtPointer)ih);
+  }
+
+  /* Disable Drag Source */
+  iupmotDisableDragSource(ih->handle);
+
+  /* initialize the widget */
+  if (ih->data->is_dropdown || ih->data->has_editbox)
+    XtRealizeWidget(ih->handle);
+  else
+    XtRealizeWidget(parent);
+
+  if (IupGetGlobal("_IUP_RESET_TXTCOLORS"))
+  {
+    iupmotSetGlobalColorAttrib(ih->handle, XmNbackground, "TXTBGCOLOR");
+    iupmotSetGlobalColorAttrib(ih->handle, XmNforeground, "TXTFGCOLOR");
+    IupSetGlobal("_IUP_RESET_TXTCOLORS", NULL);
+  }
+
+  IupSetCallback(ih, "_IUP_XY2POS_CB", (Icallback)motListConvertXYToPos);
+
+  iupListSetInitialItems(ih);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvListInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motListMapMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, motListSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "TXTBGCOLOR", IUPAF_DEFAULT);
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, motListSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "TXTFGCOLOR", IUPAF_DEFAULT);
+
+  /* IupList only */
+  iupClassRegisterAttributeId(ic, "IDVALUE", motListGetIdValueAttrib, iupListSetIdValueAttrib, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "VALUE", motListGetValueAttrib, motListSetValueAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "VISIBLE_ITEMS", NULL, motListSetVisibleItemsAttrib, IUPAF_SAMEASSYSTEM, "5", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "TOPITEM", NULL, motListSetTopItemAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SHOWDROPDOWN", NULL, motListSetShowDropdownAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SPACING", iupListGetSpacingAttrib, motListSetSpacingAttrib, NULL, NULL, IUPAF_NOT_MAPPED);
+
+  iupClassRegisterAttribute(ic, "PADDING", iupListGetPaddingAttrib, motListSetPaddingAttrib, IUPAF_SAMEASSYSTEM, "0x0", IUPAF_NOT_MAPPED);
+  iupClassRegisterAttribute(ic, "SELECTEDTEXT", motListGetSelectedTextAttrib, motListSetSelectedTextAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SELECTION", motListGetSelectionAttrib, motListSetSelectionAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SELECTIONPOS", motListGetSelectionPosAttrib, motListSetSelectionPosAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "CARET", motListGetCaretAttrib, motListSetCaretAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "CARETPOS", motListGetCaretPosAttrib, motListSetCaretPosAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "INSERT", NULL, motListSetInsertAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "APPEND", NULL, motListSetAppendAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "READONLY", motListGetReadOnlyAttrib, motListSetReadOnlyAttrib, NULL, NULL, IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "NC", iupListGetNCAttrib, motListSetNCAttrib, NULL, NULL, IUPAF_NOT_MAPPED);
+  iupClassRegisterAttribute(ic, "CLIPBOARD", NULL, motListSetClipboardAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SCROLLTO", NULL, motListSetScrollToAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SCROLLTOPOS", NULL, motListSetScrollToPosAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+}
diff --git a/iup/src/mot/iupmot_loop.c b/iup/src/mot/iupmot_loop.c
new file mode 100755
index 0000000..828ddcd
--- /dev/null
+++ b/iup/src/mot/iupmot_loop.c
@@ -0,0 +1,108 @@
+/** \file
+ * \brief Motif Message Loop
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <stdio.h>    
+
+#include <Xm/Xm.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iupmot_drv.h"
+
+
+/* local variables */
+static int mot_mainloop = 0;
+static int mot_exitmainloop = 0;
+static IFidle mot_idle_cb = NULL;
+static XtWorkProcId mot_idle_id;
+
+
+static Boolean motIdlecbWorkProc(XtPointer client_data)
+{
+  (void)client_data;
+  if (mot_idle_cb)
+  {
+    int ret = mot_idle_cb();
+    if (ret == IUP_CLOSE)
+    {
+      mot_idle_cb = NULL;
+      IupExitLoop();
+      return True; /* removes the working procedure */
+    }
+    if (ret == IUP_IGNORE)
+    {
+      mot_idle_cb = NULL;
+      return True; /* removes the working procedure */
+    }
+
+    return False; /* keeps the working procedure */
+  }
+
+  return True; /* removes the working procedure */
+}
+
+void iupdrvSetIdleFunction(Icallback f)
+{
+  if (mot_idle_cb)
+    XtRemoveWorkProc(mot_idle_id);
+
+  mot_idle_cb = (IFidle)f;
+
+  if (mot_idle_cb)
+    mot_idle_id = XtAppAddWorkProc(iupmot_appcontext, motIdlecbWorkProc, NULL);
+}
+
+static int motLoopStep(void)
+{
+  XtAppProcessEvent(iupmot_appcontext, XtIMAll);
+  return (mot_exitmainloop)? IUP_CLOSE : IUP_DEFAULT;
+}
+
+void IupExitLoop(void)
+{
+  mot_exitmainloop = 1;
+}
+
+int IupMainLoopLevel(void)
+{
+  return mot_mainloop;
+}
+
+int IupMainLoop(void)
+{
+  mot_mainloop++;
+  mot_exitmainloop = 0;
+
+  while (!mot_exitmainloop)
+  {
+    if (motLoopStep() == IUP_CLOSE)
+      break;
+  }
+
+  mot_exitmainloop = 0;
+  mot_mainloop--;
+  return IUP_NOERROR;
+}
+
+int IupLoopStep(void)
+{
+  if (!XtAppPending(iupmot_appcontext)) 
+    return IUP_DEFAULT;
+
+  return motLoopStep();
+}
+
+void IupFlush(void)
+{
+  while (XPending(iupmot_display) != 0)
+  {
+    if (motLoopStep() == IUP_CLOSE)
+      break;
+  }
+
+  XFlush(iupmot_display);
+}
diff --git a/iup/src/mot/iupmot_menu.c b/iup/src/mot/iupmot_menu.c
new file mode 100755
index 0000000..be9b953
--- /dev/null
+++ b/iup/src/mot/iupmot_menu.c
@@ -0,0 +1,457 @@
+/** \file
+ * \brief Menu Resources
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/RowColumn.h>
+#include <Xm/Separator.h>
+#include <Xm/CascadeB.h>
+#include <Xm/ToggleB.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_dialog.h"
+#include "iup_str.h"
+#include "iup_label.h"
+#include "iup_drv.h"
+#include "iup_drvfont.h"
+#include "iup_image.h"
+#include "iup_menu.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+static int mot_menu_exitloop = 0;
+
+int iupdrvMenuPopup(Ihandle* ih, int x, int y)
+{
+  XButtonEvent ev;
+  ev.x_root = x;
+  ev.y_root = y;
+  XmMenuPosition(ih->handle, &ev);
+
+  XtManageChild(ih->handle);
+
+  mot_menu_exitloop = 0;
+  while (!mot_menu_exitloop)
+    XtAppProcessEvent(iupmot_appcontext, XtIMAll);
+  mot_menu_exitloop = 0;
+
+  return IUP_NOERROR;
+}
+
+int iupdrvMenuGetMenuBarSize(Ihandle* ih)
+{
+  int ch;
+  iupdrvFontGetCharSize(ih, NULL, &ch);
+  return 5 + ch + 5;
+}
+
+
+/*******************************************************************************************/
+
+
+static void motItemActivateCallback(Widget w, Ihandle* ih, XtPointer call_data)
+{
+  Icallback cb;
+
+  if (XmIsToggleButton(ih->handle) && !iupAttribGetBoolean(ih, "AUTOTOGGLE") && !iupAttribGetBoolean(ih->parent, "RADIO"))
+  {
+    /* Motif by default will do autotoggle */
+    XmToggleButtonSetState(ih->handle, !XmToggleButtonGetState(ih->handle),0);
+  }
+
+  cb = IupGetCallback(ih, "ACTION");
+  if (cb && cb(ih)==IUP_CLOSE)
+    IupExitLoop();
+
+  (void)w;
+  (void)call_data;
+}
+
+static void motItemArmCallback(Widget w, Ihandle* ih, XtPointer call_data)
+{
+  Icallback cb = IupGetCallback(ih, "HIGHLIGHT_CB");
+  if (cb)
+    cb(ih);
+
+  (void)w;
+  (void)call_data;
+}
+
+static void motMenuMapCallback(Widget w, Ihandle* ih, XtPointer call_data)
+{
+  Icallback cb = IupGetCallback(ih, "OPEN_CB");
+  if (!cb && ih->parent) cb = (Icallback)IupGetCallback(ih->parent, "OPEN_CB");  /* check also in the Submenu */
+  if (cb) cb(ih);
+
+  (void)w;
+  (void)call_data;
+}
+
+static void motMenuUnmapCallback(Widget w, Ihandle* ih, XtPointer call_data)
+{
+  Icallback cb = IupGetCallback(ih, "MENUCLOSE_CB");
+  if (!cb && ih->parent) cb = (Icallback)IupGetCallback(ih->parent, "MENUCLOSE_CB");  /* check also in the Submenu */
+  if (cb) cb(ih);
+
+  (void)w;
+  (void)call_data;
+}
+
+static void motPopupMenuUnmapCallback(Widget w, Ihandle* ih, XtPointer call_data)
+{
+  motMenuUnmapCallback(w, ih, call_data);
+  mot_menu_exitloop = 1;
+}
+
+
+/*******************************************************************************************/
+
+
+static void motMenuUnMapMethod(Ihandle* ih)
+{
+  if (iupMenuIsMenuBar(ih))
+    XtDestroyWidget(ih->handle);
+  else
+    XtDestroyWidget(XtParent(ih->handle));  /* in this case the RowColumn widget is a child of a MenuShell. */
+}
+
+static int motMenuMapMethod(Ihandle* ih)
+{
+  int num_args = 0;
+  Arg args[30];
+
+  if (iupMenuIsMenuBar(ih))
+  {
+    /* top level menu used for MENU attribute in IupDialog (a menu bar) */
+
+    ih->handle = XtVaCreateManagedWidget(
+                   iupMenuGetChildIdStr(ih),
+                   xmRowColumnWidgetClass, 
+                   iupChildTreeGetNativeParentHandle(ih),
+                   XmNrowColumnType, XmMENU_BAR,
+                   XmNmarginHeight, 0,
+                   XmNmarginWidth, 0,
+                   XmNresizeWidth, False,
+                   NULL);
+    if (!ih->handle)
+      return IUP_ERROR;
+  }
+  else
+  {
+    /* all XmCreate* functions here, also create RowColumn Widgets. */
+
+    if (ih->parent)
+    {
+      /* parent is a submenu */
+
+      if (iupAttribGetBoolean(ih, "RADIO"))
+      {
+        iupmotSetArg(args, num_args, XmNpacking, XmPACK_COLUMN);
+        iupmotSetArg(args, num_args, XmNradioBehavior, TRUE);
+      }
+
+      ih->handle = XmCreatePulldownMenu(
+                     ih->parent->handle, 
+                     iupMenuGetChildIdStr(ih),
+                     args,
+                     num_args);
+      if (!ih->handle)
+        return IUP_ERROR;
+
+      /* update the CascadeButton */
+      XtVaSetValues(ih->parent->handle, XmNsubMenuId, ih->handle, NULL);  
+
+      XtAddCallback(ih->handle, XmNmapCallback, (XtCallbackProc)motMenuMapCallback, (XtPointer)ih);
+      XtAddCallback(ih->handle, XmNunmapCallback, (XtCallbackProc)motMenuUnmapCallback, (XtPointer)ih);
+    }
+    else
+    {
+      /* top level menu used for IupPopup */
+
+      iupmotSetArg(args, num_args, XmNpopupEnabled, XmPOPUP_AUTOMATIC);
+
+      ih->handle = XmCreatePopupMenu(
+                     iupmot_appshell, 
+                     iupMenuGetChildIdStr(ih),
+                     args,
+                     num_args);
+      if (!ih->handle)
+        return IUP_ERROR;
+
+      XtAddCallback(ih->handle, XmNmapCallback, (XtCallbackProc)motMenuMapCallback, (XtPointer)ih);
+      XtAddCallback(ih->handle, XmNunmapCallback, (XtCallbackProc)motPopupMenuUnmapCallback, (XtPointer)ih);
+    }
+  }
+
+  ih->serial = iupMenuGetChildId(ih); /* must be after using the string */
+
+  return IUP_NOERROR;
+}
+
+void iupdrvMenuInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motMenuMapMethod;
+  ic->UnMap = motMenuUnMapMethod;
+
+  /* Used by iupdrvMenuGetMenuBarSize */
+  iupClassRegisterAttribute(ic, "STANDARDFONT", NULL, NULL, IUPAF_SAMEASSYSTEM, "DEFAULTFONT", IUPAF_DEFAULT);  /* use inheritance to retrieve standard fonts */
+
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, iupdrvBaseSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+}
+
+
+/*******************************************************************************************/
+
+
+static int motItemSetTitleImageAttrib(Ihandle* ih, const char* value)
+{
+  iupmotSetPixmap(ih, value, XmNlabelPixmap, 0);
+  return 1;
+}
+
+static int motItemSetTitleAttrib(Ihandle* ih, const char* value)
+{
+  char *str;
+
+  if (!value)
+  {
+    str = "     ";
+    value = str;
+  }
+  else
+    str = iupMenuProcessTitle(ih, value);
+
+  if (XmIsToggleButton(ih->handle))
+  {
+    char *p = strchr(str, '\t');
+    if (p)
+    {
+      int offset = (p-str);
+      char* new_value = iupStrDup(str);
+      char* acc_value = new_value + offset + 1;
+      new_value[offset] = 0;
+      iupmotSetMnemonicTitle(ih, new_value);
+      iupmotSetString(ih->handle, XmNacceleratorText, acc_value);
+      free(new_value);
+
+      if (str != value) free(str);
+      return 1;
+    }
+  }
+
+  iupmotSetMnemonicTitle(ih, str);
+
+  if (str != value) free(str);
+  return 1;
+}
+
+static int motItemSetValueAttrib(Ihandle* ih, const char* value)
+{
+  if (XmIsToggleButton(ih->handle))
+  {
+    if (iupAttribGetBoolean(ih->parent, "RADIO"))
+      value = "ON";
+
+    XmToggleButtonSetState(ih->handle, iupStrBoolean(value),0);
+  }
+  return 0;
+}
+
+static char* motItemGetValueAttrib(Ihandle* ih)
+{
+  if (XmIsToggleButton(ih->handle) && XmToggleButtonGetState(ih->handle))
+    return "ON";
+  else
+    return "OFF";
+}
+
+static int motItemMapMethod(Ihandle* ih)
+{
+  int pos;
+
+  if (!ih->parent)
+    return IUP_ERROR;
+
+  /* Menu bar can contain only CascadeButtons */
+  if (iupMenuIsMenuBar(ih->parent))
+  {
+    ih->handle = XtVaCreateManagedWidget(
+                   iupMenuGetChildIdStr(ih),
+                   xmCascadeButtonWidgetClass, 
+                   ih->parent->handle,
+                   NULL);
+
+    XtAddCallback(ih->handle, XmNactivateCallback, (XtCallbackProc)motItemActivateCallback, (XtPointer)ih);
+    XtAddCallback(ih->handle, XmNcascadingCallback, (XtCallbackProc)motItemArmCallback, (XtPointer)ih);
+  }
+  else
+  {
+    int num_args = 0;
+    Arg args[10];
+
+    if (iupAttribGetBoolean(ih->parent, "RADIO"))
+    {
+      iupmotSetArg(args, num_args, XmNtoggleMode, XmTOGGLE_BOOLEAN);
+      iupmotSetArg(args, num_args, XmNindicatorType, XmONE_OF_MANY_ROUND);
+      iupmotSetArg(args, num_args, XmNindicatorOn, XmINDICATOR_CHECK_BOX);
+      iupmotSetArg(args, num_args, XmNindicatorSize, 13);
+      iupmotSetArg(args, num_args, XmNselectColor, iupmotColorGetPixel(0, 0, 0));
+    }
+    else
+    {
+      if (iupAttribGetBoolean(ih, "HIDEMARK"))
+        iupmotSetArg(args, num_args, XmNindicatorOn, XmINDICATOR_NONE);
+      else
+        iupmotSetArg(args, num_args, XmNindicatorOn, XmINDICATOR_CHECK);
+      iupmotSetArg(args, num_args, XmNlabelType, iupAttribGet(ih, "TITLEIMAGE")? XmPIXMAP: XmSTRING);
+    }
+
+    ih->handle = XtCreateManagedWidget(
+                   iupMenuGetChildIdStr(ih),
+                   xmToggleButtonWidgetClass, 
+                   ih->parent->handle,
+                   args,
+                   num_args);
+
+    XtAddCallback(ih->handle, XmNvalueChangedCallback, (XtCallbackProc)motItemActivateCallback, (XtPointer)ih);
+    XtAddCallback(ih->handle, XmNarmCallback, (XtCallbackProc)motItemArmCallback, (XtPointer)ih);
+  }
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupMenuGetChildId(ih); /* must be after using the string */
+
+  XtAddCallback (ih->handle, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+
+  pos = IupGetChildPos(ih->parent, ih);
+  XtVaSetValues(ih->handle, XmNpositionIndex, pos, NULL);   /* RowColumn Constraint */
+
+  iupUpdateStandardFontAttrib(ih);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvItemInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motItemMapMethod;
+  ic->UnMap = iupdrvBaseUnMapMethod;
+
+  /* Common */
+  iupClassRegisterAttribute(ic, "STANDARDFONT", NULL, iupdrvSetStandardFontAttrib, IUPAF_SAMEASSYSTEM, "DEFAULTFONT", IUPAF_NOT_MAPPED);  /* use inheritance to retrieve standard fonts */
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "ACTIVE", iupBaseGetActiveAttrib, iupBaseSetActiveAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, iupdrvBaseSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+
+  /* IupItem only */
+  iupClassRegisterAttribute(ic, "VALUE", motItemGetValueAttrib, motItemSetValueAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "TITLE", NULL, motItemSetTitleAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "TITLEIMAGE", NULL, motItemSetTitleImageAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+
+  /* IupItem Gtk and Motif only */
+  iupClassRegisterAttribute(ic, "HIDEMARK", NULL, NULL, NULL, NULL, IUPAF_NOT_MAPPED);
+}
+
+
+/*******************************************************************************************/
+
+
+static int motSubmenuMapMethod(Ihandle* ih)
+{
+  int pos;
+
+  if (!ih->parent)
+    return IUP_ERROR;
+
+  ih->handle = XtVaCreateManagedWidget(
+                 iupMenuGetChildIdStr(ih),
+                 xmCascadeButtonWidgetClass, 
+                 ih->parent->handle,
+                 NULL);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupMenuGetChildId(ih); /* must be after using the string */
+
+  pos = IupGetChildPos(ih->parent, ih);
+  XtVaSetValues(ih->handle, XmNpositionIndex, pos, NULL);   /* RowColumn Constraint */
+
+  XtAddCallback(ih->handle, XmNcascadingCallback, (XtCallbackProc)motItemArmCallback, (XtPointer)ih);
+
+  iupUpdateStandardFontAttrib(ih);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvSubmenuInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motSubmenuMapMethod;
+  ic->UnMap = iupdrvBaseUnMapMethod;
+
+  /* Common */
+  iupClassRegisterAttribute(ic, "STANDARDFONT", NULL, iupdrvSetStandardFontAttrib, IUPAF_SAMEASSYSTEM, "DEFAULTFONT", IUPAF_NOT_MAPPED);  /* use inheritance to retrieve standard fonts */
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "ACTIVE", iupBaseGetActiveAttrib, iupBaseSetActiveAttrib, IUPAF_SAMEASSYSTEM, "YES", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, iupdrvBaseSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+
+  /* IupSubmenu only */
+  iupClassRegisterAttribute(ic, "TITLE", NULL, motItemSetTitleAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+}
+
+
+/*******************************************************************************************/
+
+
+static int motSeparatorMapMethod(Ihandle* ih)
+{
+  int pos;
+
+  if (!ih->parent)
+    return IUP_ERROR;
+
+  ih->handle = XtVaCreateManagedWidget(
+                 iupMenuGetChildIdStr(ih),
+                 xmSeparatorWidgetClass, 
+                 ih->parent->handle,
+                 NULL);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupMenuGetChildId(ih); /* must be after using the string */
+
+  pos = IupGetChildPos(ih->parent, ih);
+  XtVaSetValues(ih->handle, XmNpositionIndex, pos, NULL);  /* RowColumn Constraint */
+
+  return IUP_NOERROR;
+}
+
+void iupdrvSeparatorInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motSeparatorMapMethod;
+  ic->UnMap = iupdrvBaseUnMapMethod;
+
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, iupdrvBaseSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+}
diff --git a/iup/src/mot/iupmot_messagedlg.c b/iup/src/mot/iupmot_messagedlg.c
new file mode 100755
index 0000000..6660503
--- /dev/null
+++ b/iup/src/mot/iupmot_messagedlg.c
@@ -0,0 +1,191 @@
+/** \file
+ * \brief Motif IupMessageDlg pre-defined dialog
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <Xm/Xm.h>
+#include <Xm/MwmUtil.h>
+#include <Xm/MessageB.h>
+#include <Xm/Protocols.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_drvinfo.h"
+#include "iup_dialog.h"
+#include "iup_strmessage.h"
+
+#include "iupmot_drv.h"
+
+
+static void motMessageDlgDeleteWindowCallback(Widget w, XtPointer client_data, XtPointer call_data)
+{
+  Ihandle *ih = (Ihandle*)client_data;
+  if (!ih) return;
+  (void)call_data;
+  (void)w;
+  if (iupStrEqualNoCase(iupAttribGetStr(ih, "BUTTONS"), "OK"))
+    iupAttribSetStr(ih, "BUTTONRESPONSE", "1");
+  else
+    iupAttribSetStr(ih, "BUTTONRESPONSE", "2");
+  iupAttribSetStr(ih, "_IUP_WM_DELETE", "1");
+}
+
+static void motMessageDlgCallback(Widget w, Ihandle* ih, XmAnyCallbackStruct* call_data)
+{
+  (void)w;
+  if (call_data->reason == XmCR_OK)
+    iupAttribSetStr(ih, "BUTTONRESPONSE", "1");
+  else if (call_data->reason == XmCR_CANCEL)
+    iupAttribSetStr(ih, "BUTTONRESPONSE", "2");
+}
+
+static void motMessageDlgHelpCallback(Widget w, XtPointer client_data, XtPointer call_data)
+{
+  Ihandle *ih = (Ihandle*)client_data;
+  Icallback cb = (Icallback)IupGetCallback(ih, "HELP_CB");
+  if (cb && cb(ih) == IUP_CLOSE)
+  {
+    if (iupStrEqualNoCase(iupAttribGetStr(ih, "BUTTONS"), "OK"))
+      iupAttribSetStr(ih, "BUTTONRESPONSE", "1");
+    else
+      iupAttribSetStr(ih, "BUTTONRESPONSE", "2");
+  }
+
+  (void)call_data;
+  (void)w;
+}
+
+static int motMessageDlgPopup(Ihandle* ih, int x, int y)
+{
+  InativeHandle* parent = iupDialogGetNativeParent(ih);
+  Widget msgbox, dialog;
+  int style = XmDIALOG_FULL_APPLICATION_MODAL;
+  int type = XmDIALOG_MESSAGE;
+  int num_but = 2;
+  char *value;
+
+  iupAttribSetInt(ih, "_IUPDLG_X", x);   /* used in iupDialogUpdatePosition */
+  iupAttribSetInt(ih, "_IUPDLG_Y", y);
+
+  if (parent)
+  {
+    msgbox = XmCreateMessageDialog(parent, "messagedialog", NULL, 0);
+    dialog = XtParent(msgbox);
+  }
+  else
+  {
+    dialog = XtAppCreateShell(NULL, "messagedialog", topLevelShellWidgetClass, iupmot_display, NULL, 0);
+    msgbox = XmCreateMessageBox(dialog, "messagebox", NULL, 0);
+    style = XmDIALOG_MODELESS;
+    XtVaSetValues(dialog,
+      XmNmwmInputMode, MWM_INPUT_FULL_APPLICATION_MODAL,
+      XmNmappedWhenManaged, False,
+      XmNsaveUnder, True,
+      NULL);
+  }
+  if (!msgbox)
+    return IUP_NOERROR;
+
+  value = iupAttribGetStr(ih, "DIALOGTYPE");
+  if (iupStrEqualNoCase(value, "ERROR"))
+    type = XmDIALOG_ERROR;
+  else if (iupStrEqualNoCase(value, "WARNING"))
+    type = XmDIALOG_WARNING;
+  else if (iupStrEqualNoCase(value, "INFORMATION"))
+    type = XmDIALOG_INFORMATION;
+  else if (iupStrEqualNoCase(value, "QUESTION"))
+    type = XmDIALOG_QUESTION;
+
+
+  value = iupAttribGet(ih, "TITLE");
+  if (value)
+    iupmotSetString(msgbox, XmNdialogTitle, value);
+  else
+  {
+    if (parent)
+    {
+      XmString title;
+      XtVaGetValues(parent, XmNdialogTitle, &title, NULL);
+      XtVaSetValues(msgbox, XmNdialogTitle, title, NULL);
+    }
+  }
+
+  value = iupAttribGet(ih, "VALUE");
+  if (value)
+    iupmotSetString(msgbox, XmNmessageString, value);
+
+  XtVaSetValues(msgbox,
+                XmNdialogType, type,
+                XmNdialogStyle, style,
+                XmNautoUnmanage, False,
+                XmNnoResize, True,
+                NULL);
+
+  value = iupAttribGetStr(ih, "BUTTONS");
+  if (iupStrEqualNoCase(value, "OK"))
+  {
+    XtUnmanageChild(XmMessageBoxGetChild(msgbox, XmDIALOG_CANCEL_BUTTON));
+    num_but = 1;
+  }
+  else if (iupStrEqualNoCase(value, "YESNO"))
+  {
+    iupmotSetString(msgbox, XmNokLabelString, iupStrMessageGet("IUP_YES"));
+    iupmotSetString(msgbox, XmNcancelLabelString, iupStrMessageGet("IUP_NO"));
+  }
+
+  if (!IupGetCallback(ih, "HELP_CB"))
+    XtUnmanageChild(XmMessageBoxGetChild(msgbox, XmDIALOG_HELP_BUTTON));
+
+  if (num_but == 2 && iupAttribGetInt(ih, "BUTTONDEFAULT") == 2)
+    XtVaSetValues(msgbox, XmNdefaultButtonType, XmDIALOG_CANCEL_BUTTON, NULL);
+  else
+    XtVaSetValues(msgbox, XmNdefaultButtonType, XmDIALOG_OK_BUTTON, NULL);
+
+  XtAddCallback(msgbox, XmNokCallback, (XtCallbackProc)motMessageDlgCallback, (XtPointer)ih);
+  XtAddCallback(msgbox, XmNcancelCallback, (XtCallbackProc)motMessageDlgCallback, (XtPointer)ih);
+  XtAddCallback(msgbox, XmNhelpCallback, (XtCallbackProc)motMessageDlgHelpCallback, (XtPointer)ih);
+
+  XmAddWMProtocolCallback(dialog, iupmot_wm_deletewindow, motMessageDlgDeleteWindowCallback, (XtPointer)ih);
+  XtManageChild(msgbox);
+
+  XtRealizeWidget(dialog);
+  ih->handle = dialog;
+  iupDialogUpdatePosition(ih);
+  ih->handle = NULL;  /* reset handle */
+
+  if (style == XmDIALOG_MODELESS)
+    XtPopup(dialog, XtGrabExclusive);
+
+  /* while the user hasn't provided an answer, simulate main loop.
+  ** The answer changes as soon as the user selects one of the
+  ** buttons and the callback routine changes its value. */
+  iupAttribSetStr(ih, "BUTTONRESPONSE", NULL);
+  while (iupAttribGet(ih, "BUTTONRESPONSE") == NULL)
+    XtAppProcessEvent(iupmot_appcontext, XtIMAll);
+
+  if (!iupAttribGet(ih, "_IUP_WM_DELETE"))
+  {
+    XtUnmanageChild(msgbox);
+
+    if (style == XmDIALOG_MODELESS)
+    {
+      XtPopdown(dialog);
+      XtDestroyWidget(dialog);
+    }
+  }
+
+  return IUP_NOERROR;
+}
+
+void iupdrvMessageDlgInitClass(Iclass* ic)
+{
+  ic->DlgPopup = motMessageDlgPopup;
+}
diff --git a/iup/src/mot/iupmot_open.c b/iup/src/mot/iupmot_open.c
new file mode 100755
index 0000000..a59dbff
--- /dev/null
+++ b/iup/src/mot/iupmot_open.c
@@ -0,0 +1,141 @@
+/** \file
+ * \brief Motif Open/Close
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <stdlib.h>    
+#include <stdio.h>    
+#include <locale.h>
+#include <string.h>    
+
+#include <Xm/Xm.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_str.h"
+#include "iup_drv.h"
+#include "iup_globalattrib.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+/* global variables */
+Widget   iupmot_appshell = 0;
+Display* iupmot_display = 0;
+int      iupmot_screen = 0;
+Visual*  iupmot_visual = 0;
+XtAppContext iupmot_appcontext = 0;
+
+void* iupdrvGetDisplay(void)
+{
+  return iupmot_display;
+}
+
+void iupmotSetGlobalColorAttrib(Widget w, const char* xmname, const char* name)
+{
+  unsigned char r, g, b; 
+  Pixel color;
+
+  XtVaGetValues(w, xmname, &color, NULL);
+  iupmotColorGetRGB(color, &r, &g, &b);
+
+  iupGlobalSetDefaultColorAttrib(name, r, g, b);
+}
+
+int iupdrvOpen(int *argc, char ***argv)
+{
+  IupSetGlobal("DRIVER", "Motif");
+
+  /* XtSetLanguageProc(NULL, NULL, NULL); 
+     Removed to avoid invalid locale in modern Linux that set LANG=en_US.UTF-8 */
+
+  /* We do NOT use XtVaOpenApplication because it crashes when using internal dummy argc and argv.
+     iupmot_appshell = XtVaOpenApplication(&iupmot_appcontext, "Iup", NULL, 0, argc, *argv, NULL,
+                                           sessionShellWidgetClass, NULL); */
+
+  XtToolkitInitialize();
+
+  iupmot_appcontext = XtCreateApplicationContext();
+
+  iupmot_display = XtOpenDisplay(iupmot_appcontext, NULL, NULL, "Iup", NULL, 0, argc, *argv);   
+  if (!iupmot_display)
+  {
+    fprintf (stderr, "IUP error: cannot open display.\n");
+    return IUP_ERROR;
+  }
+
+  iupmot_appshell = XtAppCreateShell(NULL, "Iup", sessionShellWidgetClass, iupmot_display, NULL, 0);
+  if (!iupmot_appshell)
+  {
+    fprintf(stderr, "IUP error: cannot create shell.\n");
+    return IUP_ERROR;
+  }
+  IupSetGlobal("APPSHELL", (char*)iupmot_appshell);
+
+  IupStoreGlobal("SYSTEMLANGUAGE", setlocale(LC_ALL, NULL));
+
+  iupmot_screen  = XDefaultScreen(iupmot_display);
+
+  IupSetGlobal("XDISPLAY", (char*)iupmot_display);
+  IupSetGlobal("XSCREEN", (char*)iupmot_screen);
+
+  /* screen depth can be 8bpp, but canvas can be 24bpp */
+  {
+    XVisualInfo vinfo;
+    if (XMatchVisualInfo(iupmot_display, iupmot_screen, 24, TrueColor, &vinfo) ||
+        XMatchVisualInfo(iupmot_display, iupmot_screen, 16, TrueColor, &vinfo))
+    {
+      iupmot_visual = vinfo.visual;
+      IupSetGlobal("TRUECOLORCANVAS", "YES");
+    }
+    else
+    {
+      iupmot_visual = DefaultVisual(iupmot_display, iupmot_screen);
+      IupSetGlobal("TRUECOLORCANVAS", "NO");
+    }
+  }
+
+  /* driver system version */
+  {
+    int major = xmUseVersion/1000;
+    int minor = xmUseVersion - major * 1000;
+    IupSetfAttribute(NULL, "MOTIFVERSION", "%d.%d", major, minor);
+    IupSetfAttribute(NULL, "MOTIFNUMBER", "%d", (XmVERSION * 1000 + XmREVISION * 100 + XmUPDATE_LEVEL));
+
+    IupSetGlobal("XSERVERVENDOR", ServerVendor(iupmot_display));
+    IupSetfAttribute(NULL, "XVENDORRELEASE", "%d", VendorRelease(iupmot_display));
+  }
+
+  iupmotColorInit();
+
+  /* dialog background color */
+  {
+    iupmotSetGlobalColorAttrib(iupmot_appshell, XmNbackground, "DLGBGCOLOR");
+    iupGlobalSetDefaultColorAttrib("DLGFGCOLOR", 0, 0, 0);
+    IupSetGlobal("_IUP_RESET_DLGBGCOLOR", "YES");  /* will update the DLGFGCOLOR when the first dialog is mapped */
+
+    iupGlobalSetDefaultColorAttrib("TXTBGCOLOR", 255, 255, 255);
+    iupGlobalSetDefaultColorAttrib("TXTFGCOLOR", 0, 0, 0);
+    IupSetGlobal("_IUP_RESET_TXTCOLORS", "YES");   /* will update the TXTCOLORS when the first text or list is mapped */
+  }
+
+  if (getenv("IUP_DEBUG"))
+    XSynchronize(iupmot_display, 1);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvClose(void)
+{ 
+  iupmotColorFinish();
+  iupmotTipsFinish();
+
+  if (iupmot_appshell)
+    XtDestroyWidget(iupmot_appshell);
+
+  if (iupmot_appcontext)
+    XtDestroyApplicationContext(iupmot_appcontext);
+}
diff --git a/iup/src/mot/iupmot_progressbar.c b/iup/src/mot/iupmot_progressbar.c
new file mode 100755
index 0000000..7266d38
--- /dev/null
+++ b/iup/src/mot/iupmot_progressbar.c
@@ -0,0 +1,165 @@
+/** \file
+* \brief Progress bar Control
+*
+* See Copyright Notice in "iup.h"
+*/
+
+#include <Xm/Xm.h>
+#include <Xm/Scale.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+#include <limits.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_dialog.h"
+#include "iup_str.h"
+#include "iup_progressbar.h"
+#include "iup_drv.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+static int motProgressBarSetValueAttrib(Ihandle* ih, const char* value)
+{
+  if (!value)
+    ih->data->value = 0;
+  else
+    ih->data->value = atof(value);
+  iProgressBarCropValue(ih);
+
+  XtVaSetValues(ih->handle, XmNvalue, (int)(SHRT_MAX * (ih->data->value - ih->data->vmin) / (ih->data->vmax - ih->data->vmin)), NULL);
+
+  return 0;
+}
+
+static int motProgressBarSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  if (!iupAttribGetStr(ih, "FGCOLOR"))
+  {
+    Pixel color;
+    unsigned char r, g, b;
+    if (!iupStrToRGB(value, &r, &g, &b))
+      return 0;
+
+    r = (r*8)/10;
+    g = (g*8)/10;
+    b = (b*8)/10;
+
+    color = iupmotColorGetPixel(r, g, b);
+    if (color != (Pixel)-1)
+    {
+      Widget w = XtNameToWidget(ih->handle, "*Scrollbar");
+      XtVaSetValues(w, XmNtroughColor, color, NULL);
+    }
+  }
+
+  return iupdrvBaseSetBgColorAttrib(ih, value);
+}
+
+
+static int motProgressBarSetFgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    Widget w = XtNameToWidget(ih->handle, "*Scrollbar");
+    XtVaSetValues(w, XmNtroughColor, color, NULL);
+  }
+
+  return 1;
+}
+
+static void motProgressBarLayoutUpdateMethod(Ihandle *ih)
+{
+  unsigned char orientation;
+  XtVaGetValues(ih->handle, XmNorientation, &orientation, NULL);
+
+  if (orientation == XmVERTICAL)
+    XtVaSetValues(ih->handle, XmNscaleWidth, ih->currentwidth, NULL);
+  else
+    XtVaSetValues(ih->handle, XmNscaleHeight, ih->currentheight, NULL);
+
+  iupdrvBaseLayoutUpdateMethod(ih);
+}
+
+static int motProgressBarMapMethod(Ihandle* ih)
+{
+  int num_args = 0;
+  Arg args[30];
+ 
+  /* Core */
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+  /* Primitive */
+  iupmotSetArg(args, num_args, XmNtraversalOn, False);
+  iupmotSetArg(args, num_args, XmNhighlightThickness, 0);
+  /* Scale */
+  iupmotSetArg(args, num_args, XmNminimum,   0);
+  iupmotSetArg(args, num_args, XmNmaximum, SHRT_MAX);
+  iupmotSetArg(args, num_args, XmNslidingMode, XmTHERMOMETER); /* thermometer effect */
+  iupmotSetArg(args, num_args, XmNsliderMark, XmNONE);
+  iupmotSetArg(args, num_args, XmNeditable, False);
+  iupmotSetArg(args, num_args, XmNshowValue, XmNONE);
+
+  if (iupStrEqualNoCase(iupAttribGetStr(ih, "ORIENTATION"), "VERTICAL"))
+  {
+    iupmotSetArg(args, num_args, XmNorientation, XmVERTICAL);
+
+    if (ih->currentheight < ih->currentwidth)
+    {
+      int tmp = ih->currentheight;
+      ih->currentheight = ih->currentwidth;
+      ih->currentwidth = tmp;
+    }
+  }
+  else
+    iupmotSetArg(args, num_args, XmNorientation, XmHORIZONTAL);
+  
+  ih->handle = XtCreateManagedWidget(
+    iupDialogGetChildIdStr(ih),  /* child identifier */
+    xmScaleWidgetClass,          /* widget class */
+    iupChildTreeGetNativeParentHandle(ih), /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  /* initialize the widget */
+  XtRealizeWidget(ih->handle);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvProgressBarInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motProgressBarMapMethod;
+  ic->LayoutUpdate = motProgressBarLayoutUpdateMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, motProgressBarSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, motProgressBarSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGFGCOLOR", IUPAF_DEFAULT);
+
+  /* IupProgressBar only */
+  iupClassRegisterAttribute(ic, "VALUE",  iProgressBarGetValueAttrib,  motProgressBarSetValueAttrib,  NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "ORIENTATION", NULL, NULL, "HORIZONTAL", NULL, IUPAF_NO_INHERIT);
+}
diff --git a/iup/src/mot/iupmot_tabs.c b/iup/src/mot/iupmot_tabs.c
new file mode 100755
index 0000000..7c8a6b5
--- /dev/null
+++ b/iup/src/mot/iupmot_tabs.c
@@ -0,0 +1,593 @@
+/** \file
+* \brief Tabs Control
+*
+* See Copyright Notice in "iup.h"
+*/
+
+#include <Xm/Xm.h>
+#include <Xm/Notebook.h>
+#include <Xm/BulletinB.h>
+#include <Xm/PushB.h>
+#include <Xm/Label.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_layout.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_dialog.h"
+#include "iup_drv.h"
+#include "iup_drvfont.h"
+#include "iup_stdcontrols.h"
+#include "iup_tabs.h"
+#include "iup_image.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+int iupdrvTabsExtraDecor(Ihandle* ih)
+{
+  (void)ih;
+  return 1;
+}
+
+int iupdrvTabsGetLineCountAttrib(Ihandle* ih)
+{
+  (void)ih;
+  return 1;
+}
+
+void iupdrvTabsSetCurrentTab(Ihandle* ih, int pos)
+{
+  Ihandle* child = IupGetChild(ih, pos);
+  Ihandle* prev_child = IupGetChild(ih, iupdrvTabsGetCurrentTab(ih));
+  IupSetAttribute(child, "VISIBLE", "YES");
+  IupSetAttribute(prev_child, "VISIBLE", "NO");
+
+  XtVaSetValues(ih->handle, XmNcurrentPageNumber, pos, NULL);
+}
+
+int iupdrvTabsGetCurrentTab(Ihandle* ih)
+{
+  int pos;
+  XtVaGetValues(ih->handle, XmNcurrentPageNumber, &pos, NULL);
+  return pos;
+}
+
+static void motTabsUpdatePageNumber(Ihandle* ih)
+{
+  int pos, old_pos;
+  Ihandle* child;
+  for (pos = 0, child = ih->firstchild; child; child = child->brother, pos++)
+  {
+    Widget child_manager = (Widget)iupAttribGet(child, "_IUPTAB_CONTAINER");
+    if (child_manager)
+    {
+      old_pos = iupAttribGetInt(child, "_IUPMOT_TABNUMBER");  /* did not work when using XtVaGetValues(child_manager, XmNpageNumber) */
+      if (pos != old_pos)
+      {
+        Widget tab_button = (Widget)iupAttribGet(child, "_IUPMOT_TABBUTTON");
+        XtVaSetValues(child_manager, XmNpageNumber, pos, NULL);
+        XtVaSetValues(tab_button, XmNpageNumber, pos, NULL);
+        iupAttribSetInt(child, "_IUPMOT_TABNUMBER", pos);
+      }
+    }
+  }
+}
+
+static void motTabsUpdatePageBgPixmap(Ihandle* ih, Pixmap pixmap)
+{
+  Ihandle* child;
+  for (child = ih->firstchild; child; child = child->brother)
+  {
+    Widget child_manager = (Widget)iupAttribGet(child, "_IUPTAB_CONTAINER");
+    if (child_manager)
+      XtVaSetValues(child_manager, XmNbackgroundPixmap, pixmap, NULL);
+  }
+}
+
+static void motTabsUpdatePageBgColor(Ihandle* ih, Pixel color)
+{
+  Ihandle* child;
+  for (child = ih->firstchild; child; child = child->brother)
+  {
+    Widget child_manager = (Widget)iupAttribGet(child, "_IUPTAB_CONTAINER");
+    if (child_manager)
+      iupmotSetBgColor(child_manager, color);
+  }
+}
+
+static void motTabsUpdateButtonsFgColor(Ihandle* ih, Pixel color)
+{
+  Ihandle* child;
+  for (child = ih->firstchild; child; child = child->brother)
+  {
+    Widget tab_button = (Widget)iupAttribGet(child, "_IUPMOT_TABBUTTON");
+    if (tab_button)
+      XtVaSetValues(tab_button, XmNforeground, color, NULL);
+  }
+}
+
+static void motTabsUpdateButtonsBgColor(Ihandle* ih, Pixel color)
+{
+  Ihandle* child;
+  for (child = ih->firstchild; child; child = child->brother)
+  {
+    Widget tab_button = (Widget)iupAttribGet(child, "_IUPMOT_TABBUTTON");
+    if (tab_button)
+      iupmotSetBgColor(tab_button, color);
+  }
+}
+
+static void motTabsUpdateButtonsPadding(Ihandle* ih)
+{
+  Ihandle* child;
+  for (child = ih->firstchild; child; child = child->brother)
+  {
+    Widget tab_button = (Widget)iupAttribGet(child, "_IUPMOT_TABBUTTON");
+    if (tab_button)
+      XtVaSetValues(tab_button, XmNmarginHeight, ih->data->vert_padding,
+                                XmNmarginWidth, ih->data->horiz_padding, NULL);
+  }
+}
+
+static void motTabsUpdatePageFont(Ihandle* ih)
+{
+  Ihandle* child;
+  XmFontList fontlist = (XmFontList)iupmotGetFontListAttrib(ih);
+
+  for (child = ih->firstchild; child; child = child->brother)
+  {
+    Widget tab_button = (Widget)iupAttribGet(child, "_IUPMOT_TABBUTTON");
+    if (tab_button)
+      XtVaSetValues(tab_button, XmNrenderTable, fontlist, NULL);
+  }
+}
+
+/* ------------------------------------------------------------------------- */
+/* motTabs - Sets and Gets accessors                                         */
+/* ------------------------------------------------------------------------- */
+
+static int motTabsSetPaddingAttrib(Ihandle* ih, const char* value)
+{
+  iupStrToIntInt(value, &ih->data->horiz_padding, &ih->data->vert_padding, 'x');
+
+  if (ih->handle)
+    motTabsUpdateButtonsPadding(ih);
+  return 0;
+}
+
+static void motTabsUpdateTabType(Ihandle* ih)
+{
+  if (ih->data->type == ITABS_LEFT)
+    XtVaSetValues(ih->handle, XmNbackPagePlacement, XmBOTTOM_LEFT, 
+                              XmNorientation, XmHORIZONTAL,
+                              NULL);
+  else if(ih->data->type == ITABS_RIGHT)
+    XtVaSetValues(ih->handle, XmNbackPagePlacement, XmBOTTOM_RIGHT, 
+                              XmNorientation, XmHORIZONTAL,
+                              NULL);
+  else if(ih->data->type == ITABS_BOTTOM)
+    XtVaSetValues(ih->handle, XmNbackPagePlacement, XmBOTTOM_RIGHT, 
+                              XmNorientation, XmVERTICAL,
+                              NULL);
+  else /* "TOP" */
+    XtVaSetValues(ih->handle, XmNbackPagePlacement, XmTOP_RIGHT, 
+                              XmNorientation, XmVERTICAL,
+                              NULL);
+}
+
+static int motTabsSetTabTypeAttrib(Ihandle* ih, const char* value)
+{
+  if (iupStrEqualNoCase(value, "LEFT"))
+    ih->data->type = ITABS_LEFT;
+  else if(iupStrEqualNoCase(value, "RIGHT"))
+    ih->data->type = ITABS_RIGHT;
+  else if(iupStrEqualNoCase(value, "BOTTOM"))
+    ih->data->type = ITABS_BOTTOM;
+  else /* "TOP" */
+    ih->data->type = ITABS_TOP;
+
+  if (ih->handle)
+    motTabsUpdateTabType(ih);
+
+  return 0;
+}
+
+static int motTabsSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color;
+
+  /* given value is used only for child, to the Tabs must use only from parent */
+  char* parent_value = iupBaseNativeParentGetBgColor(ih);
+
+  color = iupmotColorGetPixelStr(parent_value);
+  if (color != (Pixel)-1)
+  {
+    iupmotSetBgColor(ih->handle, color);
+    motTabsUpdatePageBgColor(ih, color);
+  }
+
+  color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+    motTabsUpdateButtonsBgColor(ih, color);
+
+  return 1; 
+}
+
+static int motTabsSetBackgroundAttrib(Ihandle* ih, const char* value)
+{
+  /* given value is used only for child, to the Tabs must use only from parent */
+  char* parent_value = iupAttribGetInheritNativeParent(ih, "BACKGROUND");
+
+  Pixel color = iupmotColorGetPixelStr(parent_value);
+  if (color != (Pixel)-1)
+  {
+    iupmotSetBgColor(ih->handle, color);
+    motTabsUpdatePageBgColor(ih, color);
+  }
+  else
+  {
+    Pixmap pixmap = (Pixmap)iupImageGetImage(parent_value, ih, 0);
+    if (pixmap)
+    {
+      XtVaSetValues(ih->handle, XmNbackgroundPixmap, pixmap, NULL);
+      motTabsUpdatePageBgPixmap(ih, pixmap);
+    }
+  }
+
+  (void)value;
+  return 1;
+}
+
+static int motTabsSetFgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    XtVaSetValues(ih->handle, XmNforeground, color, NULL);
+    motTabsUpdateButtonsFgColor(ih, color);
+    return 1;
+  }
+  return 0; 
+}
+
+static int motTabsSetStandardFontAttrib(Ihandle* ih, const char* value)
+{
+  iupdrvSetStandardFontAttrib(ih, value);
+  if (ih->handle)
+    motTabsUpdatePageFont(ih);
+  return 1;
+}
+
+static int motTabsSetTabTitleAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  int pos;
+  if (value && iupStrToInt(name_id, &pos)==1)
+  {
+    Ihandle* child = IupGetChild(ih, pos);
+    Widget tab_button = (Widget)iupAttribGet(child, "_IUPMOT_TABBUTTON");
+    if (tab_button)
+      iupmotSetString(tab_button, XmNlabelString, value);
+  }
+  return 1;
+}
+
+static int motTabsSetTabImageAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  int pos;
+  if (value && iupStrToInt(name_id, &pos)==1)
+  {
+    Ihandle* child = IupGetChild(ih, pos);
+    Widget tab_button = (Widget)iupAttribGet(child, "_IUPMOT_TABBUTTON");
+    if (tab_button)
+    {
+      Pixmap pixmap = (Pixmap)iupImageGetImage(value, ih, 0);
+      if (pixmap)
+        XtVaSetValues(tab_button, XmNlabelPixmap, pixmap, NULL);
+    }
+  }
+  return 1;
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* motTabs - Callback                                                        */
+/* ------------------------------------------------------------------------- */
+
+void motTabsPageChangedCallback(Widget w, Ihandle* ih, XmNotebookCallbackStruct *nptr)
+{
+  if (nptr->reason == XmCR_MAJOR_TAB)
+  {
+    IFnnn cb;
+    Ihandle* child = IupGetChild(ih, nptr->page_number);
+    Ihandle* prev_child = IupGetChild(ih, nptr->prev_page_number);
+    IupSetAttribute(child, "VISIBLE", "YES");
+    IupSetAttribute(prev_child, "VISIBLE", "NO");
+
+    cb = (IFnnn)IupGetCallback(ih, "TABCHANGE_CB");
+    if (cb)
+      cb(ih, child, prev_child);
+  }
+  (void)w; 
+}
+
+static void motTabsConfigureNotify(Widget w, XEvent *evt, String* s, Cardinal *card)
+{
+  /* Motif does not process the changed of position and/or size of children outside the parent's client area. 
+     Since Notebook pages are not resized until they are moved into the visible area,
+     we must update the children position and size when a tab page is resize. 
+     Since tab pages are not hidden, they are moved outside the visible area,
+     a resize occours every time a tab is activated.
+  */
+  Ihandle *child;
+  (void)s;
+  (void)card;
+  (void)evt;
+
+  XtVaGetValues(w, XmNuserData, &child, NULL);
+  if (!child) return;
+
+  iupLayoutUpdate(child);
+}
+
+/* ------------------------------------------------------------------------- */
+/* motTabs - Methods and Init Class                                          */
+/* ------------------------------------------------------------------------- */
+
+static void motTabsChildAddedMethod(Ihandle* ih, Ihandle* child)
+{
+  if (IupGetName(child) == NULL)
+    iupAttribSetHandleName(child);
+
+  if (ih->handle)
+  {
+    Widget child_manager;
+    Widget tab_button;
+    int num_args = 0, pos;
+    Arg args[30];
+    char *tabtitle, *tabimage, *background;
+    Pixel color;
+
+    /* open space for new tab number */
+    motTabsUpdatePageNumber(ih);
+
+    pos = IupGetChildPos(ih, child);
+
+    /* Create pages */
+    child_manager = XtVaCreateManagedWidget(
+                    "child_manager",
+                    xmBulletinBoardWidgetClass,
+                    ih->handle,
+                    /* Core */
+                    XmNborderWidth, 0,
+                    /* Manager */
+                    XmNshadowThickness, 0,
+                    XmNnavigationType, XmTAB_GROUP,
+                    XmNuserData, child, /* used only in motTabsConfigureNotify  */
+                    /* BulletinBoard */
+                    XmNmarginWidth, 0,
+                    XmNmarginHeight, 0,
+                    XmNresizePolicy, XmRESIZE_NONE, /* no automatic resize of children */
+                    /* Notebook Constraint */
+                    XmNnotebookChildType, XmPAGE,
+                    XmNpageNumber, pos,
+                    XmNresizable, True,
+                    NULL);   
+
+    XtOverrideTranslations(child_manager, XtParseTranslationTable("<Configure>: iupTabsConfigure()"));
+
+    tabtitle = iupAttribGet(child, "TABTITLE");
+    if (!tabtitle) tabtitle = iupTabsAttribGetStrId(ih, "TABTITLE", pos);
+    tabimage = iupAttribGet(child, "TABIMAGE");
+    if (!tabimage) tabimage = iupTabsAttribGetStrId(ih, "TABIMAGE", pos);
+    if (!tabtitle && !tabimage)
+      tabtitle = "     ";
+
+    /* Create tabs */
+    /* Label */
+    iupmotSetArg(args, num_args, XmNlabelType, tabtitle? XmSTRING: XmPIXMAP);
+    iupmotSetArg(args, num_args, XmNmarginHeight, 0);
+    iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+    /* Notebook Constraint */
+    iupmotSetArg(args, num_args, XmNnotebookChildType, XmMAJOR_TAB);
+    iupmotSetArg(args, num_args, XmNpageNumber, pos);
+    tab_button = XtCreateManagedWidget("tab_button", xmPushButtonWidgetClass, ih->handle, args, num_args);
+
+    /* Disable Drag Source */
+    iupmotDisableDragSource(tab_button);
+
+    XtAddEventHandler(tab_button, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+    XtAddEventHandler(tab_button, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+    XtAddEventHandler(tab_button, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent, (XtPointer)ih);
+    XtAddEventHandler(tab_button, KeyPressMask,    False, (XtEventHandler)iupmotKeyPressEvent, (XtPointer)ih);
+
+    if (tabtitle)
+      iupmotSetString(tab_button, XmNlabelString, tabtitle);
+    else
+    {
+      Pixmap pixmap = (Pixmap)iupImageGetImage(tabimage, ih, 0);
+      if (pixmap)
+        XtVaSetValues(tab_button, XmNlabelPixmap, pixmap, NULL);
+    }
+
+    background = iupBaseNativeParentGetBgColorAttrib(ih);
+    color = iupmotColorGetPixelStr(background);
+    if (color != -1)
+      iupmotSetBgColor(child_manager, color);
+    else
+    {
+      Pixmap pixmap = (Pixmap)iupImageGetImage(background, ih, 0);
+      if (pixmap)
+      {
+        XtVaSetValues(child_manager, XmNbackgroundPixmap, pixmap, NULL);
+      }
+    }
+
+    background = iupAttribGetStr(ih, "BGCOLOR");
+    color = iupmotColorGetPixelStr(background);
+    if (color != -1)
+      iupmotSetBgColor(tab_button, color);
+
+    color = iupmotColorGetPixelStr(IupGetAttribute(ih, "FGCOLOR"));
+    XtVaSetValues(tab_button, XmNforeground, color, NULL);
+
+    XtRealizeWidget(child_manager);
+    XtRealizeWidget(tab_button);
+
+    iupAttribSetStr(child, "_IUPTAB_CONTAINER", (char*)child_manager);
+    iupAttribSetStr(child, "_IUPMOT_TABBUTTON", (char*)tab_button);
+    iupAttribSetInt(child, "_IUPMOT_TABNUMBER", pos);
+
+    if (pos == iupdrvTabsGetCurrentTab(ih))
+      IupSetAttribute(child, "VISIBLE", "YES");
+    else
+      IupSetAttribute(child, "VISIBLE", "NO");
+  }
+}
+
+static void motTabsChildRemovedMethod(Ihandle* ih, Ihandle* child)
+{
+  if (ih->handle)
+  {
+    Widget child_manager = (Widget)iupAttribGet(child, "_IUPTAB_CONTAINER");
+    if (child_manager)
+    {
+      int cur_pos, pos;
+      Widget tab_button = (Widget)iupAttribGet(child, "_IUPMOT_TABBUTTON");
+
+      cur_pos = iupdrvTabsGetCurrentTab(ih);
+      pos = iupAttribGetInt(child, "_IUPMOT_TABNUMBER");  /* did not work when using XtVaGetValues(child_manager, XmNpageNumber) */
+      if (cur_pos == pos)
+      {
+        if (cur_pos == 0)
+          cur_pos = 1;
+        else
+          cur_pos--;
+
+        iupdrvTabsSetCurrentTab(ih, cur_pos);
+      }
+
+      XtDestroyWidget(tab_button);
+      XtDestroyWidget(child_manager);
+
+      /* compact the tab number usage */
+      motTabsUpdatePageNumber(ih);
+
+      iupAttribSetStr(child, "_IUPTAB_CONTAINER", NULL);
+      iupAttribSetStr(child, "_IUPMOT_TABBUTTON", NULL);
+      iupAttribSetStr(child, "_IUPMOT_TABNUMBER", NULL);
+    }
+  }
+}
+
+static int motTabsMapMethod(Ihandle* ih)
+{
+  int num_args = 0;
+  Arg args[30];
+
+  if (!ih->parent)
+    return IUP_ERROR;
+
+  /* Core */
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+  /* Manager */
+  iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+  iupmotSetArg(args, num_args, XmNtraversalOn, True);
+  iupmotSetArg(args, num_args, XmNhighlightThickness, 0);
+  /* Notebook */
+  iupmotSetArg(args, num_args, XmNbindingType, XmNONE);
+  iupmotSetArg(args, num_args, XmNbindingWidth, 0);
+  iupmotSetArg(args, num_args, XmNfirstPageNumber, 0);  /* IupTabs index always starts with zero */
+  iupmotSetArg(args, num_args, XmNbackPageSize, 0);
+  iupmotSetArg(args, num_args, XmNbackPageNumber, 1);
+  iupmotSetArg(args, num_args, XmNframeShadowThickness, 2);
+
+  ih->handle = XtCreateManagedWidget(
+    iupDialogGetChildIdStr(ih),  /* child identifier */
+    xmNotebookWidgetClass,       /* widget class */
+    iupChildTreeGetNativeParentHandle(ih), /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+ 
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  /* Disable page scroller */
+  {
+    Widget scroller;
+    scroller = XtNameToWidget(ih->handle, "*PageScroller");
+    XtUnmanageChild(scroller);
+  }
+
+  /* Callbacks */
+  XtAddCallback(ih->handle, XmNpageChangedCallback, (XtCallbackProc)motTabsPageChangedCallback, (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+
+  /* update Tab position */
+  motTabsUpdateTabType(ih);
+
+  /* current value is now given by the native system */
+  iupAttribSetStr(ih, "_IUPTABS_VALUE_HANDLE", NULL);
+
+  /* initialize the widget */
+  XtRealizeWidget(ih->handle);
+
+  /* Create pages and tabs */
+  if (ih->firstchild)
+  {
+    Ihandle* child;
+    for (child = ih->firstchild; child; child = child->brother)
+      motTabsChildAddedMethod(ih, child);
+  }
+
+  return IUP_NOERROR;
+}
+
+void iupdrvTabsInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motTabsMapMethod;
+  ic->ChildAdded     = motTabsChildAddedMethod;
+  ic->ChildRemoved   = motTabsChildRemovedMethod;
+
+  {
+    /* Set up a translation table that captures "Resize" events
+       (also called ConfigureNotify or Configure events). */
+    XtActionsRec rec = {"iupTabsConfigure", motTabsConfigureNotify};
+    XtAppAddActions(iupmot_appcontext, &rec, 1);
+  }
+
+  /* Driver Dependent Attribute functions */
+
+  /* Common */
+  iupClassRegisterAttribute(ic, "STANDARDFONT", NULL, motTabsSetStandardFontAttrib, IUPAF_SAMEASSYSTEM, "DEFAULTFONT", IUPAF_NOT_MAPPED);
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, motTabsSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, motTabsSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGFGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "BACKGROUND", NULL, motTabsSetBackgroundAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+  
+  /* IupTabs only */
+  iupClassRegisterAttribute(ic, "TABTYPE", iupTabsGetTabTypeAttrib, motTabsSetTabTypeAttrib, IUPAF_SAMEASSYSTEM, "TOP", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);  
+  iupClassRegisterAttribute(ic, "TABORIENTATION", iupTabsGetTabOrientationAttrib, NULL, IUPAF_SAMEASSYSTEM, "HORIZONTAL", IUPAF_READONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);  /* can not be set, always HORIZONTAL in Motif */
+  iupClassRegisterAttributeId(ic, "TABTITLE", NULL, motTabsSetTabTitleAttrib, IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "TABIMAGE", NULL, motTabsSetTabImageAttrib, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "PADDING", iupTabsGetPaddingAttrib, motTabsSetPaddingAttrib, IUPAF_SAMEASSYSTEM, "0x0", IUPAF_NOT_MAPPED);
+}
diff --git a/iup/src/mot/iupmot_text.c b/iup/src/mot/iupmot_text.c
new file mode 100755
index 0000000..4a8f936
--- /dev/null
+++ b/iup/src/mot/iupmot_text.c
@@ -0,0 +1,1165 @@
+/** \file
+ * \brief Text Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/TextF.h>
+#include <Xm/Text.h>
+#include <Xm/ScrolledW.h>
+#include <Xm/SpinB.h>
+#include <X11/keysym.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+#include <limits.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_dialog.h"
+#include "iup_str.h"
+#include "iup_mask.h"
+#include "iup_drv.h"
+#include "iup_array.h"
+#include "iup_text.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+#ifndef XmIsSpinBox
+#define XmIsSpinBox(w)	XtIsSubclass(w, xmSpinBoxWidgetClass)
+#endif
+
+#ifndef XmNwrap
+#define XmNwrap "Nwrap"
+#endif
+
+void iupdrvTextAddFormatTag(Ihandle* ih, Ihandle* formattag)
+{
+  (void)ih;
+  (void)formattag;
+}
+
+void iupdrvTextAddSpin(int *w, int h)
+{
+  *w += h/2;
+}
+
+void iupdrvTextAddBorders(int *w, int *h)
+{
+  int border_size = 2*5;
+  (*w) += border_size;
+  (*h) += border_size;
+}
+
+static void motTextGetLinColFromPosition(const char *str, int pos, int *lin, int *col )
+{
+  int i;
+
+  *lin = 0;
+  *col = 0;
+
+  for (i=0; i<pos; i++)
+  {
+    if (*str == '\n')
+    {
+      (*lin)++;
+      *col = 0;
+    }
+    else
+      (*col)++;
+
+    str++;
+  }
+
+  (*lin)++; /* IUP starts at 1 */
+  (*col)++;
+}
+
+static int motTextSetLinColToPosition(const char *str, int lin, int col)
+{
+  int pos=0, cur_lin=0, cur_col=0;
+
+  lin--; /* IUP starts at 1 */
+  col--;
+
+  while (*str)
+  {
+    if (lin<=cur_lin && col<=cur_col)
+      break;
+
+    if (*str == '\n')
+    {
+      cur_lin++;
+      cur_col = 0;
+    }
+    else
+      cur_col++;
+
+    str++;
+    pos++;
+  }
+
+  return pos;
+}
+
+void iupdrvTextConvertLinColToPos(Ihandle* ih, int lin, int col, int *pos)
+{
+  char* str = XmTextGetString(ih->handle);
+  *pos = motTextSetLinColToPosition(str, lin, col);
+  XtFree(str);
+}
+
+void iupdrvTextConvertPosToLinCol(Ihandle* ih, int pos, int *lin, int *col)
+{
+  char *str = XmTextGetString(ih->handle);
+  motTextGetLinColFromPosition(str, pos, lin, col);
+  XtFree(str);
+}
+
+static int motTextConvertXYToPos(Ihandle* ih, int x, int y)
+{
+  return XmTextXYToPos(ih->handle, x, y);
+}
+
+
+/*******************************************************************************************/
+
+
+static int motTextSetPaddingAttrib(Ihandle* ih, const char* value)
+{
+  iupStrToIntInt(value, &ih->data->horiz_padding, &ih->data->vert_padding, 'x');
+  if (ih->handle)
+  {
+    XtVaSetValues(ih->handle, XmNmarginHeight, ih->data->vert_padding,
+                              XmNmarginWidth, ih->data->horiz_padding, NULL);
+  }
+  return 0;
+}
+
+static int motTextSetReadOnlyAttrib(Ihandle* ih, const char* value)
+{
+  XtVaSetValues(ih->handle, XmNeditable, iupStrBoolean(value)? False: True, NULL);
+  return 0;
+}
+
+static char* motTextGetReadOnlyAttrib(Ihandle* ih)
+{
+  Boolean editable;
+  XtVaGetValues(ih->handle, XmNeditable, &editable, NULL);
+  if (editable)
+    return "YES";
+  else
+    return "NO";
+}
+
+static int motTextSetInsertAttrib(Ihandle* ih, const char* value)
+{
+  if (!ih->handle)  /* do not store the action before map */
+    return 0;
+  if (!value)
+    return 0;
+
+  /* disable callbacks */
+  iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+  XmTextRemove(ih->handle);
+  XmTextInsert(ih->handle, XmTextGetInsertionPosition(ih->handle), (char*)value);
+  iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+
+  return 0;
+}
+
+static int motTextSetSelectedTextAttrib(Ihandle* ih, const char* value)
+{
+  XmTextPosition start, end;
+
+  if (!value)
+    return 0;
+
+  if (XmTextGetSelectionPosition(ih->handle, &start, &end) && start!=end)
+  {
+    /* disable callbacks */
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+    XmTextReplace(ih->handle, start, end, (char*)value);
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+
+  return 0;
+}
+
+static char* motTextGetSelectedTextAttrib(Ihandle* ih)
+{
+  char* selectedtext = XmTextGetSelection(ih->handle);
+  char* str = iupStrGetMemoryCopy(selectedtext);
+  XtFree(selectedtext);
+  return str;
+}
+
+static int motTextSetAppendAttrib(Ihandle* ih, const char* value)
+{
+  XmTextPosition pos;
+  if (!ih->handle)  /* do not store the action before map */
+    return 0;
+  pos = XmTextGetLastPosition(ih->handle);
+  /* disable callbacks */
+  iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+  if (ih->data->is_multiline && ih->data->append_newline)
+    XmTextInsert(ih->handle, pos, "\n");
+	if (value)
+    XmTextInsert(ih->handle, pos+1, (char*)value);
+  iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  return 0;
+}
+
+static int motTextSetSelectionAttrib(Ihandle* ih, const char* value)
+{
+  int start=1, end=1;
+
+  if (!value || iupStrEqualNoCase(value, "NONE"))
+  {
+    XmTextClearSelection(ih->handle, CurrentTime);
+    return 0;
+  }
+
+  if (iupStrEqualNoCase(value, "ALL"))
+  {
+    XmTextSetSelection(ih->handle, (XmTextPosition)0, (XmTextPosition)XmTextGetLastPosition(ih->handle), CurrentTime);
+    return 0;
+  }
+
+  if (ih->data->is_multiline)
+  {
+    int lin_start=1, col_start=1, lin_end=1, col_end=1;
+    char *str;
+
+    if (sscanf(value, "%d,%d:%d,%d", &lin_start, &col_start, &lin_end, &col_end)!=4) return 0;
+    if (lin_start<1 || col_start<1 || lin_end<1 || col_end<1) return 0;
+
+    str = XmTextGetString(ih->handle);
+    start = motTextSetLinColToPosition(str, lin_start, col_start);
+    end = motTextSetLinColToPosition(str, lin_end, col_end);
+    XtFree(str);
+  }
+  else
+  {
+    if (iupStrToIntInt(value, &start, &end, ':')!=2) 
+      return 0;
+
+    if(start<1 || end<1) 
+      return 0;
+
+    start--; /* IUP starts at 1 */
+    end--;
+  }
+
+  /* end is inside the selection, in IUP is outside */
+  end--;
+
+  XmTextSetSelection(ih->handle, (XmTextPosition)start, (XmTextPosition)end, CurrentTime);
+
+  return 0;
+}
+
+static char* motTextGetSelectionAttrib(Ihandle* ih)
+{
+  XmTextPosition start = 0, end = 0;
+  char* str;
+
+  if (!XmTextGetSelectionPosition(ih->handle, &start, &end) || start==end)
+    return NULL;
+
+  str = iupStrGetMemory(100);
+
+  /* end is inside the selection, in IUP is outside */
+  end++;
+
+  if (ih->data->is_multiline)
+  {
+    int start_col, start_lin, end_col, end_lin;
+
+    char *value = XmTextGetString(ih->handle);
+    motTextGetLinColFromPosition(value, start, &start_lin, &start_col);
+    motTextGetLinColFromPosition(value, end,   &end_lin,   &end_col);
+    XtFree(value);
+
+    sprintf(str,"%d,%d:%d,%d", start_lin, start_col, end_lin, end_col);
+  }
+  else
+  {
+    start++; /* IUP starts at 1 */
+    end++;
+    sprintf(str, "%d:%d", (int)start, (int)end);
+  }
+
+  return str;
+}
+
+static int motTextSetSelectionPosAttrib(Ihandle* ih, const char* value)
+{
+  int start=0, end=0;
+
+  if (!value || iupStrEqualNoCase(value, "NONE"))
+  {
+    XmTextClearSelection(ih->handle, CurrentTime);
+    return 0;
+  }
+
+  if (iupStrEqualNoCase(value, "ALL"))
+  {
+    XmTextSetSelection(ih->handle, (XmTextPosition)0, (XmTextPosition)XmTextGetLastPosition(ih->handle), CurrentTime);
+    return 0;
+  }
+
+  if (iupStrToIntInt(value, &start, &end, ':')!=2) 
+    return 0;
+
+  if(start<0 || end<0) 
+    return 0;
+
+  /* end is inside the selection, in IUP is outside */
+  end--;
+
+  XmTextSetSelection(ih->handle, (XmTextPosition)start, (XmTextPosition)end, CurrentTime);
+
+  return 0;
+}
+
+static char* motTextGetSelectionPosAttrib(Ihandle* ih)
+{
+  XmTextPosition start = 0, end = 0;
+  char* str;
+
+  if (!XmTextGetSelectionPosition(ih->handle, &start, &end) || start==end)
+    return NULL;
+
+  str = iupStrGetMemory(100);
+
+  /* end is inside the selection, in IUP is outside */
+  end++;
+
+  sprintf(str, "%d:%d", (int)start, (int)end);
+
+  return str;
+}
+
+static int motTextSetCaretAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 1;
+
+  if (!value)
+    return 0;
+
+  if (ih->data->is_multiline)
+  {
+    int lin = 1, col = 1;
+    char *str;
+
+    iupStrToIntInt(value, &lin, &col, ',');
+
+    str = XmTextGetString(ih->handle);
+    pos = motTextSetLinColToPosition(str, lin, col);
+    XtFree(str);
+  }
+  else
+  {
+    sscanf(value,"%i",&pos);
+    pos--; /* IUP starts at 1 */
+  }
+
+  XmTextSetInsertionPosition(ih->handle, (XmTextPosition)pos);
+  XmTextShowPosition(ih->handle, (XmTextPosition)pos);
+
+  return 0;
+}
+
+static char* motTextGetCaretAttrib(Ihandle* ih)
+{
+  char* str = iupStrGetMemory(50);
+
+  XmTextPosition pos = XmTextGetInsertionPosition(ih->handle);
+
+  if (ih->data->is_multiline)
+  {
+    int col, lin;
+
+    char *value = XmTextGetString(ih->handle);
+    motTextGetLinColFromPosition(value, pos, &lin, &col);
+    XtFree(value);
+
+    sprintf(str, "%d,%d", lin, col);
+  }
+  else
+  {
+    pos++; /* IUP starts at 1 */
+    sprintf(str, "%d", (int)pos);
+  }
+
+  return str;
+}
+
+static int motTextSetCaretPosAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 0;
+
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  if (pos < 0) pos = 0;
+
+  XmTextSetInsertionPosition(ih->handle, (XmTextPosition)pos);
+  XmTextShowPosition(ih->handle, (XmTextPosition)pos);
+
+  return 0;
+}
+
+static char* motTextGetCaretPosAttrib(Ihandle* ih)
+{
+  XmTextPosition pos = XmTextGetInsertionPosition(ih->handle);
+  char* str = iupStrGetMemory(50);
+  sprintf(str, "%d", (int)pos);
+  return str;
+}
+
+static int motTextSetScrollToAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 1;
+
+  if (!value)
+    return 0;
+
+  if (ih->data->is_multiline)
+  {
+    int lin = 1, col = 1, pos;
+    char* str;
+
+    iupStrToIntInt(value, &lin, &col, ',');
+    if (lin < 1) lin = 1;
+    if (col < 1) col = 1;
+
+    str = XmTextGetString(ih->handle);
+    pos = motTextSetLinColToPosition(str, lin, col);
+    XtFree(str);
+  }
+  else
+  {
+    sscanf(value,"%i",&pos);
+    if (pos < 1) pos = 1;
+    pos--;  /* return to Motif referece */
+  }
+
+  XmTextShowPosition(ih->handle, (XmTextPosition)pos);
+
+  return 0;
+}
+
+static int motTextSetScrollToPosAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 0;
+
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  if (pos < 0) pos = 0;
+
+  XmTextShowPosition(ih->handle, (XmTextPosition)pos);
+
+  return 0;
+}
+
+static int motTextSetNCAttrib(Ihandle* ih, const char* value)
+{
+  if (!iupStrToInt(value, &ih->data->nc))
+    ih->data->nc = INT_MAX;
+  if (ih->handle)
+    XtVaSetValues(ih->handle, XmNmaxLength, ih->data->nc, NULL);
+  return 0;
+}
+
+static int motTextSetClipboardAttrib(Ihandle *ih, const char *value)
+{
+  if (iupStrEqualNoCase(value, "COPY"))
+  {
+    char *str = XmTextGetSelection(ih->handle);
+    if (!str) return 0;
+
+    XmTextCopy(ih->handle, CurrentTime);
+
+    /* do it also for the X clipboard */
+    XStoreBytes(iupmot_display, str, strlen(str)+1);
+    XtFree(str);
+  }
+  else if (iupStrEqualNoCase(value, "CUT"))
+  {
+    char *str = XmTextGetSelection(ih->handle);
+    if (!str) return 0;
+
+    /* disable callbacks */
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+
+    XmTextCut(ih->handle, CurrentTime);
+
+    /* do it also for the X clipboard */
+    XStoreBytes(iupmot_display, str, strlen(str)+1);
+    XtFree(str);
+    XmTextRemove(ih->handle);
+
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+  else if (iupStrEqualNoCase(value, "PASTE"))
+  {
+    int size;
+    char* str = XFetchBytes(iupmot_display, &size);
+    if (!str) return 0;
+
+    /* disable callbacks */
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+
+    XmTextPaste(ih->handle); /* TODO: this could force 2 pastes, check in CDE */
+
+    /* do it also for the X clipboard */
+    XmTextRemove(ih->handle);
+    XmTextInsert(ih->handle, XmTextGetInsertionPosition(ih->handle), str);
+    XFree(str);
+
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+  else if (iupStrEqualNoCase(value, "CLEAR"))
+  {
+    /* disable callbacks */
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+    XmTextRemove(ih->handle);
+    iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  }
+  return 0;
+}
+
+static int motTextSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  Widget sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (sb_win)
+  {
+    Pixel color;
+
+    /* ignore given value for the scrollbars, must use only from parent */
+    char* parent_value = iupBaseNativeParentGetBgColor(ih);
+
+    color = iupmotColorGetPixelStr(parent_value);
+    if (color != (Pixel)-1)
+    {
+      Widget sb = NULL;
+
+      iupmotSetBgColor(sb_win, color);
+
+      XtVaGetValues(sb_win, XmNverticalScrollBar, &sb, NULL);
+      if (sb) iupmotSetBgColor(sb, color);
+
+      XtVaGetValues(sb_win, XmNhorizontalScrollBar, &sb, NULL);
+      if (sb) iupmotSetBgColor(sb, color);
+    }
+  }
+
+  return iupdrvBaseSetBgColorAttrib(ih, value);   /* use given value for contents */
+}
+
+static int motTextSetSpinMinAttrib(Ihandle* ih, const char* value)
+{
+  Widget spinbox = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (spinbox && XmIsSpinBox(spinbox))
+  {
+    int min;
+    if (iupStrToInt(value, &min))
+    {
+      iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+      XtVaSetValues(ih->handle, XmNminimumValue, min, NULL);
+      iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+    }
+  }
+  return 1;
+}
+
+static int motTextSetSpinMaxAttrib(Ihandle* ih, const char* value)
+{
+  Widget spinbox = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (spinbox && XmIsSpinBox(spinbox))
+  {
+    int max;
+    if (iupStrToInt(value, &max))
+    {
+      iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+      XtVaSetValues(ih->handle, XmNmaximumValue, max, NULL);
+      iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+    }
+  }
+  return 1;
+}
+
+static int motTextSetSpinIncAttrib(Ihandle* ih, const char* value)
+{
+  Widget spinbox = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (spinbox && XmIsSpinBox(spinbox))
+  {
+    int inc;
+    if (iupStrToInt(value, &inc))
+    {
+      iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+      XtVaSetValues(ih->handle, XmNincrementValue, inc, NULL);
+      iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+    }
+  }
+  return 1;
+}
+
+static int motTextSetSpinValueAttrib(Ihandle* ih, const char* value)
+{
+  Widget spinbox = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (spinbox && XmIsSpinBox(spinbox))
+  {
+    int pos;
+    if (iupStrToInt(value, &pos))
+    {
+      char* value = NULL;
+      int min, max;
+      iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+      XtVaGetValues(ih->handle, XmNminimumValue, &min, 
+                                XmNmaximumValue, &max, NULL);
+      if (pos < min) pos = min;
+      if (pos > max) pos = max;
+      if (iupAttribGet(ih, "_IUPMOT_SPIN_NOAUTO"))
+        value = XmTextGetString(ih->handle);
+
+      XtVaSetValues(ih->handle, XmNposition, pos, NULL);
+
+      if (value)
+      {
+        XmTextSetString(ih->handle, (char*)value);
+        XtFree(value);
+      }
+      iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static char* motTextGetSpinValueAttrib(Ihandle* ih)
+{
+  Widget spinbox = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (spinbox && XmIsSpinBox(spinbox))
+  {
+    int pos;
+    char *str = iupStrGetMemory(50);
+    XtVaGetValues(ih->handle, XmNposition, &pos, NULL);
+    sprintf(str, "%d", pos);
+    return str;
+  }
+  return NULL;
+}
+
+static int motTextSetValueAttrib(Ihandle* ih, const char* value)
+{
+  if (!value) value = "";
+  motTextSetSpinValueAttrib(ih, value);
+  /* disable callbacks */
+  iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+  XmTextSetString(ih->handle, (char*)value);
+  iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+  return 0;
+}
+
+static char* motTextGetValueAttrib(Ihandle* ih)
+{
+  char* value = XmTextGetString(ih->handle);
+  char* str = iupStrGetMemoryCopy(value);
+  XtFree(value);
+  return str;
+}
+                       
+
+/******************************************************************************/
+
+
+static void motTextSpinModifyVerifyCallback(Widget w, Ihandle* ih, XmSpinBoxCallbackStruct *cbs)
+{
+  IFni cb = (IFni) IupGetCallback(ih, "SPIN_CB");
+  if (cb)
+  {
+    int ret = cb(ih, cbs->position);
+    if (ret == IUP_IGNORE)
+    {
+      cbs->doit = 1;
+      return;
+    }
+  }
+  (void)w;
+
+  iupAttribSetStr(ih, "_IUPMOT_SPIN_DISABLE_TEXT_CB", "1");
+}
+
+static void motTextModifyVerifyCallback(Widget w, Ihandle *ih, XmTextVerifyPtr text)
+{
+  int start, end, key = 0;
+  char *value, *new_value, *insert_value;
+  KeySym motcode = 0;
+  IFnis cb;
+
+  if (iupAttribGet(ih, "_IUPMOT_DISABLE_TEXT_CB"))
+    return;
+
+  if (iupAttribGet(ih, "_IUPMOT_SPIN_DISABLE_TEXT_CB"))
+  {
+    if (iupAttribGet(ih, "_IUPMOT_SPIN_NOAUTO"))
+      text->doit = False;
+
+    iupAttribSetStr(ih, "_IUPMOT_SPIN_DISABLE_TEXT_CB", NULL);
+    return;
+  }
+
+  cb = (IFnis)IupGetCallback(ih, "ACTION");
+  if (!cb && !ih->data->mask)
+    return;
+
+  if (text->event && text->event->type == KeyPress)
+  {
+    unsigned int state = ((XKeyEvent*)text->event)->state;
+    if (state & ControlMask ||  /* Ctrl */
+        state & Mod1Mask || 
+        state & Mod5Mask ||  /* Alt */
+        state & Mod4Mask) /* Apple/Win */
+      return;
+
+    motcode = XKeycodeToKeysym(iupmot_display, ((XKeyEvent*)text->event)->keycode, 0);
+  }
+
+  value = XmTextGetString(ih->handle);
+  start = text->startPos;
+  end = text->endPos;
+  insert_value = text->text->ptr;
+
+  if (motcode == XK_Delete)
+  {
+    new_value = value;
+    iupStrRemove(value, start, end, 1);
+  }
+  else if (motcode == XK_BackSpace)
+  {
+    new_value = value;
+    iupStrRemove(value, start, end, -1);
+  }
+  else
+  {
+    if (!value)
+      new_value = iupStrDup(insert_value);
+    else if (insert_value)
+      new_value = iupStrInsert(value, insert_value, start, end);
+    else
+      new_value = value;
+  }
+
+  if (insert_value && insert_value[0]!=0 && insert_value[1]==0)
+    key = insert_value[0];
+
+  if (ih->data->mask && iupMaskCheck(ih->data->mask, new_value)==0)
+  {
+    if (new_value != value) free(new_value);
+    XtFree(value);
+    text->doit = False;     /* abort processing */
+    return;
+  }
+
+  if (cb)
+  {
+    int cb_ret = cb(ih, key, (char*)new_value);
+    if (cb_ret==IUP_IGNORE)
+      text->doit = False;     /* abort processing */
+    else if (cb_ret==IUP_CLOSE)
+    {
+      IupExitLoop();
+      text->doit = False;     /* abort processing */
+    }
+    else if (cb_ret!=0 && key!=0 && 
+             cb_ret != IUP_DEFAULT && cb_ret != IUP_CONTINUE)  
+    {
+      insert_value[0] = (char)cb_ret;  /* replace key */
+    }
+  }
+
+  if (text->doit)
+  {
+    /* Spin is not automatically updated when you directly edit the text */
+    Widget spinbox = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+    if (spinbox && XmIsSpinBox(spinbox) && !iupAttribGet(ih, "_IUPMOT_SPIN_NOAUTO"))
+    {
+      int pos;
+      if (iupStrToInt(new_value, &pos))
+      {
+        XmTextPosition caret_pos = text->currInsert;
+        iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", "1");
+        XtVaSetValues(ih->handle, XmNposition, pos, NULL);
+        iupAttribSetStr(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
+        /* do not handle all situations, but handle the basic ones */
+        if (text->startPos == text->endPos) /* insert */
+          caret_pos++;
+        else if (text->startPos < text->endPos && text->startPos < text->currInsert)  /* backspace */
+          caret_pos--;
+        XmTextSetInsertionPosition(ih->handle, caret_pos);
+        text->doit = False;
+      }
+    }
+  }
+
+  if (new_value != value) free(new_value);
+  XtFree(value);
+  (void)w;
+}
+
+static void motTextMotionVerifyCallback(Widget w, Ihandle* ih, XmTextVerifyCallbackStruct* textverify)
+{
+  int col, lin, pos;
+
+  IFniii cb = (IFniii)IupGetCallback(ih, "CARET_CB");
+  if (!cb) return;
+
+  pos = textverify->newInsert;
+
+  if (ih->data->is_multiline)
+  {
+    char *value = XmTextGetString(ih->handle);
+    motTextGetLinColFromPosition(value, pos, &lin, &col);
+    XtFree(value);
+  }
+  else
+  {
+    col = pos;
+    col++; /* IUP starts at 1 */
+    lin = 1;
+  }
+
+  if (pos != ih->data->last_caret_pos)
+  {
+    ih->data->last_caret_pos = pos;
+    cb(ih, lin, col, pos);
+  }
+
+  (void)w;
+}
+
+static void motTextValueChangedCallback(Widget w, Ihandle* ih, XmAnyCallbackStruct* valuechanged)
+{
+  if (iupAttribGet(ih, "_IUPMOT_DISABLE_TEXT_CB"))
+    return;
+
+  iupBaseCallValueChangedCb(ih);
+
+  (void)valuechanged;
+  (void)w;
+}
+
+static void motTextKeyPressEvent(Widget w, Ihandle *ih, XKeyEvent *evt, Boolean *cont)
+{
+  Widget spinbox;
+
+  *cont = True;
+  iupmotKeyPressEvent(w, ih, (XEvent*)evt, cont);
+  if (*cont == False)
+    return;
+
+  if (evt->state & ControlMask)   /* Ctrl */
+  {
+    KeySym motcode = XKeycodeToKeysym(iupmot_display, evt->keycode, 0);
+    if (motcode == XK_c)
+      motTextSetClipboardAttrib(ih, "COPY");
+    else if (motcode == XK_x)
+      motTextSetClipboardAttrib(ih, "CUT");
+    else if (motcode == XK_v)
+      motTextSetClipboardAttrib(ih, "PASTE");
+    else if (motcode == XK_a)
+      XmTextSetSelection(ih->handle, 0, XmTextGetLastPosition(ih->handle), CurrentTime);
+  }
+
+  spinbox = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (spinbox && XmIsSpinBox(spinbox))
+  {
+    KeySym motcode = XKeycodeToKeysym(iupmot_display, evt->keycode, 0);
+    if (motcode == XK_Left || motcode == XK_Right)
+    {
+      /* avoid spin increment using Left/Right arrows, 
+         but must manually handle the new cursor position */
+      XmTextPosition caret_pos = XmTextGetInsertionPosition(ih->handle);
+      XmTextSetInsertionPosition(ih->handle, (motcode == XK_Left)? caret_pos-1: caret_pos+1);
+      *cont = False; 
+    }
+  }
+}
+
+
+/******************************************************************************/
+
+
+static void motTextLayoutUpdateMethod(Ihandle* ih)
+{
+  Widget spinbox = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (spinbox && XmIsSpinBox(spinbox))
+  {
+    XtVaSetValues(ih->handle,
+      XmNwidth, (XtArgVal)ih->currentwidth-ih->currentheight/2,
+      XmNheight, (XtArgVal)ih->currentheight,
+      NULL);
+
+    XtVaSetValues(spinbox,
+      XmNx, (XtArgVal)ih->x,
+      XmNy, (XtArgVal)ih->y,
+      XmNwidth, (XtArgVal)ih->currentwidth,
+      XmNheight, (XtArgVal)ih->currentheight,
+      XmNarrowSize, ih->currentheight/2,
+      NULL);
+  }
+  else
+    iupdrvBaseLayoutUpdateMethod(ih);
+}
+
+static int motTextMapMethod(Ihandle* ih)
+{
+  int num_args = 0;
+  Arg args[30];
+  Widget parent = iupChildTreeGetNativeParentHandle(ih);
+  char* child_id = iupDialogGetChildIdStr(ih);
+  int spin = 0;
+  WidgetClass widget_class = xmTextWidgetClass;
+
+  if (ih->data->is_multiline)
+  {
+    Widget sb_win;
+    int wordwrap = 0;
+
+    if (iupAttribGetBoolean(ih, "WORDWRAP"))
+    {
+      wordwrap = 1;
+      ih->data->sb &= ~IUP_SB_HORIZ;  /* must remove the horizontal scroolbar */
+    }
+
+    /******************************/
+    /* Create the scrolled window */
+    /******************************/
+
+    iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+    iupmotSetArg(args, num_args, XmNscrollingPolicy, XmAPPLICATION_DEFINED);
+    iupmotSetArg(args, num_args, XmNvisualPolicy, XmVARIABLE);
+    iupmotSetArg(args, num_args, XmNscrollBarDisplayPolicy, XmSTATIC);   /* can NOT be XmAS_NEEDED because XmAPPLICATION_DEFINED */
+    iupmotSetArg(args, num_args, XmNspacing, 0); /* no space between scrollbars and text */
+    iupmotSetArg(args, num_args, XmNborderWidth, 0);
+    iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+    
+    sb_win = XtCreateManagedWidget(
+      child_id,  /* child identifier */
+      xmScrolledWindowWidgetClass, /* widget class */
+      parent,                      /* widget parent */
+      args, num_args);
+
+    if (!sb_win)
+      return IUP_ERROR;
+
+    parent = sb_win;
+    child_id = "text";
+
+    num_args = 0;
+    iupmotSetArg(args, num_args, XmNeditMode, XmMULTI_LINE_EDIT);
+    if (wordwrap)
+      iupmotSetArg(args, num_args, XmNwordWrap, True);
+  }
+  else
+  {
+    widget_class = xmTextFieldWidgetClass;
+
+    if (iupAttribGetBoolean(ih, "SPIN"))
+    {
+      Widget spinbox;
+
+      num_args = 0;
+      iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+      iupmotSetArg(args, num_args, XmNspacing, 0); /* no space between spin and text */
+      iupmotSetArg(args, num_args, XmNborderWidth, 0);
+      iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+      iupmotSetArg(args, num_args, XmNmarginHeight, 0);
+      iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+      iupmotSetArg(args, num_args, XmNarrowSize, 8);
+
+      if (iupStrEqualNoCase(iupAttribGetStr(ih, "SPINALIGN"), "LEFT"))
+        iupmotSetArg(args, num_args, XmNarrowLayout, XmARROWS_BEGINNING);
+      else
+        iupmotSetArg(args, num_args, XmNarrowLayout, XmARROWS_END);
+
+      spinbox = XtCreateManagedWidget(
+        child_id,  /* child identifier */
+        xmSpinBoxWidgetClass, /* widget class */
+        parent,                      /* widget parent */
+        args, num_args);
+
+      if (!spinbox)
+        return IUP_ERROR;
+
+      XtAddCallback(spinbox, XmNmodifyVerifyCallback, (XtCallbackProc)motTextSpinModifyVerifyCallback, (XtPointer)ih);
+
+      parent = spinbox;
+      child_id = "text";
+      spin = 1;
+
+      if (!iupAttribGetBoolean(ih, "SPINAUTO"))
+        iupAttribSetStr(ih, "_IUPMOT_SPIN_NOAUTO", "1");
+    }
+
+    num_args = 0;
+    iupmotSetArg(args, num_args, XmNeditMode, XmSINGLE_LINE_EDIT);
+
+    if (spin)
+    {
+      /* Spin Constraints */
+      iupmotSetArg(args, num_args, XmNspinBoxChildType, XmNUMERIC);
+      iupmotSetArg(args, num_args, XmNminimumValue, 0);
+      iupmotSetArg(args, num_args, XmNmaximumValue, 100);
+      iupmotSetArg(args, num_args, XmNposition, 0);
+
+      if (iupAttribGetBoolean(ih, "SPINWRAP"))
+        iupmotSetArg(args, num_args, XmNwrap, TRUE);
+      else
+        iupmotSetArg(args, num_args, XmNwrap, FALSE);
+    }
+    else
+    {
+      iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+    }
+  }
+
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+
+  iupmotSetArg(args, num_args, XmNmarginHeight, 0);  /* default padding */
+  iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+
+  if (iupAttribGetBoolean(ih, "CANFOCUS"))
+    iupmotSetArg(args, num_args, XmNtraversalOn, True);
+  else
+    iupmotSetArg(args, num_args, XmNtraversalOn, False);
+
+  iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+  iupmotSetArg(args, num_args, XmNhighlightThickness, 2);
+  iupmotSetArg(args, num_args, XmNverifyBell, False);
+  iupmotSetArg(args, num_args, XmNspacing, 0);
+
+  if (iupAttribGetBoolean(ih, "BORDER"))
+    iupmotSetArg(args, num_args, XmNshadowThickness, 2);
+  else
+    iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+
+  if (ih->data->is_multiline)
+  {
+    if (ih->data->sb & IUP_SB_HORIZ)
+      iupmotSetArg(args, num_args, XmNscrollHorizontal, True);
+    else
+      iupmotSetArg(args, num_args, XmNscrollHorizontal, False);
+
+    if (ih->data->sb & IUP_SB_VERT)
+      iupmotSetArg(args, num_args, XmNscrollVertical, True);
+    else
+      iupmotSetArg(args, num_args, XmNscrollVertical, False);
+  }
+
+  ih->handle = XtCreateManagedWidget(
+    child_id,       /* child identifier */
+    widget_class,   /* widget class */
+    parent,         /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  if (ih->data->is_multiline)
+  {
+    iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)parent);
+    XtVaSetValues(parent, XmNworkWindow, ih->handle, NULL);
+  } 
+  else if (spin)
+    iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)parent);
+
+  XtAddCallback(ih->handle, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, KeyPressMask, False, (XtEventHandler)motTextKeyPressEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, PointerMotionMask, False, (XtEventHandler)iupmotPointerMotionEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, ButtonPressMask|ButtonReleaseMask, False, (XtEventHandler)iupmotButtonPressReleaseEvent, (XtPointer)ih);
+
+  XtAddCallback(ih->handle, XmNmodifyVerifyCallback, (XtCallbackProc)motTextModifyVerifyCallback, (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNmotionVerifyCallback, (XtCallbackProc)motTextMotionVerifyCallback, (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNvalueChangedCallback, (XtCallbackProc)motTextValueChangedCallback, (XtPointer)ih);
+
+  /* Disable Drag Source */
+  iupmotDisableDragSource(ih->handle);
+
+  /* initialize the widget */
+  if (ih->data->is_multiline || spin)
+    XtRealizeWidget(parent);
+  else
+    XtRealizeWidget(ih->handle);
+
+  if (IupGetGlobal("_IUP_RESET_TXTCOLORS"))
+  {
+    iupmotSetGlobalColorAttrib(ih->handle, XmNbackground, "TXTBGCOLOR");
+    iupmotSetGlobalColorAttrib(ih->handle, XmNforeground, "TXTFGCOLOR");
+    IupSetGlobal("_IUP_RESET_TXTCOLORS", NULL);
+  }
+
+  IupSetCallback(ih, "_IUP_XY2POS_CB", (Icallback)motTextConvertXYToPos);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvTextInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motTextMapMethod;
+  ic->LayoutUpdate = motTextLayoutUpdateMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Overwrite Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, motTextSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "TXTBGCOLOR", IUPAF_DEFAULT);
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, iupdrvBaseSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "TXTFGCOLOR", IUPAF_DEFAULT);
+
+  /* IupText only */
+  iupClassRegisterAttribute(ic, "PADDING", iupTextGetPaddingAttrib, motTextSetPaddingAttrib, IUPAF_SAMEASSYSTEM, "0x0", IUPAF_NOT_MAPPED);
+  iupClassRegisterAttribute(ic, "VALUE", motTextGetValueAttrib, motTextSetValueAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SELECTEDTEXT", motTextGetSelectedTextAttrib, motTextSetSelectedTextAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SELECTION", motTextGetSelectionAttrib, motTextSetSelectionAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SELECTIONPOS", motTextGetSelectionPosAttrib, motTextSetSelectionPosAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "CARET", motTextGetCaretAttrib, motTextSetCaretAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "CARETPOS", motTextGetCaretPosAttrib, motTextSetCaretPosAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "INSERT", NULL, motTextSetInsertAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "APPEND", NULL, motTextSetAppendAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "READONLY", motTextGetReadOnlyAttrib, motTextSetReadOnlyAttrib, NULL, NULL, IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "NC", iupTextGetNCAttrib, motTextSetNCAttrib, NULL, NULL, IUPAF_NOT_MAPPED);
+  iupClassRegisterAttribute(ic, "CLIPBOARD", NULL, motTextSetClipboardAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "FORMATTING", NULL, NULL, NULL, NULL, IUPAF_READONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);  /* formatting not supported in Motif */
+  iupClassRegisterAttribute(ic, "SCROLLTO", NULL, motTextSetScrollToAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SCROLLTOPOS", NULL, motTextSetScrollToPosAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SPINMIN", NULL, motTextSetSpinMinAttrib, IUPAF_SAMEASSYSTEM, "0", IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SPINMAX", NULL, motTextSetSpinMaxAttrib, IUPAF_SAMEASSYSTEM, "100", IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SPININC", NULL, motTextSetSpinIncAttrib, IUPAF_SAMEASSYSTEM, "1", IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SPINVALUE", motTextGetSpinValueAttrib, motTextSetSpinValueAttrib, IUPAF_SAMEASSYSTEM, "0", IUPAF_NO_INHERIT);
+}
diff --git a/iup/src/mot/iupmot_timer.c b/iup/src/mot/iupmot_timer.c
new file mode 100755
index 0000000..d23867e
--- /dev/null
+++ b/iup/src/mot/iupmot_timer.c
@@ -0,0 +1,70 @@
+/** \file
+ * \brief Timer for the Motif Driver.
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <Xm/Xm.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_assert.h"
+#include "iup_timer.h"
+
+#include "iupmot_drv.h"
+
+
+static void motTimerProc(XtPointer client_data, XtIntervalId *id)
+{
+  Ihandle *ih = (Ihandle*)client_data;
+  Icallback cb;
+  (void)id;
+
+  if (!iupObjectCheck(ih))   /* control could be destroyed before timer callback */
+    return;
+
+  ih->serial = -1;
+  /* we have to restart the timer everytime */
+  iupdrvTimerRun(ih);
+
+  cb = IupGetCallback(ih, "ACTION_CB");
+  if (cb)
+  {
+    if (cb(ih)==IUP_CLOSE)
+      IupExitLoop();
+  }
+}
+
+void iupdrvTimerRun(Ihandle *ih)
+{
+  unsigned int time_ms;
+
+  if (ih->serial > 0) /* timer already started */
+    return;
+  
+  time_ms = iupAttribGetInt(ih, "TIME");
+  if (time_ms > 0)
+    ih->serial = XtAppAddTimeOut(iupmot_appcontext, time_ms, motTimerProc, (XtPointer)ih);
+}
+
+void iupdrvTimerStop(Ihandle* ih)
+{
+  if (ih->serial > 0)
+  {
+    XtRemoveTimeOut(ih->serial);
+    ih->serial = -1;
+  }
+}
+
+void iupdrvTimerInitClass(Iclass* ic)
+{
+  (void)ic;
+}
diff --git a/iup/src/mot/iupmot_tips.c b/iup/src/mot/iupmot_tips.c
new file mode 100755
index 0000000..25bdbea
--- /dev/null
+++ b/iup/src/mot/iupmot_tips.c
@@ -0,0 +1,226 @@
+/** \file
+ * \brief Motif Driver TIPS Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/Label.h>
+
+#include <stdio.h>
+
+#include "iup.h"
+
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_drv.h"
+#include "iup_drvfont.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+/* Default offset from cursor */
+#define TIP_X_OFFSET    12
+#define TIP_Y_OFFSET    12
+
+typedef struct _Imottips
+{
+  Widget        Dialog;
+  Widget        Label;
+  XtIntervalId  ShowTimerId;       /* Timer: from enterwin to show tip    */
+  XtIntervalId  HideTimerId;       /* Timer: from visible to hide tip    */
+  unsigned long ShowInterval;      /* Time for tipPopupTimerId         */
+  unsigned long HideInterval;      /* Time for tipActiveTimerId        */
+  int           Visible;
+  Ihandle*      ih;
+} Imottips;
+
+static Imottips mot_tips = {0, 0, 0, 0, 0, 0};
+
+static void motTipsShow(void)
+{
+  Window root, child;
+  int cx, cy, x, y;
+  unsigned int keys;
+  char* value;
+
+  XQueryPointer(iupmot_display, RootWindow(iupmot_display, iupmot_screen),
+                &root, &child, &x, &y, &cx, &cy, &keys);
+
+  value = iupAttribGet(mot_tips.ih, "TIPRECT");
+  if (value)
+  {
+    int x1, x2, y1, y2, wx = x, wy = y;
+    sscanf(value, "%d %d %d %d", &x1, &y1, &x2, &y2);
+    iupdrvScreenToClient(mot_tips.ih, &wx, &wy);
+    if (wx < x1 || wx > x2 || wy < y1 || wy > y2)
+    {
+      iupmotTipLeaveNotify();
+      return;
+    }
+  }
+  
+  XtVaSetValues(mot_tips.Dialog, 
+    XmNx, (XtArgVal)(x+TIP_X_OFFSET),
+    XmNy, (XtArgVal)(y+TIP_Y_OFFSET), 
+    NULL);
+
+  if (mot_tips.Visible)
+    XRaiseWindow(iupmot_display, XtWindow(mot_tips.Dialog));
+  else
+    XtMapWidget(mot_tips.Dialog);
+
+  mot_tips.ShowTimerId = (XtIntervalId) NULL;
+  mot_tips.Visible = TRUE;
+}
+
+static void motTipsHide(void)
+{
+  mot_tips.HideTimerId = (XtIntervalId) NULL;
+  iupmotTipLeaveNotify();
+}
+
+static int motTipsSet(Ihandle *ih)
+{
+  char* tipText = iupAttribGet(ih, "TIP");
+  if (!tipText)
+    return FALSE;
+
+  if (!mot_tips.Dialog)
+  {
+    mot_tips.Dialog = XtVaAppCreateShell(" ", "tip",
+      overrideShellWidgetClass, iupmot_display,
+      XmNmappedWhenManaged, False,
+      NULL);
+
+    mot_tips.Label = XtVaCreateManagedWidget("label tip",
+      xmLabelWidgetClass, mot_tips.Dialog,     /* must use IupGetAttribute to use inheritance */
+      XmNforeground, iupmotColorGetPixelStr(IupGetAttribute(ih, "TIPFGCOLOR")),
+      XmNbackground, iupmotColorGetPixelStr(IupGetAttribute(ih, "TIPBGCOLOR")),
+      NULL);
+
+    XtRealizeWidget(mot_tips.Dialog);
+  }
+
+  /* set label font */
+  {
+    XmFontList fontlist = (XmFontList)iupmotGetFontListAttrib(ih);
+    char* value = iupAttribGetStr(ih, "TIPFONT");
+    if (value)
+    {
+      if (iupStrEqualNoCase(value, "SYSTEM"))
+        fontlist = NULL;
+      else
+        fontlist = iupmotGetFontList(iupAttribGet(ih, "TIPFOUNDRY"), value);
+    }
+
+    if (fontlist)
+      XtVaSetValues(mot_tips.Label, XmNfontList, fontlist, NULL);
+  }
+ 
+  /* set label contents */
+  iupmotSetString(mot_tips.Label, XmNlabelString, tipText);
+
+  /* set label size */
+  {
+    int lw = 0, lh = 0;
+    iupdrvFontGetMultiLineStringSize(ih, tipText, &lw, &lh);
+
+    /* add room for margin */
+    lw += 2*(2);
+    lh += 2*(2);  
+
+    XtVaSetValues(mot_tips.Label,
+      XmNwidth, (XtArgVal)lw,
+      XmNheight, (XtArgVal)lh,
+      NULL);
+    XtVaSetValues(mot_tips.Dialog,
+      XmNwidth, (XtArgVal)lw,
+      XmNheight, (XtArgVal)lh,
+      NULL);
+  }
+
+  mot_tips.ShowTimerId  = (XtIntervalId) NULL;
+  mot_tips.HideTimerId  = (XtIntervalId) NULL;
+  mot_tips.Visible      = FALSE;
+  mot_tips.ShowInterval = 500;  /* 1/2 second to show */
+
+  {
+    int delay = IupGetInt(ih, "TIPDELAY");  /* must use IupGetInt to use inheritance */
+    mot_tips.HideInterval = delay + mot_tips.ShowInterval;
+  }
+
+  return TRUE;
+}
+
+int iupdrvBaseSetTipVisibleAttrib(Ihandle* ih, const char* value)
+{
+  /* must use IupGetAttribute to use inheritance */
+  if (!IupGetAttribute(ih, "TIP"))
+    return 0;
+
+  if (iupStrBoolean(value))
+    iupmotTipEnterNotify(ih);
+  else
+    iupmotTipLeaveNotify();
+
+  return 0;
+}
+
+void iupmotTipEnterNotify(Ihandle *ih)
+{
+  iupmotTipLeaveNotify();
+
+  if (motTipsSet(ih) == FALSE)
+    return;
+
+  mot_tips.ih = ih;
+
+  mot_tips.ShowTimerId = XtAppAddTimeOut( /* EnterWin to Show */
+    iupmot_appcontext,
+    mot_tips.ShowInterval,
+    (XtTimerCallbackProc)motTipsShow,
+    NULL);
+  mot_tips.HideTimerId = XtAppAddTimeOut( /* Visible to Hide */
+    iupmot_appcontext,
+    mot_tips.HideInterval,
+    (XtTimerCallbackProc)motTipsHide,
+    NULL);
+}
+
+void iupmotTipLeaveNotify(void)
+{
+  if (mot_tips.ShowTimerId)
+  {
+    XtRemoveTimeOut(mot_tips.ShowTimerId);
+    mot_tips.ShowTimerId = (XtIntervalId) NULL;
+  }
+  if (mot_tips.HideTimerId)
+  {
+    XtRemoveTimeOut(mot_tips.HideTimerId);
+    mot_tips.HideTimerId = (XtIntervalId) NULL;
+  }
+  if (mot_tips.Visible)
+  {
+    XtUnmapWidget(mot_tips.Dialog);
+    mot_tips.Visible = FALSE;
+  }
+}
+
+void iupmotTipsFinish(void)
+{
+  if (mot_tips.Dialog)
+  {
+    XtDestroyWidget(mot_tips.Dialog);
+    memset(&mot_tips, 0, sizeof(Imottips));
+  }
+}
+
+int iupdrvBaseSetTipAttrib(Ihandle* ih, const char* value)
+{
+  /* implement this stub here because of the other drivers. */
+  (void)ih;
+  (void)value;
+  return 1;
+}
diff --git a/iup/src/mot/iupmot_toggle.c b/iup/src/mot/iupmot_toggle.c
new file mode 100755
index 0000000..b18f24d
--- /dev/null
+++ b/iup/src/mot/iupmot_toggle.c
@@ -0,0 +1,469 @@
+/** \file
+ * \brief Toggle Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/ToggleB.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_dialog.h"
+#include "iup_str.h"
+#include "iup_toggle.h"
+#include "iup_drv.h"
+#include "iup_image.h"
+#include "iup_key.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+void iupdrvToggleAddCheckBox(int *x, int *y)
+{
+  (*x) += 15+6+3;
+  if ((*y) < 15+6) (*y) = 12+6; /* minimum height */
+  (*y) += 6;
+}
+
+
+/*********************************************************************************/
+
+
+static int motToggleSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_TOGGLE_TEXT)
+  {
+    char* parent_value = iupAttribGetInheritNativeParent(ih, "BGCOLOR");
+    if (!parent_value)
+    {
+      /* if not defined at a native parent, 
+         then change the toggle button color to the given color instead using the default */
+      if (iupdrvBaseSetBgColorAttrib(ih, value))  /* let XmChangeColor do its job */
+      {
+        parent_value = IupGetGlobal("DLGBGCOLOR");
+        XtVaSetValues(ih->handle, XmNbackground, iupmotColorGetPixelStr(parent_value), NULL);  /* reset just the background */
+
+        if (ih->data->radio)
+          XtVaSetValues(ih->handle, XmNselectColor, iupmotColorGetPixel(0, 0, 0), NULL);
+        XtVaSetValues(ih->handle, XmNunselectColor, iupmotColorGetPixelStr(value), NULL);
+        return 1;
+      }
+    }
+    else
+    {
+      /* ignore given value, must use only from parent */
+      if (iupdrvBaseSetBgColorAttrib(ih, parent_value))
+      {
+        if (ih->data->radio)
+          XtVaSetValues(ih->handle, XmNselectColor, iupmotColorGetPixel(0, 0, 0), NULL);
+        XtVaSetValues(ih->handle, XmNunselectColor, iupmotColorGetPixelStr(parent_value), NULL);
+        return 1;
+      }
+    }
+    return 0; 
+  }
+  else
+    return iupdrvBaseSetBgColorAttrib(ih, value); 
+}
+
+static int motToggleSetBackgroundAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_TOGGLE_TEXT)
+  {
+    Pixel color;
+
+    /* ignore given value, must use only from parent */
+    value = iupAttribGetInheritNativeParent(ih, "BACKGROUND");
+
+    color = iupmotColorGetPixelStr(value);
+    if (color != (Pixel)-1)
+    {
+      XtVaSetValues(ih->handle, XmNbackground, color, NULL);
+      return 1;
+    }
+    else
+    {
+      Pixmap pixmap = (Pixmap)iupImageGetImage(value, ih, 0);
+      if (pixmap)
+      {
+        XtVaSetValues(ih->handle, XmNbackgroundPixmap, pixmap, NULL);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+static int motToggleSetTitleAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_TOGGLE_TEXT)
+  {
+    iupmotSetMnemonicTitle(ih, value);
+    return 1;
+  }
+
+  return 0;
+}
+
+static int motToggleSetAlignmentAttrib(Ihandle* ih, const char* value)
+{
+  unsigned char align;
+  char value1[30]="", value2[30]="";
+
+  if (ih->data->type == IUP_TOGGLE_TEXT)
+    return 0;
+
+  iupStrToStrStr(value, value1, value2, ':');   /* value2 is ignored, NOT supported in Motif */
+
+  if (iupStrEqualNoCase(value1, "ARIGHT"))
+    align = XmALIGNMENT_END;
+  else if (iupStrEqualNoCase(value1, "ACENTER"))
+    align = XmALIGNMENT_CENTER;
+  else /* "ALEFT" */
+    align = XmALIGNMENT_BEGINNING;
+
+  XtVaSetValues (ih->handle, XmNalignment, align, NULL);
+  return 1;
+}
+
+static int motToggleSetImageAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_TOGGLE_IMAGE)
+  {
+    iupmotSetPixmap(ih, value, XmNlabelPixmap, 0);
+
+    if (!iupAttribGet(ih, "IMINACTIVE"))
+    {
+      /* if not active and IMINACTIVE is not defined 
+         then automaticaly create one based on IMAGE */
+      iupmotSetPixmap(ih, value, XmNlabelInsensitivePixmap, 1); /* make_inactive */
+    }
+    return 1;
+  }
+  else
+    return 0;
+}
+
+static int motToggleSetImInactiveAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_TOGGLE_IMAGE)
+  {
+    iupmotSetPixmap(ih, value, XmNlabelInsensitivePixmap, 0);
+    return 1;
+  }
+  else
+    return 0;
+}
+
+static int motToggleSetImPressAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->type == IUP_TOGGLE_IMAGE)
+  {
+    iupmotSetPixmap(ih, value, XmNselectPixmap, 0);
+    return 1;
+  }
+  else
+    return 0;
+}
+
+static int motToggleSetValueAttrib(Ihandle* ih, const char* value)
+{
+  Ihandle *radio;
+  unsigned char check;
+
+  if (iupStrEqualNoCase(value,"NOTDEF"))
+    check = XmINDETERMINATE;
+  else if (iupStrBoolean(value))
+    check = XmSET;
+  else
+    check = XmUNSET;
+
+  /* This is necessary because Motif toggle does not have support for radio. 
+     It is implemented using an external RadioBox that we do not use. */
+  radio = iupRadioFindToggleParent(ih);
+  if (radio)
+  {
+    Ihandle* last_tg;
+    unsigned char oldcheck;
+
+    XtVaGetValues(ih->handle, XmNset, &oldcheck, NULL);
+
+    last_tg = (Ihandle*)iupAttribGet(radio, "_IUPMOT_LASTTOGGLE");
+    if (check)
+    {
+      if (iupObjectCheck(last_tg) && last_tg != ih)
+        XtVaSetValues(last_tg->handle, XmNset, XmUNSET, NULL);
+      iupAttribSetStr(radio, "_IUPMOT_LASTTOGGLE", (char*)ih);
+    }
+
+    if (last_tg != ih && oldcheck != check)
+      XtVaSetValues(ih->handle, XmNset, check, NULL);
+  }
+  else
+    XtVaSetValues(ih->handle, XmNset, check, NULL);
+
+  return 0;
+}
+
+static char* motToggleGetValueAttrib(Ihandle* ih)
+{
+  unsigned char check = 0;
+  XtVaGetValues (ih->handle, XmNset, &check, NULL);
+  if (check == XmINDETERMINATE)
+    return "NOTDEF";
+  else if (check == XmSET)
+    return "ON";
+  else
+    return "OFF";
+}
+
+static int motToggleSetPaddingAttrib(Ihandle* ih, const char* value)
+{
+  iupStrToIntInt(value, &ih->data->horiz_padding, &ih->data->vert_padding, 'x');
+  if (ih->handle && ih->data->type == IUP_TOGGLE_IMAGE)
+  {
+    XtVaSetValues(ih->handle, XmNmarginHeight, ih->data->vert_padding,
+                              XmNmarginWidth, ih->data->horiz_padding, NULL);
+  }
+  return 0;
+}
+
+static char* motToggleGetSelectColorAttrib(Ihandle* ih)
+{
+  unsigned char r, g, b;
+  Pixel color;
+  char* str = iupStrGetMemory(20);
+  XtVaGetValues(ih->handle, XmNselectColor, &color, NULL); 
+  iupmotColorGetRGB(color, &r, &g, &b);
+  sprintf(str, "%d %d %d", (int)r, (int)g, (int)b);
+  return str;
+}
+
+static int motToggleSetSelectColorAttrib(Ihandle* ih, const char *value)
+{
+  Pixel color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+    XtVaSetValues(ih->handle, XmNselectColor, color, NULL);
+  return 1;
+}
+
+static void motToggleValueChangedCallback(Widget w, Ihandle* ih, XmToggleButtonCallbackStruct* call_data)
+{
+  Ihandle *radio;
+  IFni cb;
+  int check = call_data->set;
+
+  /* Must manually hide the tip if the toggle is pressed. */
+  iupmotTipLeaveNotify();
+
+  /* This is necessary because Motif toggle does not have support for radio. 
+     It is implemented using an external RadioBox that we do not use. */
+  radio = iupRadioFindToggleParent(ih);
+  if (radio)
+  {
+    if (check)
+    {
+      Ihandle* last_tg = (Ihandle*)iupAttribGet(radio, "_IUPMOT_LASTTOGGLE");
+      if (iupObjectCheck(last_tg) && last_tg != ih)
+      {
+        /* uncheck last toggle */
+        XtVaSetValues(last_tg->handle, XmNset, XmUNSET, NULL);
+
+        cb = (IFni) IupGetCallback(last_tg, "ACTION");
+        if (cb && cb(last_tg, 0) == IUP_CLOSE)
+            IupExitLoop();
+
+        iupBaseCallValueChangedCb(last_tg);
+      }
+      iupAttribSetStr(radio, "_IUPMOT_LASTTOGGLE", (char*)ih);
+
+      if (last_tg != ih)
+      {
+        cb = (IFni)IupGetCallback(ih, "ACTION");
+        if (cb && cb (ih, 1) == IUP_CLOSE)
+            IupExitLoop();
+
+        iupBaseCallValueChangedCb(ih);
+      }
+    }
+    else
+    {
+      /* Force stay checked */
+      XtVaSetValues(ih->handle, XmNset, XmSET, NULL);
+    }
+  }
+  else
+  {
+    if (check == XmINDETERMINATE)
+       check = -1;
+
+    cb = (IFni)IupGetCallback(ih, "ACTION");
+    if (cb)
+    {
+      if (cb(ih, check) == IUP_CLOSE) 
+        IupExitLoop();
+    }
+
+    iupBaseCallValueChangedCb(ih);
+  }
+
+  (void)w;
+}
+
+static int motToggleMapMethod(Ihandle* ih)
+{
+  Ihandle* radio = iupRadioFindToggleParent(ih);
+  char* value;
+  int num_args = 0;
+  Arg args[40];
+
+  if (radio)
+    ih->data->radio = 1;
+
+  value = iupAttribGet(ih, "IMAGE");
+  if (value)
+  {
+    ih->data->type = IUP_TOGGLE_IMAGE;
+    iupmotSetArg(args, num_args, XmNlabelType, XmPIXMAP); 
+  }
+  else
+  {
+    ih->data->type = IUP_TOGGLE_TEXT;
+    iupmotSetArg(args, num_args, XmNlabelType, XmSTRING); 
+  }
+
+  /* Core */
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+  /* Primitive */
+  if (iupAttribGetBoolean(ih, "CANFOCUS"))
+    iupmotSetArg(args, num_args, XmNtraversalOn, True);
+  else
+    iupmotSetArg(args, num_args, XmNtraversalOn, False);
+  iupmotSetArg(args, num_args, XmNhighlightThickness, 2);
+  iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+  /* Label */
+  iupmotSetArg(args, num_args, XmNrecomputeSize, False);  /* no automatic resize from text */
+  iupmotSetArg(args, num_args, XmNmarginHeight, 0);  /* default padding */
+  iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+  iupmotSetArg(args, num_args, XmNmarginTop, 0);     /* no extra margins */
+  iupmotSetArg(args, num_args, XmNmarginLeft, 0);
+  iupmotSetArg(args, num_args, XmNmarginBottom, 0);
+  iupmotSetArg(args, num_args, XmNmarginRight, 0);
+
+  if (radio)
+  {
+    iupmotSetArg(args, num_args, XmNtoggleMode, XmTOGGLE_BOOLEAN);
+    iupmotSetArg(args, num_args, XmNindicatorType, XmONE_OF_MANY_ROUND);
+
+    if (!iupAttribGet(radio, "_IUPMOT_LASTTOGGLE"))
+    {
+      /* this is the first toggle in the radio, and the last toggle with VALUE=ON */
+      iupAttribSetStr(ih, "VALUE","ON");
+    }
+  }
+  else
+  {
+    if (ih->data->type == IUP_TOGGLE_TEXT && iupAttribGetBoolean(ih, "3STATE"))
+      iupmotSetArg(args, num_args, XmNtoggleMode, XmTOGGLE_INDETERMINATE);
+    else
+      iupmotSetArg(args, num_args, XmNtoggleMode, XmTOGGLE_BOOLEAN);
+    iupmotSetArg(args, num_args, XmNindicatorType, XmN_OF_MANY);
+  }
+
+  if (ih->data->type == IUP_TOGGLE_IMAGE)
+  {
+    iupmotSetArg(args, num_args, XmNindicatorOn, XmINDICATOR_NONE);
+    iupmotSetArg(args, num_args, XmNalignment, XmALIGNMENT_CENTER);
+    iupmotSetArg(args, num_args, XmNshadowThickness, 2);
+  }
+  else
+  {
+    iupmotSetArg(args, num_args, XmNspacing, 3);
+    iupmotSetArg(args, num_args, XmNindicatorOn, XmINDICATOR_CHECK_BOX);
+    iupmotSetArg(args, num_args, XmNalignment, XmALIGNMENT_BEGINNING);
+    if (radio)
+    {
+      iupmotSetArg(args, num_args, XmNindicatorSize, 13);
+      iupmotSetArg(args, num_args, XmNselectColor, iupmotColorGetPixel(0, 0, 0));
+    }
+    else
+      iupmotSetArg(args, num_args, XmNindicatorSize, 15);
+
+    iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+    iupmotSetArg(args, num_args, XmNdetailShadowThickness, 2);
+  }
+
+  ih->handle = XtCreateManagedWidget(
+    iupDialogGetChildIdStr(ih),  /* child identifier */
+    xmToggleButtonWidgetClass,     /* widget class */
+    iupChildTreeGetNativeParentHandle(ih), /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  XtAddCallback(ih->handle, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+
+  XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+
+  XtAddEventHandler(ih->handle, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, KeyPressMask,    False, (XtEventHandler)iupmotKeyPressEvent,    (XtPointer)ih);
+
+  XtAddCallback(ih->handle, XmNvalueChangedCallback, (XtCallbackProc)motToggleValueChangedCallback, (XtPointer)ih);
+
+  /* Disable Drag Source */
+  iupmotDisableDragSource(ih->handle);
+
+  /* initialize the widget */
+  XtRealizeWidget(ih->handle);
+
+  if (ih->data->type == IUP_TOGGLE_TEXT)
+    iupmotSetString(ih->handle, XmNlabelString, "");
+
+  return IUP_NOERROR;
+}
+
+void iupdrvToggleInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motToggleMapMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Overwrite Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", iupmotGetBgColorAttrib, motToggleSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "BACKGROUND", NULL, motToggleSetBackgroundAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, iupdrvBaseSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGFGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "TITLE", NULL, motToggleSetTitleAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+
+  /* IupToggle only */
+  iupClassRegisterAttribute(ic, "ALIGNMENT", NULL, motToggleSetAlignmentAttrib, IUPAF_SAMEASSYSTEM, "ACENTER:ACENTER", IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "IMAGE", NULL, motToggleSetImageAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "IMINACTIVE", NULL, motToggleSetImInactiveAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "IMPRESS", NULL, motToggleSetImPressAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "VALUE", motToggleGetValueAttrib, motToggleSetValueAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SELECTCOLOR", motToggleGetSelectColorAttrib, motToggleSetSelectColorAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+
+  iupClassRegisterAttribute(ic, "PADDING", iupToggleGetPaddingAttrib, motToggleSetPaddingAttrib, IUPAF_SAMEASSYSTEM, "0x0", IUPAF_NOT_MAPPED);
+}
diff --git a/iup/src/mot/iupmot_tree.c b/iup/src/mot/iupmot_tree.c
new file mode 100755
index 0000000..eb230af
--- /dev/null
+++ b/iup/src/mot/iupmot_tree.c
@@ -0,0 +1,2848 @@
+#include <Xm/Xm.h>
+#include <Xm/Form.h>
+#include <Xm/Container.h>
+#include <Xm/IconG.h>
+#include <Xm/ScrolledW.h>
+#include <Xm/XmosP.h>
+#include <Xm/Text.h>
+#include <Xm/Transfer.h>
+#include <Xm/DragDrop.h>
+#include <X11/keysym.h>
+
+#include <sys/stat.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+#include <limits.h>
+#include <time.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_dialog.h"
+#include "iup_layout.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_drv.h"
+#include "iup_drvinfo.h"
+#include "iup_drvfont.h"
+#include "iup_stdcontrols.h"
+#include "iup_key.h"
+#include "iup_image.h"
+#include "iup_array.h"
+#include "iup_tree.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+typedef struct _motTreeItemData
+{
+  Pixmap image, image_mask;
+  Pixmap image_expanded, image_expanded_mask;
+  unsigned char kind;
+  void* userdata;
+} motTreeItemData;
+
+
+static void motTreeShowEditField(Ihandle* ih, Widget wItem);
+static int motTreeGetNodeId(Ihandle* ih, Widget wItem);
+
+typedef int (*motTreeNodeFunc)(Ihandle* ih, Widget wItem, void* userdata);
+
+static int motTreeForEach(Ihandle* ih, Widget wItem, motTreeNodeFunc func, void* userdata)
+{
+  WidgetList wItemChildList = NULL;
+  int i, numChild;
+
+  if (!wItem)
+    wItem = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+
+  if (!func(ih, wItem, userdata))
+    return 0;
+
+  numChild = XmContainerGetItemChildren(ih->handle, wItem, &wItemChildList);
+  for (i=0; i<numChild; i++)
+  {
+    /* Recursively traverse child items */
+    if (!motTreeForEach(ih, wItemChildList[i], func, userdata))
+    {
+      XtFree((char*)wItemChildList);
+      return 0;
+    }
+  }
+  if (wItemChildList) XtFree((char*)wItemChildList);
+
+  return 1;
+}
+
+/*****************************************************************************/
+/* COPYING ITEMS (Branches and its children)                                 */
+/*****************************************************************************/
+/* Insert the copied item in a new location. Returns the new item. */
+static Widget motTreeCopyItem(Ihandle* ih, Widget wItem, Widget wParent, int pos, int full_copy)
+{
+  Widget wNewItem;
+  XmString title;
+  motTreeItemData *itemData;
+  Pixel fgcolor, bgcolor;
+  int num_args = 0;
+  Arg args[30];
+  Pixmap image = XmUNSPECIFIED_PIXMAP, mask = XmUNSPECIFIED_PIXMAP;
+  unsigned char state;
+
+  iupmotSetArg(args, num_args,  XmNentryParent, wParent);
+  iupmotSetArg(args, num_args, XmNmarginHeight, ih->data->spacing);
+  iupmotSetArg(args, num_args,  XmNmarginWidth, 0);
+  iupmotSetArg(args, num_args,     XmNviewType, XmSMALL_ICON);
+  iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+  iupmotSetArg(args, num_args, XmNtraversalOn, True);
+  iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+
+  /* Get values to copy */
+  XtVaGetValues(wItem, XmNlabelString, &title,
+                          XmNuserData, &itemData,
+                        XmNforeground, &fgcolor,
+                   XmNsmallIconPixmap, &image, 
+                     XmNsmallIconMask, &mask,
+                      XmNoutlineState, &state,
+                                       NULL);
+
+  if (full_copy) /* during a full copy the userdata reference is not copied */
+  {
+    /* create a new one */
+    motTreeItemData* itemDataNew = malloc(sizeof(motTreeItemData));
+    memcpy(itemDataNew, itemData, sizeof(motTreeItemData));
+    itemDataNew->userdata = NULL;
+    itemData = itemDataNew;
+  }
+
+  iupmotSetArg(args, num_args,  XmNlabelString, title);
+  iupmotSetArg(args, num_args,       XmNuserData, itemData);
+  iupmotSetArg(args, num_args,   XmNforeground, fgcolor);
+  iupmotSetArg(args, num_args, XmNsmallIconPixmap, image);
+  iupmotSetArg(args, num_args, XmNsmallIconMask, mask);
+  iupmotSetArg(args, num_args, XmNoutlineState, state);
+
+  iupmotSetArg(args, num_args,  XmNentryParent, wParent);
+  iupmotSetArg(args, num_args, XmNpositionIndex, pos);
+
+  XtVaGetValues(ih->handle, XmNbackground, &bgcolor, NULL);
+  iupmotSetArg(args, num_args,   XmNbackground, bgcolor);
+
+  wNewItem = XtCreateManagedWidget("icon", xmIconGadgetClass, ih->handle, args, num_args);
+
+  /* Root always expanded */
+  XtVaSetValues((Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM"), XmNoutlineState, XmEXPANDED, NULL);
+
+  XtRealizeWidget(wNewItem);
+
+  return wNewItem;
+}
+
+static void motTreeCopyChildren(Ihandle* ih, Widget wItemSrc, Widget wItemDst, int full_copy)
+{
+  WidgetList wItemChildList = NULL;
+  int i = 0;
+  int numChild = XmContainerGetItemChildren(ih->handle, wItemSrc, &wItemChildList);
+  while(i != numChild)
+  {
+    Widget wNewItem = motTreeCopyItem(ih, wItemChildList[i], wItemDst, i, full_copy);  /* Use the same order they where enumerated */
+
+    /* Recursively transfer all the items */
+    motTreeCopyChildren(ih, wItemChildList[i], wNewItem, full_copy);  
+
+    /* Go to next sibling item */
+    i++;
+  }
+
+  if (wItemChildList) XtFree((char*)wItemChildList);
+}
+
+/* Copies all items in a branch to a new location. Returns the new branch node. */
+static Widget motTreeCopyNode(Ihandle* ih, Widget wItemSrc, Widget wItemDst, int full_copy)
+{
+  Widget wNewItem, wParent;
+  motTreeItemData *itemDataDst;
+  unsigned char stateDst;
+  int pos;
+
+  XtVaGetValues(wItemDst, XmNoutlineState, &stateDst, 
+                          XmNuserData, &itemDataDst, 
+                          NULL);
+
+  if (itemDataDst->kind == ITREE_BRANCH && stateDst == XmEXPANDED)
+  {
+    /* copy as first child of expanded branch */
+    wParent = wItemDst;
+    pos = 0;
+  }
+  else
+  {
+    /* copy as next brother of item or collapsed branch */
+    XtVaGetValues(wItemDst, XmNentryParent, &wParent, NULL);
+    XtVaGetValues(wItemDst, XmNpositionIndex, &pos, NULL);
+    pos++;
+  }
+
+  wNewItem = motTreeCopyItem(ih, wItemSrc, wParent, pos, full_copy);
+
+  motTreeCopyChildren(ih, wItemSrc, wNewItem, full_copy);
+
+  return wNewItem;
+}
+
+static void motTreeContainerDeselectAll(Ihandle *ih)
+{
+  XKeyEvent ev;
+
+  memset(&ev, 0, sizeof(XKeyEvent));
+  ev.type = KeyPress;
+  ev.display = XtDisplay(ih->handle);
+  ev.send_event = True;
+  ev.root = RootWindow(iupmot_display, iupmot_screen);
+  ev.time = clock()*CLOCKS_PER_SEC;
+  ev.window = XtWindow(ih->handle);
+  ev.state = ControlMask;
+  ev.keycode = XK_backslash;
+  ev.same_screen = True;
+
+  XtCallActionProc(ih->handle, "ContainerDeselectAll", (XEvent*)&ev, 0, 0);
+}
+
+static void motTreeContainerSelectAll(Ihandle *ih)
+{
+  XKeyEvent ev;
+
+  memset(&ev, 0, sizeof(XKeyEvent));
+  ev.type = KeyPress;
+  ev.display = XtDisplay(ih->handle);
+  ev.send_event = True;
+  ev.root = RootWindow(iupmot_display, iupmot_screen);
+  ev.time = clock()*CLOCKS_PER_SEC;
+  ev.window = XtWindow(ih->handle);
+  ev.state = ControlMask;
+  ev.keycode = XK_slash;
+  ev.same_screen = True;
+
+  XtCallActionProc(ih->handle, "ContainerSelectAll", (XEvent*)&ev, 0, 0);
+}
+
+static Widget motTreeGetLastVisibleNode(Ihandle* ih, Widget wItem)
+{
+  unsigned char itemState;
+
+  XtVaGetValues(wItem, XmNoutlineState, &itemState, NULL);
+
+  if (itemState == XmEXPANDED)
+  {
+    WidgetList wChildrenTree = NULL;
+    int numChildren = XmContainerGetItemChildren(ih->handle, wItem, &wChildrenTree);
+    if(numChildren)
+      wItem = motTreeGetLastVisibleNode(ih, wChildrenTree[numChildren - 1]);
+    if (wChildrenTree) XtFree((char*)wChildrenTree);
+  }
+
+  return wItem;
+}
+
+static Widget motTreeFindVisibleNodeId(Ihandle* ih, WidgetList itemList, int numItems, Widget itemNode)
+{
+  Widget itemChild;
+  WidgetList itemChildList;
+  int i = 0;
+  int numChild;
+  unsigned char itemState;
+
+  while(i != numItems)
+  {
+    /* ID control to traverse items */
+    ih->data->id_control++;   /* not the real id since it counts only the visible ones */
+
+    /* StateID founded! */
+    if(itemList[i] == itemNode)
+      return itemList[i];
+
+    /* Check whether we have child items */
+    itemChildList = NULL;
+    numChild = XmContainerGetItemChildren(ih->handle, itemList[i], &itemChildList);
+    XtVaGetValues(itemList[i], XmNoutlineState,  &itemState, NULL);
+
+    /* The itemWidget has child and it is expanded (visible) */
+    if (numChild && itemState == XmEXPANDED)
+    {
+      /* pass the list of children of this item */
+      itemChild = motTreeFindVisibleNodeId(ih, itemChildList, numChild, itemNode);
+
+      /* StateID founded! */
+      if(itemChild)
+      {
+        XtFree((char*)itemChildList);
+        return itemChild;
+      }
+    }
+
+    if (itemChildList) XtFree((char*)itemChildList);
+    /* Go to next sibling item */
+    i++;
+  }
+
+  return NULL;
+}
+
+static Widget motTreeFindVisibleNodeFromId(Ihandle* ih, WidgetList itemList, int numItems)
+{
+  Widget itemChild;
+  WidgetList itemChildList;
+  int i = 0;
+  int numChild;
+  unsigned char itemState;
+
+  while(i != numItems)
+  {
+    /* ID control to traverse items */
+    ih->data->id_control--;    /* not the real id since it counts only the visible ones */
+
+    /* StateID founded! */
+    if(ih->data->id_control < 0)
+      return itemList[i];
+
+    /* Check whether we have child items */
+    itemChildList = NULL;
+    numChild = XmContainerGetItemChildren(ih->handle, itemList[i], &itemChildList);
+    XtVaGetValues(itemList[i], XmNoutlineState,  &itemState, NULL);
+
+    /* The itemWidget has child and it is expanded (visible) */
+    if (numChild && itemState == XmEXPANDED)
+    {
+      /* pass the list of children of this item */
+      itemChild = motTreeFindVisibleNodeFromId(ih, itemChildList, numChild);
+
+      /* StateID founded! */
+      if(ih->data->id_control < 0)
+      {
+        if (itemChildList) XtFree((char*)itemChildList);
+        return itemChild;
+      }
+    }
+
+    if (itemChildList) XtFree((char*)itemChildList);
+    /* Go to next sibling item */
+    i++;
+  }
+
+  return NULL;
+}
+
+static Widget motTreeGetNextVisibleNode(Ihandle* ih, Widget wRoot, Widget wItem)
+{
+  Widget wNext;
+
+  ih->data->id_control = -1;
+  motTreeFindVisibleNodeId(ih, &wRoot, 1, wItem);
+  ih->data->id_control++;   /* more 1 visible node */
+
+  wNext = motTreeFindVisibleNodeFromId(ih, &wRoot, 1);
+
+  if (ih->data->id_control >= 0)
+    wNext = motTreeGetLastVisibleNode(ih, wRoot);
+
+  return wNext;
+}
+
+static Widget motTreeGetPreviousVisibleNode(Ihandle* ih, Widget wRoot, Widget wItem)
+{
+  ih->data->id_control = -1;
+  motTreeFindVisibleNodeId(ih, &wRoot, 1, wItem);
+  ih->data->id_control--;    /* less 1 visible node */
+
+  if (ih->data->id_control < 0)
+    ih->data->id_control = 0;  /* Begin of tree = Root id */
+
+  return motTreeFindVisibleNodeFromId(ih, &wRoot, 1);
+}
+
+static void motTreeUpdateBgColor(Ihandle* ih, WidgetList itemList, int numItems, Pixel bgcolor)
+{
+  WidgetList itemChildList;
+  int i = 0;
+  int numChild;
+
+  while(i != numItems)
+  {
+    XtVaSetValues(itemList[i], XmNbackground, bgcolor, NULL);
+
+    /* Check whether we have child items */
+    itemChildList = NULL;
+    numChild = XmContainerGetItemChildren(ih->handle, itemList[i], &itemChildList);
+    if(numChild)
+      motTreeUpdateBgColor(ih, itemChildList, numChild, bgcolor);
+    if (itemChildList) XtFree((char*)itemChildList);
+
+    /* Go to next sibling item */
+    i++;
+  }
+}
+
+static void motTreeUpdateImages(Ihandle* ih, WidgetList itemList, int numItems, int mode)
+{
+  motTreeItemData *itemData;
+  int i = 0;
+
+  /* called when one of the default images is changed */
+
+  while(i != numItems)
+  {
+    /* Get node attributes */
+    XtVaGetValues(itemList[i], XmNuserData, &itemData, NULL);
+	  
+    if (itemData->kind == ITREE_BRANCH)
+    {
+      unsigned char itemState;
+      XtVaGetValues(itemList[i], XmNoutlineState,  &itemState, NULL);
+      
+      if (itemState == XmEXPANDED)
+      {
+        if (mode == ITREE_UPDATEIMAGE_EXPANDED)
+        {
+          XtVaSetValues(itemList[i], XmNsmallIconPixmap, (itemData->image_expanded!=XmUNSPECIFIED_PIXMAP)? itemData->image_expanded: (Pixmap)ih->data->def_image_expanded, NULL);
+          XtVaSetValues(itemList[i], XmNsmallIconMask, (itemData->image_expanded_mask!=XmUNSPECIFIED_PIXMAP)? itemData->image_expanded_mask: (Pixmap)ih->data->def_image_expanded_mask, NULL);
+        }
+      }
+      else 
+      {
+        if (mode == ITREE_UPDATEIMAGE_COLLAPSED)
+        {
+          XtVaSetValues(itemList[i], XmNsmallIconPixmap, (itemData->image!=XmUNSPECIFIED_PIXMAP)? itemData->image: (Pixmap)ih->data->def_image_collapsed, NULL);
+          XtVaSetValues(itemList[i], XmNsmallIconMask, (itemData->image_mask!=XmUNSPECIFIED_PIXMAP)? itemData->image_mask: (Pixmap)ih->data->def_image_collapsed_mask, NULL);
+        }
+      }
+
+      /* Recursively traverse child items */
+      {
+        WidgetList itemChildList;
+        int numChild;
+        itemChildList = NULL;
+        numChild = XmContainerGetItemChildren(ih->handle, itemList[i], &itemChildList);
+        motTreeUpdateImages(ih, itemChildList, numChild, mode);
+        if (itemChildList) XtFree((char*)itemChildList);
+      }
+    }
+    else 
+    {
+      if (mode == ITREE_UPDATEIMAGE_LEAF)
+      {
+        XtVaSetValues(itemList[i], XmNsmallIconPixmap, (itemData->image!=XmUNSPECIFIED_PIXMAP)? itemData->image: (Pixmap)ih->data->def_image_leaf, NULL);
+        XtVaSetValues(itemList[i], XmNsmallIconMask, (itemData->image_mask!=XmUNSPECIFIED_PIXMAP)? itemData->image_mask: (Pixmap)ih->data->def_image_leaf_mask, NULL);
+      }
+    }
+
+    /* Go to next sibling node */
+    i++;
+  }
+}
+
+static int motTreeSelectFunc(Ihandle* ih, Widget wItem, int *select)
+{
+  int do_select = *select;
+  if (do_select == -1)
+  {
+    unsigned char isSelected;
+    XtVaGetValues(wItem, XmNvisualEmphasis, &isSelected, NULL);
+    do_select = (isSelected == XmSELECTED)? 0: 1; /* toggle */
+  }
+
+  if (do_select)
+    XtVaSetValues(wItem, XmNvisualEmphasis, XmSELECTED, NULL);
+  else
+    XtVaSetValues(wItem, XmNvisualEmphasis, XmNOT_SELECTED, NULL);
+
+  (void)ih;
+  return 1;
+}
+
+static void motTreeInvertAllNodeMarking(Ihandle* ih)
+{
+  int select = -1;
+  motTreeForEach(ih, NULL, (motTreeNodeFunc)motTreeSelectFunc, &select);
+}
+
+typedef struct _motTreeRange{
+  Widget wItem1, wItem2;
+  char inside, clear;
+}motTreeRange;
+
+static int motTreeSelectRangeFunc(Ihandle* ih, Widget wItem, motTreeRange* range)
+{
+  int end_range = 0;
+
+  if (range->inside == 0) /* detect the range start */
+  {
+    if (range->wItem1 == wItem) range->inside=1;
+    else if (range->wItem2 == wItem) range->inside=1;
+  }
+  else if (range->inside == 1) /* detect the range end */
+  {
+    if (range->wItem1 == wItem) end_range=1;
+    else if (range->wItem2 == wItem) end_range=1;
+  }
+
+  if (range->inside == 1) /* if inside, select */
+    XtVaSetValues(wItem, XmNvisualEmphasis, XmSELECTED, NULL);
+  else if (range->clear)  /* if outside and clear, unselect */
+    XtVaSetValues(wItem, XmNvisualEmphasis, XmNOT_SELECTED, NULL);
+
+  if (end_range || (range->inside && range->wItem1==range->wItem2))
+    range->inside=-1;  /* update after selecting the node */
+
+  (void)ih;
+  return 1;
+}
+
+static void motTreeSelectRange(Ihandle* ih, Widget wItem1, Widget wItem2, int clear)
+{
+  motTreeRange range;
+  range.wItem1 = wItem1;
+  range.wItem2 = wItem2;
+  range.inside = 0;
+  range.clear = (char)clear;
+  motTreeForEach(ih, NULL, (motTreeNodeFunc)motTreeSelectRangeFunc, &range);
+}
+
+void motTreeExpandCollapseAllNodes(Ihandle* ih, WidgetList itemList, int numItems, unsigned char itemState)
+{
+  WidgetList itemChildList;
+  int numChild;
+  int i = 0;
+
+  while(i != numItems)
+  {
+    /* Check whether we have child items */
+    itemChildList = NULL;
+    numChild = XmContainerGetItemChildren(ih->handle, itemList[i], &itemChildList);
+
+    if(numChild)
+    {
+      XtVaSetValues(itemList[i], XmNoutlineState, itemState, NULL);
+      motTreeExpandCollapseAllNodes(ih, itemChildList, numChild, itemState);
+    }
+
+    if (itemChildList) XtFree((char*)itemChildList);
+    /* Go to next sibling item */
+    i++;
+  }
+}
+
+static void motTreeDestroyItemData(Ihandle* ih, Widget wItem)
+{
+  motTreeItemData *itemData = NULL;
+  XtVaGetValues(wItem, XmNuserData, &itemData, NULL);
+  if (itemData)
+  {
+    IFnis cb = (IFnis)IupGetCallback(ih, "NODEREMOVED_CB");
+    if (cb) cb(ih, motTreeGetNodeId(ih, wItem), (char*)itemData->userdata);
+    free(itemData);
+    XtVaSetValues(wItem, XmNuserData, NULL, NULL);
+  }
+}
+
+static void motTreeRemoveChildren(Ihandle* ih, WidgetList itemList, int numItems, int del_userdata)
+{
+  WidgetList itemChildList;
+  int numChild;
+  int i = 0;
+
+  while(i != numItems)
+  {	  
+    /* Check whether we have child items */
+    itemChildList = NULL;
+    numChild = XmContainerGetItemChildren(ih->handle, itemList[i], &itemChildList);
+    if (numChild)
+      motTreeRemoveChildren(ih, itemChildList, numChild, del_userdata);
+
+    if (del_userdata)
+      motTreeDestroyItemData(ih, itemList[i]);
+
+    XtDestroyWidget(itemList[i]);
+
+    if (itemChildList) XtFree((char*)itemChildList);
+    /* Go to next sibling item */
+    i++;
+  }
+}
+
+static void motTreeRemoveNode(Ihandle* ih, Widget wItem, int del_userdata)
+{
+  WidgetList wChildList = NULL;
+  int numChild = XmContainerGetItemChildren(ih->handle, wItem, &wChildList);
+  if (numChild)
+    motTreeRemoveChildren(ih, wChildList, numChild, del_userdata);
+  if (del_userdata)
+    motTreeDestroyItemData(ih, wItem);
+  XtDestroyWidget(wItem);
+  if (wChildList) XtFree((char*)wChildList);
+}
+
+static Widget motTreeFindNodeID(Ihandle* ih, WidgetList itemList, int numItems, Widget itemNode)
+{
+  Widget itemChild;
+  WidgetList itemChildList;
+  int i = 0;
+  int numChild;
+
+  while(i != numItems)
+  {
+    /* ID control to traverse items */
+    ih->data->id_control++;
+
+    /* StateID founded! */
+    if(itemList[i] == itemNode)
+      return itemList[i];
+
+    /* Check whether we have child items */
+    itemChildList = NULL;
+    numChild = XmContainerGetItemChildren(ih->handle, itemList[i], &itemChildList);
+    if(numChild)
+    {
+      /* pass the list of children of this item */
+      itemChild = motTreeFindNodeID(ih, itemChildList, numChild, itemNode);
+
+      /* StateID founded! */
+      if(itemChild)
+      {
+        if (itemChildList) XtFree((char*)itemChildList);
+        return itemChild;
+      }
+    }
+
+    if (itemChildList) XtFree((char*)itemChildList);
+    /* Go to next sibling item */
+    i++;
+  }
+
+  return NULL;
+}
+
+static Widget motTreeFindNodeFromID(Ihandle* ih, WidgetList itemList, int numItems)
+{
+  Widget itemChild;
+  WidgetList itemChildList;
+  int i = 0;
+  int numChild;
+
+  while(i != numItems)
+  {
+    /* ID control to traverse items */
+    ih->data->id_control--;
+
+    /* StateID founded! */
+    if(ih->data->id_control < 0)
+      return itemList[i];
+
+    /* Check whether we have child items */
+    itemChildList = NULL;
+    numChild = XmContainerGetItemChildren(ih->handle, itemList[i], &itemChildList);
+    if(numChild)
+    {
+      /* pass the list of children of this item */
+      itemChild = motTreeFindNodeFromID(ih, itemChildList, numChild);
+
+      /* StateID founded! */
+      if(ih->data->id_control < 0)
+      {
+        if (itemChildList) XtFree((char*)itemChildList);
+        return itemChild;
+      }
+    }
+
+    if (itemChildList) XtFree((char*)itemChildList);
+    /* Go to next sibling item */
+    i++;
+  }
+
+  return NULL;
+}
+
+static int motTreeGetNodeId(Ihandle* ih, Widget wItem)
+{
+  Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+  ih->data->id_control = -1;
+  if (motTreeFindNodeID(ih, &wRoot, 1, wItem))
+    return ih->data->id_control;
+  else
+    return -1;
+}
+
+static Widget motTreeFindUserDataID(Ihandle* ih, WidgetList itemList, int numItems, void* userdata)
+{
+  Widget itemChild;
+  WidgetList itemChildList;
+  motTreeItemData *itemData;
+  int i = 0;
+  int numChild;
+
+  while(i != numItems)
+  {
+    /* ID control to traverse items */
+    ih->data->id_control++;
+
+    XtVaGetValues(itemList[i], XmNuserData, &itemData, NULL);
+
+    /* StateID founded! */
+    if(itemData->userdata == userdata)
+      return itemList[i];
+
+    /* Check whether we have child items */
+    itemChildList = NULL;
+    numChild = XmContainerGetItemChildren(ih->handle, itemList[i], &itemChildList);
+    if(numChild)
+    {
+      /* pass the list of children of this item */
+      itemChild = motTreeFindUserDataID(ih, itemChildList, numChild, userdata);
+
+      /* StateID founded! */
+      if (itemChild)
+      {
+        if (itemChildList) XtFree((char*)itemChildList);
+        return itemChild;
+      }
+    }
+
+    if (itemChildList) XtFree((char*)itemChildList);
+    /* Go to next sibling item */
+    i++;
+  }
+
+  return NULL;
+}
+
+static int motTreeGetUserDataId(Ihandle* ih, void* userdata)
+{
+  Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+  ih->data->id_control = -1;
+  if (motTreeFindUserDataID(ih, &wRoot, 1, userdata))
+    return ih->data->id_control;
+  else
+    return -1;
+}
+
+static void motTreeSetFocusNode(Ihandle* ih, Widget wItem)
+{
+  iupAttribSetStr(ih, "_IUPTREE_LAST_FOCUS", (char*)wItem);
+  XmProcessTraversal(wItem, XmTRAVERSE_CURRENT);
+}
+
+static Widget motTreeGetFocusNode(Ihandle* ih)
+{
+  Widget wItem = XmGetFocusWidget(ih->handle);  /* returns the focus in the dialog */
+  if (wItem && XtParent(wItem) == ih->handle) /* is a node */
+    return wItem;
+
+  return (Widget)iupAttribGet(ih, "_IUPTREE_LAST_FOCUS");
+}
+
+static Widget motTreeFindNodeFromString(Ihandle* ih, const char* name_id)
+{
+  if (name_id[0])
+  {
+    Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+    iupStrToInt(name_id, &ih->data->id_control);
+    return motTreeFindNodeFromID(ih, &wRoot, 1);
+  }
+  else
+    return motTreeGetFocusNode(ih);
+}
+
+static void motTreeEnterLeaveWindowEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont)
+{
+  if (iupAttribGet(ih, "_IUPTREE_EDITFIELD"))
+    return;
+
+  /* usually when one Gadget is selected different than the previous one,
+     leave/enter events are generated. But we could not find the exact condition, 
+     so this is a workaround. Some leave events will be lost. */
+  if (evt->type == EnterNotify)
+  {
+    if (iupAttribGet(ih, "_IUPTREE_IGNORE_ENTERLEAVE"))
+    {
+      iupAttribSetStr(ih, "_IUPTREE_IGNORE_ENTERLEAVE", NULL);
+      return;
+    }
+  }
+  else  if (evt->type == LeaveNotify)
+  {
+    if (iupAttribGet(ih, "_IUPTREE_IGNORE_ENTERLEAVE"))
+      return;
+  }
+
+  iupmotEnterLeaveWindowEvent(w, ih, evt, cont);
+}
+
+static void motTreeFocusChangeEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont)
+{
+  unsigned char selpol;
+  Widget wItem = XmGetFocusWidget(w);  /* returns the focus in the dialog */
+  Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+
+  if (XtParent(wItem) == w) /* is a node */
+    iupAttribSetStr(ih, "_IUPTREE_LAST_FOCUS", (char*)wItem);
+
+  if (wItem == NULL || wItem == wRoot)
+  {
+    iupmotFocusChangeEvent(w, ih, evt, cont);
+    return;
+  }
+
+  XtVaGetValues(w, XmNselectionPolicy, &selpol, NULL);
+  if (selpol != XmSINGLE_SELECT)
+    return;
+
+  if (evt->type == FocusIn && !iupStrBoolean(IupGetGlobal("CONTROLKEY")))
+  {
+    XtVaSetValues(w, XmNselectedObjects,  NULL, NULL);
+    XtVaSetValues(w, XmNselectedObjectCount, 0, NULL);
+    XtVaSetValues(wItem, XmNvisualEmphasis, XmSELECTED, NULL);
+  }
+}
+
+void iupdrvTreeAddNode(Ihandle* ih, const char* name_id, int kind, const char* title, int add)
+{
+  Widget wItemPrev = motTreeFindNodeFromString(ih, name_id);
+  Widget wNewItem;
+  XmString itemTitle;
+  motTreeItemData *itemData, *itemDataPrev;
+  Pixel bgcolor, fgcolor;
+  int kindPrev, num_args = 0;
+  Arg args[30];
+
+  if (!wItemPrev)
+    return;
+
+  itemData = calloc(1, sizeof(motTreeItemData));
+  itemData->image = XmUNSPECIFIED_PIXMAP;
+  itemData->image_expanded = XmUNSPECIFIED_PIXMAP;
+  itemData->image_mask = XmUNSPECIFIED_PIXMAP;
+  itemData->image_expanded_mask = XmUNSPECIFIED_PIXMAP;
+  itemData->kind = (unsigned char)kind;
+
+  itemTitle = XmStringCreateLocalized((String)title);
+
+  /* Get default colors */
+  XtVaGetValues(ih->handle, XmNforeground, &fgcolor, NULL);
+  XtVaGetValues(ih->handle, XmNbackground, &bgcolor, NULL);
+
+  /* Get the kind of previous item */
+  XtVaGetValues(wItemPrev, XmNuserData, &itemDataPrev, NULL);
+  kindPrev = itemDataPrev->kind;
+
+  if (kindPrev == ITREE_BRANCH && add)
+  {
+    /* wItemPrev is parent of the new item (firstchild of it) */
+    iupmotSetArg(args, num_args,   XmNentryParent, wItemPrev);
+    iupmotSetArg(args, num_args, XmNpositionIndex, 0);
+  }
+  else
+  {
+    /* wItemPrev is sibling of the new item (set its parent to the new item) */
+    Widget wItemParent;
+    int pos;
+
+    XtVaGetValues(wItemPrev, XmNentryParent, &wItemParent, NULL);
+    XtVaGetValues(wItemPrev, XmNpositionIndex, &pos, NULL);
+
+    iupmotSetArg(args, num_args, XmNentryParent, wItemParent);
+    iupmotSetArg(args, num_args, XmNpositionIndex, pos+1);
+  }
+
+  iupmotSetArg(args, num_args,       XmNuserData, itemData);
+  iupmotSetArg(args, num_args,   XmNforeground, fgcolor);
+  iupmotSetArg(args, num_args,   XmNbackground, bgcolor);
+  iupmotSetArg(args, num_args, XmNmarginHeight, ih->data->spacing);
+  iupmotSetArg(args, num_args,  XmNmarginWidth, 0);
+  iupmotSetArg(args, num_args,     XmNviewType, XmSMALL_ICON);
+  iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+  iupmotSetArg(args, num_args, XmNtraversalOn, True);
+  iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+  iupmotSetArg(args, num_args, XmNlabelString, itemTitle);
+
+  if (kind == ITREE_BRANCH)
+  {
+    if (ih->data->add_expanded)
+    {
+      iupmotSetArg(args, num_args, XmNsmallIconPixmap, ih->data->def_image_expanded);
+      iupmotSetArg(args, num_args, XmNsmallIconMask, ih->data->def_image_expanded_mask);
+    }
+    else
+    {
+      iupmotSetArg(args, num_args, XmNsmallIconPixmap, ih->data->def_image_collapsed);
+      iupmotSetArg(args, num_args, XmNsmallIconMask, ih->data->def_image_collapsed_mask);
+    }
+  }
+  else
+  {
+    iupmotSetArg(args, num_args, XmNsmallIconPixmap, ih->data->def_image_leaf);
+    iupmotSetArg(args, num_args, XmNsmallIconMask, ih->data->def_image_leaf_mask);
+  }
+
+
+  wNewItem = XtCreateManagedWidget("icon", xmIconGadgetClass, ih->handle, args, num_args);
+
+  if (kind == ITREE_BRANCH)
+  {
+    if (ih->data->add_expanded)
+    {
+      iupAttribSetStr(ih, "_IUP_IGNORE_BRANCHOPEN", "1");
+      XtVaSetValues(wNewItem, XmNoutlineState, XmEXPANDED, NULL);
+    }
+    else
+      XtVaSetValues(wNewItem, XmNoutlineState, XmCOLLAPSED, NULL);
+  }
+
+  /* Root always expanded */
+  XtVaSetValues((Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM"), XmNoutlineState, XmEXPANDED, NULL);
+
+  XtRealizeWidget(wNewItem);
+  XmStringFree(itemTitle);
+}
+
+static void motTreeAddRootNode(Ihandle* ih)
+{
+  Widget wRootItem;
+  motTreeItemData *itemData;
+  Pixel bgcolor, fgcolor;
+  int num_args = 0;
+  Arg args[30];
+
+  itemData = calloc(1, sizeof(motTreeItemData));
+  itemData->image = XmUNSPECIFIED_PIXMAP;
+  itemData->image_expanded = XmUNSPECIFIED_PIXMAP;
+  itemData->image_mask = XmUNSPECIFIED_PIXMAP;
+  itemData->image_expanded_mask = XmUNSPECIFIED_PIXMAP;
+  itemData->kind = ITREE_BRANCH;
+
+  /* Get default foreground color */
+  XtVaGetValues(ih->handle, XmNforeground, &fgcolor, NULL);
+  XtVaGetValues(ih->handle, XmNbackground, &bgcolor, NULL);
+
+  iupmotSetArg(args, num_args,  XmNentryParent, NULL);
+  iupmotSetArg(args, num_args,       XmNuserData, itemData);
+  iupmotSetArg(args, num_args,   XmNforeground, fgcolor);
+  iupmotSetArg(args, num_args,   XmNbackground, bgcolor);
+  iupmotSetArg(args, num_args, XmNoutlineState, XmEXPANDED);
+  iupmotSetArg(args, num_args, XmNmarginHeight, ih->data->spacing);
+  iupmotSetArg(args, num_args,  XmNmarginWidth, 0);
+  iupmotSetArg(args, num_args,     XmNviewType, XmSMALL_ICON);
+  iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+  iupmotSetArg(args, num_args, XmNtraversalOn, True);
+  iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+  iupmotSetArg(args, num_args, XmNsmallIconPixmap, ih->data->def_image_expanded);
+  iupmotSetArg(args, num_args, XmNsmallIconMask, ih->data->def_image_expanded_mask);
+
+  wRootItem = XtCreateManagedWidget("icon", xmIconGadgetClass, ih->handle, args, num_args);
+
+  /* Select the new item */
+  XtVaSetValues(wRootItem, XmNvisualEmphasis, XmSELECTED, NULL);
+
+  XtRealizeWidget(wRootItem);
+
+  /* Save the root node for later use */
+  iupAttribSetStr(ih, "_IUPTREE_ROOTITEM", (char*)wRootItem);
+
+  /* MarkStart node */
+  iupAttribSetStr(ih, "_IUPTREE_MARKSTART_NODE", (char*)wRootItem);
+
+  /* Set the default VALUE */
+  /* In Motif this will set also the current focus */
+  motTreeSetFocusNode(ih, wRootItem);
+}
+
+/*****************************************************************************/
+
+static int motTreeSetImageExpandedAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  motTreeItemData *itemData;
+  unsigned char itemState;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)
+    return 0;
+
+  XtVaGetValues(wItem, XmNuserData, &itemData, NULL);
+  XtVaGetValues(wItem, XmNoutlineState, &itemState, NULL);
+  itemData->image_expanded = (Pixmap)iupImageGetImage(value, ih, 0);
+  if (!itemData->image_expanded)
+  {
+    itemData->image_expanded = XmUNSPECIFIED_PIXMAP;
+    itemData->image_expanded_mask = XmUNSPECIFIED_PIXMAP;
+  }
+  else
+  {
+    itemData->image_expanded_mask = (Pixmap)iupImageGetMask(value);
+    if (!itemData->image_expanded_mask) itemData->image_expanded_mask = XmUNSPECIFIED_PIXMAP;
+  }
+
+  if (itemData->kind == ITREE_BRANCH && itemState == XmEXPANDED)
+  {
+    if (itemData->image_expanded == XmUNSPECIFIED_PIXMAP)
+      XtVaSetValues(wItem, XmNsmallIconPixmap, (Pixmap)ih->data->def_image_expanded, 
+                           XmNsmallIconMask, (Pixmap)ih->data->def_image_expanded_mask, 
+                           NULL);
+    else
+      XtVaSetValues(wItem, XmNsmallIconPixmap, itemData->image_expanded, 
+                           XmNsmallIconMask, itemData->image_expanded_mask, 
+                           NULL);
+  }
+
+  return 1;
+}
+
+static int motTreeSetImageAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  motTreeItemData *itemData;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return 0;
+
+  XtVaGetValues(wItem, XmNuserData, &itemData, NULL);
+  itemData->image = (Pixmap)iupImageGetImage(value, ih, 0);
+  if (!itemData->image) 
+  {
+    itemData->image = XmUNSPECIFIED_PIXMAP;
+    itemData->image_mask = XmUNSPECIFIED_PIXMAP;
+  }
+  else
+  {
+    itemData->image_mask = (Pixmap)iupImageGetMask(value);
+    if (!itemData->image_mask) itemData->image_mask = XmUNSPECIFIED_PIXMAP;
+  }
+
+  if (itemData->kind == ITREE_BRANCH)
+  {
+    unsigned char itemState;
+    XtVaGetValues(wItem, XmNoutlineState, &itemState, NULL);
+    if (itemState == XmCOLLAPSED)
+    {
+      if (itemData->image == XmUNSPECIFIED_PIXMAP)
+        XtVaSetValues(wItem, XmNsmallIconPixmap, (Pixmap)ih->data->def_image_collapsed, 
+                             XmNsmallIconMask, (Pixmap)ih->data->def_image_collapsed_mask, 
+                             NULL);
+      else
+        XtVaSetValues(wItem, XmNsmallIconPixmap, itemData->image, 
+                             XmNsmallIconMask, itemData->image_mask, 
+                             NULL);
+    }
+  }
+  else
+  {
+    if (itemData->image == XmUNSPECIFIED_PIXMAP)
+      XtVaSetValues(wItem, XmNsmallIconPixmap, (Pixmap)ih->data->def_image_leaf, 
+                           XmNsmallIconMask, (Pixmap)ih->data->def_image_leaf_mask, 
+                           NULL);
+    else
+      XtVaSetValues(wItem, XmNsmallIconPixmap, itemData->image, 
+                           XmNsmallIconMask, itemData->image_mask, 
+                           NULL);
+  }
+
+  return 1;
+}
+
+static int motTreeSetImageBranchExpandedAttrib(Ihandle* ih, const char* value)
+{
+  Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+  ih->data->def_image_expanded = iupImageGetImage(value, ih, 0);
+  if (!ih->data->def_image_expanded) 
+  {
+    ih->data->def_image_expanded = (void*)XmUNSPECIFIED_PIXMAP;
+    ih->data->def_image_expanded_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+  else
+  {
+    ih->data->def_image_expanded_mask = iupImageGetMask(value);
+    if (!ih->data->def_image_expanded_mask) ih->data->def_image_expanded_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+    
+  /* Update all images, starting at root node */
+  motTreeUpdateImages(ih, &wRoot, 1, ITREE_UPDATEIMAGE_EXPANDED);
+
+  return 1;
+}
+
+static int motTreeSetImageBranchCollapsedAttrib(Ihandle* ih, const char* value)
+{
+  Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+  ih->data->def_image_collapsed = iupImageGetImage(value, ih, 0);
+  if (!ih->data->def_image_collapsed) 
+  {
+    ih->data->def_image_collapsed = (void*)XmUNSPECIFIED_PIXMAP;
+    ih->data->def_image_collapsed_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+  else
+  {
+    ih->data->def_image_collapsed_mask = iupImageGetMask(value);
+    if (!ih->data->def_image_collapsed_mask) ih->data->def_image_collapsed_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+   
+  /* Update all images, starting at root node */
+  motTreeUpdateImages(ih, &wRoot, 1, ITREE_UPDATEIMAGE_COLLAPSED);
+
+  return 1;
+}
+
+static int motTreeSetImageLeafAttrib(Ihandle* ih, const char* value)
+{
+  Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+  ih->data->def_image_leaf = iupImageGetImage(value, ih, 0);
+  if (!ih->data->def_image_leaf) 
+  {
+    ih->data->def_image_leaf = (void*)XmUNSPECIFIED_PIXMAP;
+    ih->data->def_image_leaf_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+  else
+  {
+    ih->data->def_image_leaf_mask = iupImageGetMask(value);
+    if (!ih->data->def_image_leaf_mask) ih->data->def_image_leaf_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+    
+  /* Update all images, starting at root node */
+  motTreeUpdateImages(ih, &wRoot, 1, ITREE_UPDATEIMAGE_LEAF);
+
+  return 1;
+}
+
+static char* motTreeGetStateAttrib(Ihandle* ih, const char* name_id)
+{
+  int hasChildren;
+  unsigned char itemState;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return 0;
+
+  XtVaGetValues(wItem, XmNnumChildren, &hasChildren, NULL);
+  XtVaGetValues(wItem, XmNoutlineState, &itemState, NULL);
+  
+  if (hasChildren)
+  {
+    if(itemState == XmEXPANDED)
+      return "EXPANDED";
+    else
+      return "COLLAPSED";
+  }
+
+  return NULL;
+}
+
+static int motTreeSetStateAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return 0;
+
+  if (iupStrEqualNoCase(value, "EXPANDED"))
+    XtVaSetValues(wItem, XmNoutlineState, XmEXPANDED, NULL);
+  else 
+    XtVaSetValues(wItem, XmNoutlineState, XmCOLLAPSED, NULL);
+
+  return 0;
+}
+
+static char* motTreeGetColorAttrib(Ihandle* ih, const char* name_id)
+{
+  unsigned char r, g, b;
+  Pixel color;
+  char* str;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);  
+  if (!wItem)  
+    return NULL;
+
+  XtVaGetValues(wItem, XmNforeground, &color, NULL); 
+  iupmotColorGetRGB(color, &r, &g, &b);
+
+  str = iupStrGetMemory(20);
+  sprintf(str, "%d %d %d", (int)r, (int)g, (int)b);
+  return str;
+}
+
+static int motTreeSetColorAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  Pixel color;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);  
+  if (!wItem)  
+    return 0;
+
+  color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+    XtVaSetValues(wItem, XmNforeground, color, NULL);
+  return 0; 
+}
+
+static char* motTreeGetDepthAttrib(Ihandle* ih, const char* name_id)
+{
+  Widget wRoot;
+  int dep = 0;
+  char* depth;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);  
+  if (!wItem)  
+    return NULL;
+
+  wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+
+  while((wRoot != wItem) && (wItem != NULL))
+  {
+    XtVaGetValues(wItem, XmNentryParent, &wItem, NULL);
+    dep++;
+  }
+
+  depth = iupStrGetMemory(10);
+  sprintf(depth, "%d", dep);
+  return depth;
+}
+
+static int motTreeSetMoveNodeAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  Widget wItemDst, wParent, wItemSrc;
+
+  if (!ih->handle)  /* do not store the action before map */
+    return 0;
+  wItemSrc = motTreeFindNodeFromString(ih, name_id);
+  if (!wItemSrc)
+    return 0;
+  wItemDst = motTreeFindNodeFromString(ih, value);
+  if (!wItemDst)
+    return 0;
+
+  /* If Drag item is an ancestor of Drop item then return */
+  wParent = wItemDst;
+  while(wParent)
+  {
+    XtVaGetValues(wParent, XmNentryParent, &wParent, NULL);
+    if (wParent == wItemSrc)
+      return 0;
+  }
+
+  /* Copying the node and its children to the new position */
+  motTreeCopyNode(ih, wItemSrc, wItemDst, 0);  /* not a full copy, preserve user data */
+
+  /* Deleting the node (and its children) inserted into the old position */
+  motTreeRemoveNode(ih, wItemSrc, 0);   /* do not delete the user data, we copy the references in CopyNode */
+
+  return 0;
+}
+
+static int motTreeSetCopyNodeAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  Widget wItemDst, wParent, wItemSrc;
+
+  if (!ih->handle)  /* do not store the action before map */
+    return 0;
+  wItemSrc = motTreeFindNodeFromString(ih, name_id);
+  if (!wItemSrc)
+    return 0;
+  wItemDst = motTreeFindNodeFromString(ih, value);
+  if (!wItemDst)
+    return 0;
+
+  /* If Drag item is an ancestor of Drop item then return */
+  wParent = wItemDst;
+  while(wParent)
+  {
+    XtVaGetValues(wParent, XmNentryParent, &wParent, NULL);
+    if (wParent == wItemSrc)
+      return 0;
+  }
+
+  /* Copying the node and its children to the new position */
+  motTreeCopyNode(ih, wItemSrc, wItemDst, 1);
+
+  return 0;
+}
+
+static char* motTreeGetParentAttrib(Ihandle* ih, const char* name_id)
+{
+  Widget wItemParent;
+  char* str;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return NULL;
+
+  /* get the parent item */
+  XtVaGetValues(wItem, XmNentryParent, &wItemParent, NULL);
+  if (!wItemParent)
+    return NULL;
+
+  str = iupStrGetMemory(10);
+  sprintf(str, "%d", motTreeGetNodeId(ih, wItemParent));
+  return str;
+}
+
+static char* motTreeGetChildCountAttrib(Ihandle* ih, const char* name_id)
+{
+  char* str;
+  WidgetList wList = NULL;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return NULL;
+
+  str = iupStrGetMemory(10);
+  sprintf(str, "%d", XmContainerGetItemChildren(ih->handle, wItem, &wList));
+  if (wList) XtFree((char*)wList);
+  return str;
+}
+
+static int motTreeCount(Ihandle* ih, Widget wItem)
+{
+  WidgetList wList = NULL;
+  int i, count = 0;
+  int childCount = XmContainerGetItemChildren(ih->handle, wItem, &wList);
+  count++;
+  for (i=0; i<childCount; i++)
+    count += motTreeCount(ih, wList[i]);
+  if (wList) XtFree((char*)wList);
+  return count;
+}
+
+static char* motTreeGetCountAttrib(Ihandle* ih)
+{
+  char* str = iupStrGetMemory(10);
+  Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+  sprintf(str, "%d", motTreeCount(ih, wRoot));
+  return str;
+}
+
+static char* motTreeGetKindAttrib(Ihandle* ih, const char* name_id)
+{
+  motTreeItemData *itemData;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return NULL;
+
+  XtVaGetValues(wItem, XmNuserData, &itemData, NULL);
+
+  if(itemData->kind == ITREE_BRANCH)
+    return "BRANCH";
+  else
+    return "LEAF";
+}
+
+static char* motTreeGetValueAttrib(Ihandle* ih)
+{
+  char* str;
+  Widget wItem = motTreeGetFocusNode(ih);
+  if (!wItem)
+    return "0"; /* default VALUE is root */
+
+  str = iupStrGetMemory(10);
+  sprintf(str, "%d", motTreeGetNodeId(ih, wItem));
+  return str;
+}
+
+static int motTreeSetMarkAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->mark_mode==ITREE_MARK_SINGLE)
+    return 0;
+
+  if(iupStrEqualNoCase(value, "CLEARALL"))
+    motTreeContainerDeselectAll(ih);
+  else if(iupStrEqualNoCase(value, "MARKALL"))
+    motTreeContainerSelectAll(ih);
+  else if(iupStrEqualNoCase(value, "INVERTALL")) /* INVERTALL *MUST* appear before INVERT, or else INVERTALL will never be called. */
+    motTreeInvertAllNodeMarking(ih);
+  else if(iupStrEqualPartial(value, "INVERT"))
+  {
+    unsigned char isSelected;
+    Widget wItem = motTreeFindNodeFromString(ih, &value[strlen("INVERT")]);
+    if (!wItem)  
+      return 0;
+
+    XtVaGetValues(wItem, XmNvisualEmphasis, &isSelected, NULL);
+    if (isSelected == XmSELECTED)
+      XtVaSetValues(wItem, XmNvisualEmphasis, XmNOT_SELECTED, NULL);
+    else
+      XtVaSetValues(wItem, XmNvisualEmphasis, XmSELECTED, NULL);
+  }
+  else if(iupStrEqualNoCase(value, "BLOCK"))
+  {
+    Widget wItem = (Widget)iupAttribGet(ih, "_IUPTREE_MARKSTART_NODE");
+    Widget wFocusItem = motTreeGetFocusNode(ih);
+    if(!wFocusItem || !wItem)
+      return 0;
+    motTreeSelectRange(ih, wFocusItem, wItem, 0);
+  }
+  else
+  {
+    Widget wItem1, wItem2;
+    char str1[50], str2[50];
+    if (iupStrToStrStr(value, str1, str2, '-')!=2)
+      return 0;
+
+    wItem1 = motTreeFindNodeFromString(ih, str1);
+    if (!wItem1)  
+      return 0;
+    wItem2 = motTreeFindNodeFromString(ih, str2);
+    if (!wItem2)  
+      return 0;
+
+    motTreeSelectRange(ih, wItem1, wItem2, 0);
+  }
+
+  return 1;
+} 
+
+static int motTreeSetValueAttrib(Ihandle* ih, const char* value)
+{
+  Widget wRoot, wItem;
+
+  if (motTreeSetMarkAttrib(ih, value))
+    return 0;
+
+  wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+
+  if (iupStrEqualNoCase(value, "ROOT"))
+    wItem = wRoot;
+  else if(iupStrEqualNoCase(value, "LAST"))
+    wItem = motTreeGetLastVisibleNode(ih, wRoot);
+  else if(iupStrEqualNoCase(value, "PGUP"))
+  {
+    Widget wItemFocus = motTreeGetFocusNode(ih);
+    if(!wItemFocus)
+      return 0;
+
+    ih->data->id_control = -1;
+    motTreeFindVisibleNodeId(ih, &wRoot, 1, wItemFocus);
+    ih->data->id_control -= 10;  /* less 10 visible nodes */
+
+    if(ih->data->id_control < 0)
+      ih->data->id_control = 0;  /* Begin of tree = Root id */
+
+    wItem = motTreeFindVisibleNodeFromId(ih, &wRoot, 1);
+  }
+  else if(iupStrEqualNoCase(value, "PGDN"))
+  {
+    Widget wNext, wItemFocus;
+
+    wItemFocus = motTreeGetFocusNode(ih);
+    if(!wItemFocus)
+      return 0;
+
+    ih->data->id_control = -1;
+    motTreeFindVisibleNodeId(ih, &wRoot, 1, wItemFocus);
+    ih->data->id_control += 10;  /* more 10 visible nodes */
+
+    wNext = motTreeFindVisibleNodeFromId(ih, &wRoot, 1);
+
+    if (ih->data->id_control >= 0)
+      wNext = motTreeGetLastVisibleNode(ih, wRoot);
+ 
+    wItem = wNext;
+  }
+  else if(iupStrEqualNoCase(value, "NEXT"))
+  {
+    Widget wItemFocus = motTreeGetFocusNode(ih);
+    if (!wItemFocus)
+      return 0;
+
+    wItem = motTreeGetNextVisibleNode(ih, wRoot, wItemFocus);
+  }
+  else if(iupStrEqualNoCase(value, "PREVIOUS"))
+  {
+    Widget wItemFocus = motTreeGetFocusNode(ih);
+    if(!wItemFocus)
+      return 0;
+
+    wItem = motTreeGetPreviousVisibleNode(ih, wRoot, wItemFocus);
+  }
+  else
+    wItem = motTreeFindNodeFromString(ih, value);
+
+  if (!wItem)  
+    return 0;
+
+  /* select */
+  if (ih->data->mark_mode==ITREE_MARK_SINGLE)
+  {
+    /* clear previous selection */
+    XtVaSetValues(ih->handle, XmNselectedObjects,  NULL, NULL);
+    XtVaSetValues(ih->handle, XmNselectedObjectCount, 0, NULL);
+
+    XtVaSetValues(wItem, XmNvisualEmphasis, XmSELECTED, NULL);
+  }
+
+  /* set focus (will scroll to visible) */
+  motTreeSetFocusNode(ih, wItem);
+
+  iupAttribSetInt(ih, "_IUPTREE_OLDVALUE", motTreeGetNodeId(ih, wItem));
+
+  return 0;
+} 
+
+static int motTreeSetMarkStartAttrib(Ihandle* ih, const char* name_id)
+{
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return 0;
+
+  iupAttribSetStr(ih, "_IUPTREE_MARKSTART_NODE", (char*)wItem);
+
+  return 1;
+}
+
+static char* motTreeGetMarkedAttrib(Ihandle* ih, const char* name_id)
+{
+  unsigned char isSelected;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return NULL;
+
+  XtVaGetValues(wItem, XmNvisualEmphasis, &isSelected, NULL);
+
+  if(isSelected == XmSELECTED)
+    return "YES";
+  else
+    return "NO";
+}
+
+static int motTreeSetMarkedAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return 0;
+
+  if (iupStrBoolean(value))
+    XtVaSetValues(wItem, XmNvisualEmphasis, XmSELECTED, NULL);
+  else
+    XtVaSetValues(wItem, XmNvisualEmphasis, XmNOT_SELECTED, NULL);
+
+  return 0;
+}
+
+static char* motTreeGetTitle(Widget wItem)
+{
+  char *title;
+  XmString itemTitle;
+  XtVaGetValues(wItem, XmNlabelString, &itemTitle, NULL);
+  title = iupmotConvertString(itemTitle);
+  XmStringFree(itemTitle);
+  return title;
+}
+
+static char* motTreeGetTitleAttrib(Ihandle* ih, const char* name_id)
+{
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return NULL;
+  return motTreeGetTitle(wItem);
+}
+
+static int motTreeSetTitleAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return 0;
+
+  iupmotSetString(wItem, XmNlabelString, value);
+
+  return 0;
+}
+
+static int motTreeSetTitleFontAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  XmFontList fontlist = NULL;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return 0;
+
+  if (value)
+  {
+    char attr[20];
+    sprintf(attr, "TITLEFOUNDRY%s", name_id);
+    fontlist = iupmotGetFontList(iupAttribGet(ih, attr), value);
+  }
+  XtVaSetValues(wItem, XmNrenderTable, fontlist, NULL);
+
+  return 0;
+}
+
+static char* motTreeGetTitleFontAttrib(Ihandle* ih, const char* name_id)
+{
+  XmFontList fontlist;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return NULL;
+
+  XtVaGetValues(wItem, XmNrenderTable, &fontlist, NULL);
+  return iupmotFindFontList(fontlist);
+}
+
+static char* motTreeGetFindUserDataAttrib(Ihandle* ih, const char* name_id)
+{
+  int id;
+  char* str = (char*)(name_id+1); /* skip ':' */
+  void* userdata = NULL;
+  if (sscanf(str, "%p", &userdata)!=1)
+    return NULL;
+  id = motTreeGetUserDataId(ih, userdata);
+  if (id == -1)
+    return NULL;
+  str = iupStrGetMemory(16);
+  sprintf(str, "%d", id);
+  return str;
+}
+
+static char* motTreeGetUserDataAttrib(Ihandle* ih, const char* name_id)
+{
+  motTreeItemData *itemData;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return NULL;
+
+  XtVaGetValues(wItem, XmNuserData, &itemData, NULL);
+
+  return itemData->userdata;
+}
+
+static int motTreeSetUserDataAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  motTreeItemData *itemData;
+  Widget wItem = motTreeFindNodeFromString(ih, name_id);
+  if (!wItem)  
+    return 0;
+
+  XtVaGetValues(wItem, XmNuserData, &itemData, NULL);
+  itemData->userdata = (void*)value;
+
+  return 0;
+}
+
+static int motTreeSetRenameAttrib(Ihandle* ih, const char* value)
+{  
+  if (ih->data->show_rename)
+  {
+    IFni cbShowRename = (IFni)IupGetCallback(ih, "SHOWRENAME_CB");
+    Widget wItemFocus = motTreeGetFocusNode(ih);
+    if (cbShowRename)
+      cbShowRename(ih, motTreeGetNodeId(ih, wItemFocus));
+    motTreeShowEditField(ih, wItemFocus);
+  }
+  else
+  {
+    IFnis cbRenameNode = (IFnis)IupGetCallback(ih, "RENAMENODE_CB");
+    if (cbRenameNode)
+    {
+      Widget wItemFocus = motTreeGetFocusNode(ih);
+      cbRenameNode(ih, motTreeGetNodeId(ih, wItemFocus), motTreeGetTitle(wItemFocus));  
+    }
+  }
+
+  (void)value;
+  return 0;
+}
+
+static int motTreeSetDelNodeAttrib(Ihandle* ih, const char* name_id, const char* value)
+{
+  if (!ih->handle)  /* do not store the action before map */
+    return 0;
+  if(iupStrEqualNoCase(value, "SELECTED"))  /* selected here means the specified one */
+  {
+    Widget wItem = motTreeFindNodeFromString(ih, name_id);
+    Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+
+    /* the root node can't be deleted */
+    if(!wItem || wItem == wRoot)  /* root is the unique child */
+      return 0;
+
+    /* deleting the specified node (and it's children) */
+    motTreeRemoveNode(ih, wItem, 1);
+  }
+  else if(iupStrEqualNoCase(value, "CHILDREN"))  /* children of the specified one */
+  {
+    Widget wItem = motTreeFindNodeFromString(ih, name_id);
+
+    if(!wItem)
+      return 0;
+
+    {
+      /* deleting the selected node's children only */
+      WidgetList wItemList = NULL;
+      int numChild = XmContainerGetItemChildren(ih->handle, wItem, &wItemList);
+      if(numChild)
+        motTreeRemoveChildren(ih, wItemList, numChild, 1);
+      if (wItemList) XtFree((char*)wItemList);
+    }
+  }
+  else if(iupStrEqualNoCase(value, "MARKED"))  /* Delete the array of marked nodes */
+  {
+    WidgetList wSelectedItemList = NULL;
+    Widget wRoot;
+    int countItems, i;
+
+    XtVaGetValues(ih->handle, XmNselectedObjects, &wSelectedItemList,
+                              XmNselectedObjectCount, &countItems, NULL);
+
+    wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+
+    for(i = 0; i < countItems; i++)
+    {
+      int ok = XmIsIconGadget(wSelectedItemList[i]);
+      if ((wSelectedItemList[i] != wRoot) && ok)  /* the root node can't be deleted */
+        motTreeRemoveNode(ih, wSelectedItemList[i], 1);
+    }
+  }
+
+  return 0;
+}
+
+static char* motTreeGetIndentationAttrib(Ihandle* ih)
+{
+  char* str = iupStrGetMemory(255);
+  Dimension indent;
+  XtVaGetValues(ih->handle, XmNoutlineIndentation, &indent, NULL);
+  sprintf(str, "%d", (int)indent);
+  return str;
+}
+
+static int motTreeSetIndentationAttrib(Ihandle* ih, const char* value)
+{
+  int indent;
+  if (iupStrToInt(value, &indent))
+    XtVaSetValues(ih->handle, XmNoutlineIndentation, (Dimension)indent, NULL);
+  return 0;
+}
+
+static int motTreeSetTopItemAttrib(Ihandle* ih, const char* value)
+{
+  Widget wItem = motTreeFindNodeFromString(ih, value);
+  Widget sb_win;
+  Widget wItemParent;
+
+  if (!wItem)
+    return 0;
+
+  /* expand all parents */
+  XtVaGetValues(wItem, XmNentryParent, &wItemParent, NULL);
+  while(wItemParent)
+  {
+    XtVaSetValues(wItemParent, XmNoutlineState, XmEXPANDED, NULL);
+    XtVaGetValues(wItemParent, XmNentryParent, &wItemParent, NULL);
+  }
+
+  sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  XmScrollVisible(sb_win, wItem, 0, 0);
+
+  return 0;
+}
+
+static int motTreeSpacingFunc(Ihandle* ih, Widget wItem, void *data)
+{
+  XtVaSetValues(wItem, XmNmarginHeight, ih->data->spacing, NULL);
+  (void)data;
+  return 1;
+}
+
+static int motTreeSetSpacingAttrib(Ihandle* ih, const char* value)
+{
+  if (!iupStrToInt(value, &ih->data->spacing))
+    ih->data->spacing = 1;
+
+  if (ih->data->spacing < 1)
+    ih->data->spacing = 1;
+
+  if (ih->handle)
+  {
+    motTreeForEach(ih, NULL, (motTreeNodeFunc)motTreeSpacingFunc, 0);
+    return 0;
+  }
+  else
+    return 1; /* store until not mapped, when mapped will be set again */
+}
+
+static int motTreeSetExpandAllAttrib(Ihandle* ih, const char* value)
+{
+  Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+
+  if (iupStrBoolean(value))
+    motTreeExpandCollapseAllNodes(ih, &wRoot, 1, XmEXPANDED);
+  else
+  {
+    motTreeExpandCollapseAllNodes(ih, &wRoot, 1, XmCOLLAPSED);
+
+    /* The root node is always expanded */
+    XtVaSetValues((Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM"), XmNoutlineState, XmEXPANDED, NULL);
+  }
+
+  return 0;
+}
+
+static int motTreeSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  Widget sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  Pixel color;
+
+  /* ignore given value for the scrollbars, must use only from parent */
+  char* parent_value = iupBaseNativeParentGetBgColor(ih);
+
+  color = iupmotColorGetPixelStr(parent_value);
+  if (color != (Pixel)-1)
+  {
+    Widget sb = NULL;
+
+    iupmotSetBgColor(sb_win, color);
+
+    XtVaGetValues(sb_win, XmNverticalScrollBar, &sb, NULL);
+    if (sb) iupmotSetBgColor(sb, color);
+
+    XtVaGetValues(sb_win, XmNhorizontalScrollBar, &sb, NULL);
+    if (sb) iupmotSetBgColor(sb, color);
+  }
+
+  color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    Widget wRoot;
+    Widget clipwin = NULL;
+
+    XtVaGetValues(sb_win, XmNclipWindow, &clipwin, NULL);
+    if (clipwin) iupmotSetBgColor(clipwin, color);
+
+    wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+    
+    /* Update all children, starting at root node */
+    motTreeUpdateBgColor(ih, &wRoot, 1, color);
+  }
+
+  iupdrvBaseSetBgColorAttrib(ih, value);   /* use given value for contents */
+
+  /* update internal image cache */
+  iupTreeUpdateImages(ih);
+
+  return 1;
+}
+
+static int motTreeSetFgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+    XtVaSetValues(ih->handle, XmNforeground, color, NULL);
+
+  return 1;
+}
+
+void iupdrvTreeUpdateMarkMode(Ihandle *ih)
+{
+  XtVaSetValues(ih->handle, XmNselectionPolicy, (ih->data->mark_mode==ITREE_MARK_SINGLE)? XmSINGLE_SELECT: XmEXTENDED_SELECT, NULL);
+}
+
+/************************************************************************************************/
+
+
+static void motTreeSetRenameCaretPos(Widget cbEdit, const char* value)
+{
+  int pos = 1;
+
+  if (iupStrToInt(value, &pos))
+  {
+    if (pos < 1) pos = 1;
+    pos--; /* IUP starts at 1 */
+
+    XtVaSetValues(cbEdit, XmNcursorPosition, pos, NULL);
+  }
+}
+
+static void motTreeSetRenameSelectionPos(Widget cbEdit, const char* value)
+{
+  int start = 1, end = 1;
+
+  if (iupStrToIntInt(value, &start, &end, ':') != 2) 
+    return;
+
+  if(start < 1 || end < 1) 
+    return;
+
+  start--; /* IUP starts at 1 */
+  end--;
+
+  XmTextSetSelection(cbEdit, start, end, CurrentTime);
+}
+
+/*****************************************************************************/
+
+static int motTreeCallBranchCloseCb(Ihandle* ih, Widget wItem)
+{
+  IFni cbBranchClose = (IFni)IupGetCallback(ih, "BRANCHCLOSE_CB");
+
+  if(cbBranchClose)
+    return cbBranchClose(ih, motTreeGetNodeId(ih, wItem));
+
+  return IUP_DEFAULT;
+}
+
+static int motTreeCallBranchOpenCb(Ihandle* ih, Widget wItem)
+{
+  IFni cbBranchOpen;
+  
+  if (iupAttribGet(ih, "_IUP_IGNORE_BRANCHOPEN"))
+  {
+    iupAttribSetStr(ih, "_IUP_IGNORE_BRANCHOPEN", NULL);
+    return IUP_DEFAULT;
+  }
+
+  cbBranchOpen = (IFni)IupGetCallback(ih, "BRANCHOPEN_CB");
+  if (cbBranchOpen)
+    return cbBranchOpen(ih, motTreeGetNodeId(ih, wItem));
+
+  return IUP_DEFAULT;
+}
+
+static void motTreeCallMultiSelectionCb(Ihandle* ih)
+{
+  IFnIi cbMulti = (IFnIi)IupGetCallback(ih, "MULTISELECTION_CB");
+  IFnii cbSelec = (IFnii)IupGetCallback(ih, "SELECTION_CB");
+  WidgetList wSelectedItemList = NULL;
+  Widget wRoot;
+  int countItems;
+
+  wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+
+  XtVaGetValues(ih->handle, XmNselectedObjects, &wSelectedItemList,
+                        XmNselectedObjectCount, &countItems, NULL);
+  if (countItems == 0)
+    return;
+
+  if (cbMulti || cbSelec)
+  {
+    int* id_rowItem = malloc(sizeof(int) * countItems);
+    int i = 0;
+
+    for(i = 0; i < countItems; i++)
+      id_rowItem[i] = motTreeGetNodeId(ih, wSelectedItemList[i]);
+
+    if (cbMulti)
+      cbMulti(ih, id_rowItem, countItems);
+    else
+    {
+      for (i=0; i<countItems; i++)
+        cbSelec(ih, id_rowItem[i], 1);
+    }
+
+    free(id_rowItem);
+  }
+}
+
+static int motTreeConvertXYToPos(Ihandle* ih, int x, int y)
+{
+  Widget wItem = XmObjectAtPoint(ih->handle, (Position)x, (Position)y);
+  if (wItem)
+    return motTreeGetNodeId(ih, wItem);
+  return -1;
+}
+
+static void motTreeCallRightClickCb(Ihandle* ih, int x, int y)
+{
+  IFni cbRightClick  = (IFni)IupGetCallback(ih, "RIGHTCLICK_CB");
+  if (cbRightClick)
+  {
+    int id = motTreeConvertXYToPos(ih, x, y);
+    if (id != -1)
+      cbRightClick(ih, id);
+  }    
+}
+
+static void motTreeCallRenameCb(Ihandle* ih)
+{
+  IFnis cbRename;
+  Widget wItem, wEdit;
+  int ignore = 0;
+  String title = NULL;
+
+  wItem = (Widget)iupAttribGet(ih, "_IUPTREE_SELECTED");
+  wEdit = (Widget)iupAttribGet(ih, "_IUPTREE_EDITFIELD");
+
+  XtVaGetValues((Widget)iupAttribGet(ih, "_IUPTREE_EDITFIELD"), XmNvalue, &title, NULL);
+
+  cbRename = (IFnis)IupGetCallback(ih, "RENAME_CB");
+  if (cbRename)
+  {
+    if (cbRename(ih, motTreeGetNodeId(ih, wItem), title) == IUP_IGNORE)
+      ignore = 1;
+  }
+
+  if (!ignore)
+    iupmotSetString(wItem, XmNlabelString, title);
+
+  XtDestroyWidget(wEdit);
+
+  iupAttribSetStr(ih, "_IUPTREE_EDITFIELD", NULL);
+  iupAttribSetStr(ih, "_IUPTREE_SELECTED",  NULL);
+}
+
+static int motTreeCallDragDropCb(Ihandle* ih, Widget wItemDrag, Widget wItemDrop, int *is_ctrl)
+{
+  IFniiii cbDragDrop = (IFniiii)IupGetCallback(ih, "DRAGDROP_CB");
+  int is_shift = 0;
+  char key[5];
+  iupdrvGetKeyState(key);
+  if (key[0] == 'S')
+    is_shift = 1;
+  if (key[1] == 'C')
+    *is_ctrl = 1;
+  else
+    *is_ctrl = 0;
+
+  if (cbDragDrop)
+  {
+    int drag_id = motTreeGetNodeId(ih, wItemDrag);
+    int drop_id = motTreeGetNodeId(ih, wItemDrop);
+    return cbDragDrop(ih, drag_id, drop_id, is_shift, *is_ctrl);
+  }
+
+  return IUP_CONTINUE; /* allow to move by default if callback not defined */
+}
+
+static void motTreeEditFocusChangeEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont)
+{
+  if (evt->type == FocusOut)
+    motTreeCallRenameCb(ih);
+
+  (void)cont;
+  (void)w;
+}
+
+static void motTreeEditKeyPressEvent(Widget w, Ihandle *ih, XKeyEvent *evt, Boolean *cont)
+{
+  KeySym motcode = XKeycodeToKeysym(iupmot_display, evt->keycode, 0);
+  if (motcode == XK_Return)
+  {
+    Widget wItem = (Widget)iupAttribGet(ih, "_IUPTREE_SELECTED");
+    motTreeCallRenameCb(ih);
+    motTreeSetFocusNode(ih, wItem);
+  }
+  else if (motcode == XK_Escape)
+  {
+    Widget wEdit = (Widget)iupAttribGet(ih, "_IUPTREE_EDITFIELD");
+    Widget wItem = (Widget)iupAttribGet(ih, "_IUPTREE_SELECTED");
+
+    XtDestroyWidget(wEdit);
+    motTreeSetFocusNode(ih, wItem);
+
+    iupAttribSetStr(ih, "_IUPTREE_EDITFIELD", NULL);
+    iupAttribSetStr(ih, "_IUPTREE_SELECTED",  NULL);
+  }
+
+  (void)cont;
+  (void)w;
+}
+
+static void motTreeScrollbarOffset(Widget sb_win, Position *x, Position *y)
+{
+  Widget sb_horiz, sb_vert;
+  XtVaGetValues(sb_win, XmNhorizontalScrollBar, &sb_horiz, NULL);
+  if (sb_horiz) 
+  {
+    int pos;
+    XtVaGetValues(sb_horiz, XmNvalue, &pos, NULL);
+    *x = *x - (Position)pos;
+  }
+  XtVaGetValues(sb_win, XmNverticalScrollBar, &sb_vert, NULL);
+  if (sb_vert) 
+  {
+    int pos;
+    XtVaGetValues(sb_vert, XmNvalue, &pos, NULL);
+    *y = *y - (Position)pos;
+  }
+}
+
+static void motTreeShowEditField(Ihandle* ih, Widget wItem)
+{
+  int num_args = 0, w_img = 0;
+  Arg args[30];
+  Position x, y;
+  Dimension w, h;
+  char* child_id = iupDialogGetChildIdStr(ih);
+  Widget cbEdit;
+  XmString title;
+  char* value;
+  Pixel color;
+  Pixmap image = XmUNSPECIFIED_PIXMAP;
+  XmFontList fontlist;
+  Widget sb_win = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+
+  XtVaGetValues(wItem, XmNx, &x, 
+                       XmNy, &y,
+                       XmNwidth, &w, 
+                       XmNheight, &h, 
+                       XmNlabelString, &title,
+                       XmNsmallIconPixmap, &image, 
+                       XmNforeground, &color,
+                       XmNrenderTable, &fontlist,
+                       NULL);
+
+  motTreeScrollbarOffset(sb_win, &x, &y);
+  iupdrvImageGetInfo((void*)image, &w_img, NULL, NULL);
+  w_img += 3; /* add some room for borders */
+
+  iupmotSetArg(args, num_args, XmNx, x+w_img);      /* x-position */
+  iupmotSetArg(args, num_args, XmNy, y);         /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, w-w_img);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, h);    /* default height to avoid 0 */
+  iupmotSetArg(args, num_args, XmNmarginHeight, ih->data->spacing);  /* default padding */
+  iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+  iupmotSetArg(args, num_args, XmNforeground, color);
+  iupmotSetArg(args, num_args, XmNrenderTable, fontlist);
+  iupmotSetArg(args, num_args, XmNvalue, iupmotConvertString(title));
+  iupmotSetArg(args, num_args, XmNtraversalOn, True);
+
+  cbEdit = XtCreateManagedWidget(
+    child_id,       /* child identifier */
+    xmTextWidgetClass,   /* widget class */
+    sb_win,
+    args, num_args);
+
+  /* Disable Drag Source */
+  iupmotDisableDragSource(cbEdit);
+
+  XtAddEventHandler(cbEdit, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(cbEdit, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(cbEdit, FocusChangeMask, False, (XtEventHandler)motTreeEditFocusChangeEvent, (XtPointer)ih);
+  XtAddEventHandler(cbEdit, KeyPressMask,    False, (XtEventHandler)motTreeEditKeyPressEvent, (XtPointer)ih);
+
+  iupAttribSetStr(ih, "_IUPTREE_SELECTED",  (char*)wItem);
+  iupAttribSetStr(ih, "_IUPTREE_EDITFIELD", (char*)cbEdit);
+
+  XmProcessTraversal(cbEdit, XmTRAVERSE_CURRENT);
+
+  XmTextSetSelection(cbEdit, (XmTextPosition)0, (XmTextPosition)XmTextGetLastPosition(cbEdit), CurrentTime);
+
+  value = iupAttribGetStr(ih, "RENAMECARET");
+  if (value)
+    motTreeSetRenameCaretPos(cbEdit, value);
+
+  value = iupAttribGetStr(ih, "RENAMESELECTION");
+  if (value)
+    motTreeSetRenameSelectionPos(cbEdit, value);
+
+  /* the parents callbacks can be called while editing 
+     so we must avoid their processing if _IUPTREE_EDITFIELD is defined. */
+}
+
+static void motTreeSelectionCallback(Widget w, Ihandle* ih, XmContainerSelectCallbackStruct *nptr)
+{
+  IFnii cbSelec;
+  int is_ctrl = 0;
+  (void)w;
+  (void)nptr;
+
+printf("SelectionCallback(%d)\n", nptr->selected_item_count);
+
+  if (ih->data->mark_mode == ITREE_MARK_MULTIPLE)
+  {
+    char key[5];
+    iupdrvGetKeyState(key);
+    if (key[0] == 'S')
+      return;
+    else if (key[1] == 'C')
+      is_ctrl = 1;
+
+    if (nptr->selected_item_count>1 && !is_ctrl)
+    {
+      if (IupGetCallback(ih, "MULTISELECTION_CB"))
+      {
+        if (nptr->auto_selection_type==XmAUTO_NO_CHANGE)
+          motTreeCallMultiSelectionCb(ih);
+      }
+      else
+      {
+        if (nptr->auto_selection_type==XmAUTO_MOTION)
+          motTreeCallMultiSelectionCb(ih);
+      }
+      return;
+    }
+  }
+
+  cbSelec = (IFnii)IupGetCallback(ih, "SELECTION_CB");
+  if (cbSelec)
+  {
+    Widget wItemFocus = motTreeGetFocusNode(ih);
+    int curpos = motTreeGetNodeId(ih, wItemFocus);
+    if (is_ctrl) 
+    {
+      unsigned char isSelected;
+      XtVaGetValues(wItemFocus, XmNvisualEmphasis, &isSelected, NULL);
+      cbSelec(ih, curpos, isSelected == XmSELECTED? 1: 0);
+    }
+    else
+    {
+      int oldpos = iupAttribGetInt(ih, "_IUPTREE_OLDVALUE");
+      if (oldpos != curpos)
+      {
+        cbSelec(ih, oldpos, 0);  /* unselected */
+        cbSelec(ih, curpos, 1);  /*   selected */
+
+        iupAttribSetInt(ih, "_IUPTREE_OLDVALUE", curpos);
+      }
+    }
+  }
+}
+
+static void motTreeDefaultActionCallback(Widget w, Ihandle* ih, XmContainerSelectCallbackStruct *nptr)
+{
+  unsigned char itemState;
+  WidgetList wSelectedItemList = NULL;
+  int countItems;
+  motTreeItemData *itemData;
+  Widget wItem;
+  (void)w;
+
+  wSelectedItemList = nptr->selected_items;
+  countItems = nptr->selected_item_count;
+
+  if (!countItems || (Widget)iupAttribGet(ih, "_IUPTREE_EDITFIELD"))
+    return;
+
+  /* this works also when using multiple selection */
+  wItem = wSelectedItemList[0];
+
+  XtVaGetValues(wItem, XmNoutlineState, &itemState,
+                       XmNuserData, &itemData, NULL);
+
+  if (itemData->kind == ITREE_BRANCH)
+  {
+    if (itemState == XmEXPANDED)
+      XtVaSetValues(wItem, XmNoutlineState,  XmCOLLAPSED, NULL);
+    else
+      XtVaSetValues(wItem, XmNoutlineState,  XmEXPANDED, NULL);
+  }
+  else
+  {
+    IFni cbExecuteLeaf = (IFni)IupGetCallback(ih, "EXECUTELEAF_CB");
+    if (cbExecuteLeaf)
+      cbExecuteLeaf(ih, motTreeGetNodeId(ih, wItem));
+  }
+}
+
+static void motTreeOutlineChangedCallback(Widget w, Ihandle* ih, XmContainerOutlineCallbackStruct *nptr)
+{
+  motTreeItemData *itemData;
+  XtVaGetValues(nptr->item, XmNuserData, &itemData, NULL);
+
+  if (nptr->reason == XmCR_EXPANDED)
+  {
+    if (motTreeCallBranchOpenCb(ih, nptr->item) == IUP_IGNORE)
+      nptr->new_outline_state = XmCOLLAPSED; /* prevent the change */
+    else
+    {
+      XtVaSetValues(nptr->item, XmNsmallIconPixmap, (itemData->image_expanded!=XmUNSPECIFIED_PIXMAP)? itemData->image_expanded: (Pixmap)ih->data->def_image_expanded, NULL);
+      XtVaSetValues(nptr->item, XmNsmallIconMask, (itemData->image_expanded_mask!=XmUNSPECIFIED_PIXMAP)? itemData->image_expanded_mask: (Pixmap)ih->data->def_image_expanded_mask, NULL);
+    }
+  }
+  else if (nptr->reason == XmCR_COLLAPSED)
+  {
+    if (motTreeCallBranchCloseCb(ih, nptr->item) == IUP_IGNORE)
+      nptr->new_outline_state = XmEXPANDED;  /* prevent the change */
+    else
+    {
+      XtVaSetValues(nptr->item, XmNsmallIconPixmap, (itemData->image!=XmUNSPECIFIED_PIXMAP)? itemData->image: (Pixmap)ih->data->def_image_collapsed, NULL);
+      XtVaSetValues(nptr->item, XmNsmallIconMask, (itemData->image_mask!=XmUNSPECIFIED_PIXMAP)? itemData->image_mask: (Pixmap)ih->data->def_image_collapsed_mask, NULL);
+    }
+  }
+
+  (void)w;
+}
+
+static void motTreeTraverseObscuredCallback(Widget widget, Ihandle* ih, XmTraverseObscuredCallbackStruct *cbs)
+{
+  (void)ih;
+  /* allow to do automatic scroll when navigating in the tree */
+  XmScrollVisible(widget, cbs->traversal_destination, 10, 10);
+}
+
+static void motTreeKeyReleaseEvent(Widget w, Ihandle *ih, XKeyEvent *evt, Boolean *cont)
+{
+  KeySym motcode;
+
+  if (iupAttribGet(ih, "_IUPTREE_EDITFIELD"))
+    return;
+
+  motcode = XKeycodeToKeysym(iupmot_display, evt->keycode, 0);
+  if (motcode == XK_Down || motcode == XK_U || motcode == XK_Home || motcode == XK_End)
+  {
+    if (ih->data->mark_mode==ITREE_MARK_MULTIPLE && (evt->state & ShiftMask))
+      motTreeCallMultiSelectionCb(ih);
+  }
+
+  (void)w;
+  (void)cont;
+}
+
+static void motTreeKeyPressEvent(Widget w, Ihandle *ih, XKeyEvent *evt, Boolean *cont)
+{
+  KeySym motcode;
+
+  if (iupAttribGet(ih, "_IUPTREE_EDITFIELD"))
+    return;
+
+  *cont = True;
+  iupmotKeyPressEvent(w, ih, (XEvent*)evt, cont);
+  if (*cont == False)
+    return;
+
+  motcode = XKeycodeToKeysym(iupmot_display, evt->keycode, 0);
+  if (motcode == XK_F2)
+    motTreeSetRenameAttrib(ih, NULL);
+  else if (motcode == XK_F1)
+    iupmotHelpCallback(w, ih, NULL);
+  else if ((motcode == XK_Down || motcode == XK_Up) && (evt->state & ControlMask))
+  {
+    Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+    Widget wItem;
+    Widget wItemFocus = motTreeGetFocusNode(ih);
+
+    /* Ctrl+Arrows move only focus */
+    if (motcode == XK_Down)
+      wItem = motTreeGetNextVisibleNode(ih, wRoot, wItemFocus);
+    else
+      wItem = motTreeGetPreviousVisibleNode(ih, wRoot, wItemFocus);
+
+    motTreeSetFocusNode(ih, wItem);
+    *cont = False;
+  }
+  else if(motcode == XK_Home || motcode == XK_End)
+  {
+    Widget wRoot = (Widget)iupAttribGet(ih, "_IUPTREE_ROOTITEM");
+    Widget wItem;
+
+    /* Not processed by Motif */
+
+    if (motcode == XK_Home)
+      wItem = wRoot;
+    else
+      wItem = motTreeGetLastVisibleNode(ih, wRoot);
+
+    /* Ctrl+Arrows move only focus */
+    if (!(evt->state & ControlMask))
+    {
+      /* Shift+Arrows select block */
+      if (evt->state & ShiftMask)
+      {
+        Widget wItemFocus = motTreeGetFocusNode(ih);
+        if (!wItemFocus)
+          return;
+        motTreeSelectRange(ih, wItemFocus, wItem, 1);
+      }
+      else
+      {
+        /* clear previous selection */
+        XtVaSetValues(ih->handle, XmNselectedObjects,  NULL, NULL);
+        XtVaSetValues(ih->handle, XmNselectedObjectCount, 0, NULL);
+
+        XtVaSetValues(wItem, XmNvisualEmphasis, XmSELECTED, NULL);
+      }
+    }
+
+    motTreeSetFocusNode(ih, wItem);
+    *cont = False;
+  }
+  else if(motcode == XK_space && (evt->state & ControlMask))
+  {
+    Widget wItemFocus = motTreeGetFocusNode(ih);
+    if (wItemFocus)
+    {
+      unsigned char isSelected;
+      XtVaGetValues(wItemFocus, XmNvisualEmphasis, &isSelected, NULL);
+      if (isSelected == XmSELECTED)
+        XtVaSetValues(wItemFocus, XmNvisualEmphasis, XmNOT_SELECTED, NULL);
+      else
+        XtVaSetValues(wItemFocus, XmNvisualEmphasis, XmSELECTED, NULL);
+    }
+  }
+}
+
+static void motTreeButtonEvent(Widget w, Ihandle* ih, XButtonEvent* evt, Boolean* cont)
+{
+  (void)w;
+  (void)cont;
+
+  if (iupAttribGet(ih, "_IUPTREE_EDITFIELD"))
+    return;
+
+  *cont = True;
+  iupmotButtonPressReleaseEvent(w, ih, (XEvent*)evt, cont);
+  if (*cont == False)
+    return;
+
+  if (evt->type==ButtonPress)
+  {   
+    iupAttribSetStr(ih, "_IUPTREE_IGNORE_ENTERLEAVE", "1");
+
+    if (evt->button==Button1)
+    {
+      Widget wItemFocus = motTreeGetFocusNode(ih);
+      static Widget wLastItem = NULL;
+      static Time last = 0;
+      int clicktwice = 0, doubleclicktime = XtGetMultiClickTime(iupmot_display);
+      int elapsed = (int)(evt->time - last);
+      last = evt->time;
+
+      /* stay away from double click and leave some room for clicks */
+      if (elapsed > (3*doubleclicktime)/2 && elapsed <= 3*doubleclicktime)
+        clicktwice = 1;
+    
+      if (clicktwice && wLastItem && wLastItem==wItemFocus)
+      {
+        motTreeSetRenameAttrib(ih, NULL);
+        *cont = False;
+      }
+      wLastItem = wItemFocus;
+    }
+    else if (evt->button==Button3)
+      motTreeCallRightClickCb(ih, evt->x, evt->y);
+  }
+  else if (evt->type==ButtonRelease)
+  {   
+    if (evt->button==Button1)
+    {
+      if (ih->data->mark_mode==ITREE_MARK_MULTIPLE && (evt->state & ShiftMask))
+        motTreeCallMultiSelectionCb(ih);
+    }
+  }
+}
+
+static void motTreeTransferProc(Widget drop_context, XtPointer client_data, Atom *seltype, Atom *type, XtPointer value, unsigned long *length, int format)
+{
+  Atom atomTreeItem = XInternAtom(iupmot_display, "TREE_ITEM", False);
+  Widget wItemDrop = (Widget)client_data;
+  Widget wItemDrag = (Widget)value;
+
+  if (*type == atomTreeItem)
+  {
+    Widget wParent;
+    Ihandle* ih = NULL;
+    int is_ctrl;
+
+    if (!wItemDrop || wItemDrag == wItemDrop)
+      return;
+
+    wParent = wItemDrop;
+    while(wParent)
+    {
+      XtVaGetValues(wParent, XmNentryParent, &wParent, NULL);
+      if (wParent == wItemDrag)
+        return;
+    }
+
+    XtVaGetValues(XtParent(wItemDrag), XmNuserData, &ih, NULL);
+
+    if (motTreeCallDragDropCb(ih, wItemDrag, wItemDrop, &is_ctrl) == IUP_CONTINUE)
+    {
+      /* Copy the dragged item to the new position. */
+      Widget wNewItem = motTreeCopyNode(ih, wItemDrag, wItemDrop, is_ctrl);
+
+      if (!is_ctrl)
+      {
+        /* do not delete the user data, we copy the references in CopyNode */
+        motTreeRemoveNode(ih, wItemDrag, 0);
+      }
+
+      /* Select the dragged item */
+      XtVaSetValues(ih->handle, XmNselectedObjects,  NULL, NULL);
+      XtVaSetValues(ih->handle, XmNselectedObjectCount, 0, NULL);
+      XtVaSetValues(wNewItem, XmNvisualEmphasis, XmSELECTED, NULL);
+
+      motTreeSetFocusNode(ih, wNewItem);
+    }
+  }
+
+  (void)drop_context;
+  (void)seltype;
+  (void)format;
+  (void)length;
+}
+
+static void motTreeDropProc(Widget w, XtPointer client_data, XmDropProcCallbackStruct* drop_data)
+{
+  Atom atomTreeItem = XInternAtom(iupmot_display, "TREE_ITEM", False);
+  XmDropTransferEntryRec transferList[2];
+  Arg args[10];
+  int i, num_args = 0;
+  Widget wItemDrop, drop_context;
+  Cardinal numExportTargets;
+  Atom *exportTargets;
+  Boolean found = False;
+  (void)client_data;
+
+  drop_context = drop_data->dragContext;
+
+  /* retrieve the data targets */
+  iupmotSetArg(args, num_args, XmNexportTargets, &exportTargets);
+  iupmotSetArg(args, num_args, XmNnumExportTargets, &numExportTargets);
+  XtGetValues(drop_context, args, num_args);
+
+  for (i = 0; i < (int)numExportTargets; i++) 
+  {
+    if (exportTargets[i] == atomTreeItem) 
+    {
+      found = True;
+      break;
+    }
+  }
+
+  wItemDrop = XmObjectAtPoint(w, drop_data->x, drop_data->y);
+  if (!wItemDrop)
+    found = False;
+
+  num_args = 0;
+  if ((!found) || (drop_data->dropAction != XmDROP) ||  (drop_data->operation != XmDROP_COPY && drop_data->operation != XmDROP_MOVE)) 
+  {
+    iupmotSetArg(args, num_args, XmNtransferStatus, XmTRANSFER_FAILURE);
+    iupmotSetArg(args, num_args, XmNnumDropTransfers, 0);
+  }
+  else 
+  {
+    /* set up transfer requests for drop site */
+    transferList[0].target = atomTreeItem;
+    transferList[0].client_data = (XtPointer)wItemDrop;
+    iupmotSetArg(args, num_args, XmNdropTransfers, transferList);
+    iupmotSetArg(args, num_args, XmNnumDropTransfers, 1);
+    iupmotSetArg(args, num_args, XmNtransferProc, motTreeTransferProc);
+  }
+
+  XmDropTransferStart(drop_context, args, num_args);
+}
+
+static void motTreeDragDropFinishCallback(Widget drop_context, XtPointer client_data, XtPointer call_data)
+{
+  Widget source_icon = NULL;
+  XtVaGetValues(drop_context, XmNsourceCursorIcon, &source_icon, NULL);
+  if (source_icon)
+    XtDestroyWidget(source_icon);
+  (void)call_data;
+  (void)client_data;
+}
+
+static void motTreeDragMotionCallback(Widget drop_context, Widget wItemDrag, XmDragMotionCallbackStruct* drag_motion)
+{
+  Ihandle* ih = NULL;
+  XtVaGetValues(XtParent(wItemDrag), XmNuserData, &ih, NULL);
+  if (!iupAttribGet(ih, "NODRAGFEEDBACK"))
+  {
+    Widget wItem;
+    int x = drag_motion->x;
+    int y = drag_motion->y;
+    iupdrvScreenToClient(ih, &x, &y);
+    wItem = XmObjectAtPoint(ih->handle, (Position)x, (Position)y);
+    if (wItem)
+    {
+      XtVaSetValues(ih->handle, XmNselectedObjects,  NULL, NULL);
+      XtVaSetValues(ih->handle, XmNselectedObjectCount, 0, NULL);
+      XtVaSetValues(wItem, XmNvisualEmphasis, XmSELECTED, NULL);
+    }
+  }
+  (void)drop_context;
+}
+
+static Boolean motTreeConvertProc(Widget drop_context, Atom *selection, Atom *target, Atom *type_return,
+                                  XtPointer *value_return, unsigned long *length_return, int *format_return)
+{
+  Atom atomMotifDrop = XInternAtom(iupmot_display, "_MOTIF_DROP", False);
+  Atom atomTreeItem = XInternAtom(iupmot_display, "TREE_ITEM", False);
+  Widget wItemDrag = NULL;
+
+  /* check if we are dealing with a drop */
+  if (*selection != atomMotifDrop || *target != atomTreeItem)
+    return False;
+
+  XtVaGetValues(drop_context, XmNclientData, &wItemDrag, NULL);
+  if (!wItemDrag)
+    return False;
+
+  /* format the value for transfer */
+  *type_return = atomTreeItem;
+  *value_return = (XtPointer)wItemDrag;
+  *length_return = 1;
+  *format_return = 32;
+  return True;
+}
+
+static void motTreeStartDrag(Widget w, XButtonEvent* evt, String* params, Cardinal* num_params)
+{
+  Atom atomTreeItem = XInternAtom(iupmot_display, "TREE_ITEM", False);
+  Atom exportList[1];
+  Widget drag_icon, drop_context;
+  Pixmap pixmap = 0, mask = 0;
+  int num_args = 0;
+  Arg args[40];
+  Pixel fg, bg;
+  Widget wItemDrag = XmObjectAtPoint(w, (Position)evt->x, (Position)evt->y);
+  if (!wItemDrag)
+    return;
+
+  XtVaGetValues(wItemDrag, XmNsmallIconPixmap, &pixmap, 
+                           XmNsmallIconMask, &mask, 
+                           XmNbackground, &bg,
+                           XmNforeground, &fg,
+                           NULL);
+
+  iupmotSetArg(args, num_args, XmNpixmap, pixmap);
+  iupmotSetArg(args, num_args, XmNmask, mask);
+  drag_icon = XmCreateDragIcon(w, "drag_icon", args, num_args);
+
+  exportList[0] = atomTreeItem;
+
+  /* specify resources for DragContext for the transfer */
+  num_args = 0;
+  iupmotSetArg(args, num_args, XmNcursorBackground, bg);
+  iupmotSetArg(args, num_args, XmNcursorForeground, fg);
+  /* iupmotSetArg(args, num_args, XmNsourcePixmapIcon, drag_icon);  works, but only outside the dialog, inside disapears */
+  iupmotSetArg(args, num_args, XmNsourceCursorIcon, drag_icon);  /* does not work, shows the default cursor */
+  iupmotSetArg(args, num_args, XmNexportTargets, exportList);
+  iupmotSetArg(args, num_args, XmNnumExportTargets, 1);
+  iupmotSetArg(args, num_args, XmNdragOperations, XmDROP_MOVE|XmDROP_COPY);
+  iupmotSetArg(args, num_args, XmNconvertProc, motTreeConvertProc);
+  iupmotSetArg(args, num_args, XmNclientData, wItemDrag);
+
+  /* start the drag and register a callback to clean up when done */
+  drop_context = XmDragStart(w, (XEvent*)evt, args, num_args);
+  XtAddCallback(drop_context, XmNdragDropFinishCallback, (XtCallbackProc)motTreeDragDropFinishCallback, NULL);
+  XtAddCallback(drop_context, XmNdragMotionCallback, (XtCallbackProc)motTreeDragMotionCallback, (XtPointer)wItemDrag);
+
+  (void)params;
+  (void)num_params;
+}
+
+static void motTreeEnableDragDrop(Widget w)
+{
+  Atom atomTreeItem = XInternAtom(iupmot_display, "TREE_ITEM", False);
+  Atom importList[1];
+  Arg args[40];
+  int num_args = 0;
+  char dragTranslations[] = "#override <Btn2Down>: StartDrag()";
+  static int do_rec = 0;
+  if (!do_rec)
+  {
+    XtActionsRec rec = {"StartDrag", (XtActionProc)motTreeStartDrag};
+    XtAppAddActions(iupmot_appcontext, &rec, 1);
+    do_rec = 1;
+  }
+  XtOverrideTranslations(w, XtParseTranslationTable(dragTranslations));
+
+  importList[0] = atomTreeItem;
+  iupmotSetArg(args, num_args, XmNimportTargets, importList);
+  iupmotSetArg(args, num_args, XmNnumImportTargets, 1);
+  iupmotSetArg(args, num_args, XmNdropSiteOperations, XmDROP_MOVE|XmDROP_COPY);
+  iupmotSetArg(args, num_args, XmNdropProc, motTreeDropProc);
+  XmDropSiteUpdate(w, args, num_args);
+
+  XtVaSetValues(XmGetXmDisplay(iupmot_display), XmNenableDragIcon, True, NULL);
+}
+
+static int motTreeMapMethod(Ihandle* ih)
+{
+  int num_args = 0;
+  Arg args[40];
+  Widget parent = iupChildTreeGetNativeParentHandle(ih);
+  char* child_id = iupDialogGetChildIdStr(ih);
+  Widget sb_win;
+
+  /******************************/
+  /* Create the scrolled window */
+  /******************************/
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+  iupmotSetArg(args, num_args, XmNscrollingPolicy, XmAUTOMATIC);
+  iupmotSetArg(args, num_args, XmNvisualPolicy, XmVARIABLE); 
+  iupmotSetArg(args, num_args, XmNscrollBarDisplayPolicy, XmAS_NEEDED);
+  iupmotSetArg(args, num_args, XmNspacing, 0); /* no space between scrollbars and text */
+  iupmotSetArg(args, num_args, XmNborderWidth, 0);
+  iupmotSetArg(args, num_args, XmNshadowThickness, 2);
+
+  sb_win = XtCreateManagedWidget(
+    child_id,  /* child identifier */
+    xmScrolledWindowWidgetClass, /* widget class */
+    parent,                      /* widget parent */
+    args, num_args);
+
+  if (!sb_win)
+     return IUP_ERROR;
+
+  XtAddCallback (sb_win, XmNtraverseObscuredCallback, (XtCallbackProc)motTreeTraverseObscuredCallback, (XtPointer)ih);
+
+  parent = sb_win;
+  child_id = "container";
+
+  num_args = 0;
+ 
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+
+  iupmotSetArg(args, num_args, XmNmarginHeight, 0);  /* default padding */
+  iupmotSetArg(args, num_args, XmNmarginWidth, 0);
+
+  if (iupAttribGetBoolean(ih, "CANFOCUS"))
+    iupmotSetArg(args, num_args, XmNtraversalOn, True);
+  else
+    iupmotSetArg(args, num_args, XmNtraversalOn, False);
+
+  iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+  iupmotSetArg(args, num_args, XmNhighlightThickness, 2);
+  iupmotSetArg(args, num_args, XmNshadowThickness, 0);
+
+  iupmotSetArg(args, num_args, XmNlayoutType, XmOUTLINE);
+  iupmotSetArg(args, num_args, XmNentryViewType, XmSMALL_ICON);
+  iupmotSetArg(args, num_args, XmNselectionPolicy, XmSINGLE_SELECT);
+  iupmotSetArg(args, num_args, XmNoutlineIndentation, 20);
+
+  if (iupAttribGetBoolean(ih, "HIDELINES"))
+    iupmotSetArg(args, num_args, XmNoutlineLineStyle,  XmNO_LINE);
+  else
+    iupmotSetArg(args, num_args, XmNoutlineLineStyle, XmSINGLE);
+
+  if (iupAttribGetBoolean(ih, "HIDEBUTTONS"))
+    iupmotSetArg(args, num_args, XmNoutlineButtonPolicy,  XmOUTLINE_BUTTON_ABSENT);
+  else
+    iupmotSetArg(args, num_args, XmNoutlineButtonPolicy, XmOUTLINE_BUTTON_PRESENT);
+
+  ih->handle = XtCreateManagedWidget(
+    child_id,       /* child identifier */
+    xmContainerWidgetClass,   /* widget class */
+    parent,         /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)parent);
+
+  XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)motTreeEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)motTreeEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, FocusChangeMask, False, (XtEventHandler)motTreeFocusChangeEvent,  (XtPointer)ih);
+  XtAddEventHandler(ih->handle, KeyPressMask,    False, (XtEventHandler)motTreeKeyPressEvent,    (XtPointer)ih);
+  XtAddEventHandler(ih->handle, KeyReleaseMask,  False, (XtEventHandler)motTreeKeyReleaseEvent,  (XtPointer)ih);
+  XtAddEventHandler(ih->handle, ButtonPressMask|ButtonReleaseMask, False, (XtEventHandler)motTreeButtonEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, PointerMotionMask, False, (XtEventHandler)iupmotPointerMotionEvent, (XtPointer)ih);
+
+  /* Callbacks */
+  /* XtAddCallback(ih->handle, XmNhelpCallback,           (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);  NOT WORKING */
+  XtAddCallback(ih->handle, XmNoutlineChangedCallback, (XtCallbackProc)motTreeOutlineChangedCallback, (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNdefaultActionCallback,  (XtCallbackProc)motTreeDefaultActionCallback,  (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNselectionCallback,      (XtCallbackProc)motTreeSelectionCallback,      (XtPointer)ih);
+
+  XtRealizeWidget(parent);
+
+  if (ih->data->show_dragdrop)
+  {
+    motTreeEnableDragDrop(ih->handle);
+    XtVaSetValues(ih->handle, XmNuserData, ih, NULL);  /* to be used in motTreeTransferProc */
+  }
+  else
+    iupmotDisableDragSource(ih->handle);
+
+  /* Force background update before setting the images */
+  {
+    char* value = iupAttribGet(ih, "BGCOLOR");
+    if (value)
+    {
+      motTreeSetBgColorAttrib(ih, value);
+      iupAttribSetStr(ih, "BGCOLOR", NULL);
+    }
+  }
+
+  /* Initialize the default images */
+  ih->data->def_image_leaf = iupImageGetImage("IMGLEAF", ih, 0);
+  if (!ih->data->def_image_leaf) 
+  {
+    ih->data->def_image_leaf = (void*)XmUNSPECIFIED_PIXMAP;
+    ih->data->def_image_leaf_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+  else
+  {
+    ih->data->def_image_leaf_mask = iupImageGetMask("IMGLEAF");
+    if (!ih->data->def_image_leaf_mask) ih->data->def_image_leaf_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+
+  ih->data->def_image_collapsed = iupImageGetImage("IMGCOLLAPSED", ih, 0);
+  if (!ih->data->def_image_collapsed) 
+  {
+    ih->data->def_image_collapsed = (void*)XmUNSPECIFIED_PIXMAP;
+    ih->data->def_image_collapsed_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+  else
+  {
+    ih->data->def_image_collapsed_mask = iupImageGetMask("IMGCOLLAPSED");
+    if (!ih->data->def_image_collapsed_mask) ih->data->def_image_collapsed_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+
+  ih->data->def_image_expanded = iupImageGetImage("IMGEXPANDED", ih, 0);
+  if (!ih->data->def_image_expanded) 
+  {
+    ih->data->def_image_expanded = (void*)XmUNSPECIFIED_PIXMAP;
+    ih->data->def_image_expanded_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+  else
+  {
+    ih->data->def_image_expanded_mask = iupImageGetMask("IMGEXPANDED");
+    if (!ih->data->def_image_expanded_mask) ih->data->def_image_expanded_mask = (void*)XmUNSPECIFIED_PIXMAP;
+  }
+
+  motTreeAddRootNode(ih);
+
+  IupSetCallback(ih, "_IUP_XY2POS_CB", (Icallback)motTreeConvertXYToPos);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvTreeInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motTreeMapMethod;
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, motTreeSetBgColorAttrib, "TXTBGCOLOR", NULL, IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, motTreeSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "TXTFGCOLOR", IUPAF_DEFAULT);
+
+  /* IupTree Attributes - GENERAL */
+  iupClassRegisterAttribute(ic, "EXPANDALL",  NULL, motTreeSetExpandAllAttrib,  NULL, NULL, IUPAF_WRITEONLY||IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "INDENTATION",  motTreeGetIndentationAttrib, motTreeSetIndentationAttrib, NULL, NULL, IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "COUNT", motTreeGetCountAttrib, NULL, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_READONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SPACING", iupTreeGetSpacingAttrib, motTreeSetSpacingAttrib, NULL, NULL, IUPAF_NOT_MAPPED);
+  iupClassRegisterAttribute(ic, "TOPITEM", NULL, motTreeSetTopItemAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+
+  /* IupTree Attributes - IMAGES */
+  iupClassRegisterAttributeId(ic, "IMAGE", NULL, motTreeSetImageAttrib, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "IMAGEEXPANDED", NULL, motTreeSetImageExpandedAttrib, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+
+  iupClassRegisterAttribute(ic, "IMAGELEAF",            NULL, motTreeSetImageLeafAttrib, IUPAF_SAMEASSYSTEM, "IMGLEAF", IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "IMAGEBRANCHCOLLAPSED", NULL, motTreeSetImageBranchCollapsedAttrib, IUPAF_SAMEASSYSTEM, "IMGCOLLAPSED", IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "IMAGEBRANCHEXPANDED",  NULL, motTreeSetImageBranchExpandedAttrib, IUPAF_SAMEASSYSTEM, "IMGEXPANDED", IUPAF_NO_INHERIT);
+
+  /* IupTree Attributes - NODES */
+  iupClassRegisterAttributeId(ic, "STATE",  motTreeGetStateAttrib,  motTreeSetStateAttrib, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "DEPTH",  motTreeGetDepthAttrib,  NULL, IUPAF_READONLY|IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "KIND",   motTreeGetKindAttrib,   NULL, IUPAF_READONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "PARENT", motTreeGetParentAttrib, NULL, IUPAF_READONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "COLOR",  motTreeGetColorAttrib,  motTreeSetColorAttrib, IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "NAME",   motTreeGetTitleAttrib,   motTreeSetTitleAttrib, IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "TITLE",   motTreeGetTitleAttrib,   motTreeSetTitleAttrib, IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "USERDATA",   motTreeGetUserDataAttrib,   motTreeSetUserDataAttrib, IUPAF_NO_STRING|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "CHILDCOUNT",   motTreeGetChildCountAttrib,   NULL, IUPAF_READONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "TITLEFONT", motTreeGetTitleFontAttrib, motTreeSetTitleFontAttrib, IUPAF_NO_INHERIT);
+
+  /* IupTree Attributes - MARKS */
+  iupClassRegisterAttributeId(ic, "MARKED",   motTreeGetMarkedAttrib,   motTreeSetMarkedAttrib,   IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute  (ic, "MARK",    NULL,    motTreeSetMarkAttrib,    NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute  (ic, "STARTING", NULL, motTreeSetMarkStartAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute  (ic, "MARKSTART", NULL, motTreeSetMarkStartAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+
+  iupClassRegisterAttribute  (ic, "VALUE",    motTreeGetValueAttrib,    motTreeSetValueAttrib,    NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+
+  /* IupTree Attributes - ACTION */
+  iupClassRegisterAttributeId(ic, "DELNODE", NULL, motTreeSetDelNodeAttrib, IUPAF_NOT_MAPPED|IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "RENAME",  NULL, motTreeSetRenameAttrib,  NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "MOVENODE",  NULL, motTreeSetMoveNodeAttrib,  IUPAF_NOT_MAPPED|IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "COPYNODE",  NULL, motTreeSetCopyNodeAttrib,  IUPAF_NOT_MAPPED|IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttributeId(ic, "FINDUSERDATA", motTreeGetFindUserDataAttrib, NULL, IUPAF_READONLY|IUPAF_NO_INHERIT);
+}
diff --git a/iup/src/mot/iupmot_val.c b/iup/src/mot/iupmot_val.c
new file mode 100755
index 0000000..200d2b4
--- /dev/null
+++ b/iup/src/mot/iupmot_val.c
@@ -0,0 +1,488 @@
+/** \file
+ * \brief Valuator Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <Xm/Xm.h>
+#include <Xm/Scale.h>
+#include <Xm/SeparatoG.h>
+#include <X11/keysym.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <memory.h>
+#include <stdarg.h>
+#include <limits.h>
+
+#include "iup.h"
+#include "iupcbs.h"
+
+#include "iup_object.h"
+#include "iup_childtree.h"
+#include "iup_attrib.h"
+#include "iup_dialog.h"
+#include "iup_str.h"
+#include "iup_val.h"
+#include "iup_image.h"
+#include "iup_drv.h"
+
+#include "iupmot_drv.h"
+#include "iupmot_color.h"
+
+
+void iupdrvValGetMinSize(Ihandle* ih, int *w, int *h)
+{
+  int ticks_size = 0;
+  if (iupAttribGetInt(ih, "SHOWTICKS"))
+    ticks_size = 8;
+
+  if (ih->data->type == IVAL_HORIZONTAL)
+  {
+    *w = 30;
+    *h = 20+ticks_size;
+  }
+  else
+  {
+    *w = 20+ticks_size;
+    *h = 30;
+  }
+}
+
+static void motValRemoveOldTicks(Widget scale)
+{
+  WidgetList children = (WidgetList)0;
+  Cardinal num_children = (Cardinal)0;
+  Cardinal i;
+  String name;
+
+  XtVaGetValues(scale, XmNchildren, &children, 
+                       XmNnumChildren, &num_children, 
+                       NULL);
+
+  for (i = 0; i < num_children; i++) 
+  {
+    if (XmIsSeparatorGadget(children[i])) 
+    {
+      if ((name = XtName(children[i])) != (String)0) 
+      {
+        if ((strcmp(name, "BigTic") == 0) ||
+            (strcmp(name, "MedTic") == 0) ||
+            (strcmp(name, "SmallTic") == 0)) 
+        {
+          XtDestroyWidget(children[i]);
+        }
+      }
+    }
+  }
+}
+
+static int motValSetShowTicksAttrib(Ihandle* ih, const char* value)
+{
+  int tick_freq, show_ticks;
+
+  if (!ih->data->show_ticks)  /* can only set if already not zero */
+    return 0;
+
+  show_ticks = atoi(value);
+  if (show_ticks<2) show_ticks=2;
+  ih->data->show_ticks = show_ticks;
+
+  motValRemoveOldTicks(ih->handle);
+
+  /* Defines the interval frequency for tick marks */
+  tick_freq = SHRT_MAX/(show_ticks-1);
+  XmScaleSetTicks(ih->handle, tick_freq, 0, 0, 8, 0, 0);
+  return 0;
+}
+
+static int motValSetPageStepAttrib(Ihandle* ih, const char* value)
+{
+  int pagesize;
+  ih->data->pagestep = atof(value);
+  pagesize = (int)(ih->data->pagestep*SHRT_MAX);
+  XtVaSetValues(ih->handle, XmNscaleMultiple, pagesize, NULL);
+  return 0; /* do not store value in hash table */
+}
+
+static int motValSetStepAttrib(Ihandle* ih, const char* value)
+{
+  ih->data->step = atof(value);
+  return 0; /* do not store value in hash table */
+}
+
+static int motValSetValueAttrib(Ihandle* ih, const char* value)
+{
+  int ival;
+
+  ih->data->val = atof(value);
+  iupValCropValue(ih);
+
+  ival = (int)(((ih->data->val-ih->data->vmin)/(ih->data->vmax - ih->data->vmin))*SHRT_MAX);
+  XtVaSetValues(ih->handle, XmNvalue, ival, NULL);
+
+  return 0; /* do not store value in hash table */
+}
+
+static int motValSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color;
+  unsigned char r, g, b;
+  if (!iupStrToRGB(value, &r, &g, &b))
+    return 0;
+
+  r = (r*8)/10;
+  g = (g*8)/10;
+  b = (b*8)/10;
+
+  color = iupmotColorGetPixel(r, g, b);
+  if (color != (Pixel)-1)
+  {
+    Widget w = XtNameToWidget(ih->handle, "*Scrollbar");
+    XtVaSetValues(w, XmNtroughColor, color, NULL);
+  }
+
+  return iupdrvBaseSetBgColorAttrib(ih, value);
+}
+
+static int motValSetBackgroundAttrib(Ihandle* ih, const char* value)
+{
+  Pixel color;
+
+  /* ignore given value, must use only from parent */
+  value = iupAttribGetInheritNativeParent(ih, "BACKGROUND");
+
+  color = iupmotColorGetPixelStr(value);
+  if (color != (Pixel)-1)
+  {
+    XtVaSetValues(ih->handle, XmNbackground, color, NULL);
+    return 1;
+  }
+  else
+  {
+    Pixmap pixmap = (Pixmap)iupImageGetImage(value, ih, 0);
+    if (pixmap)
+    {
+      XtVaSetValues(ih->handle, XmNbackgroundPixmap, pixmap, NULL);
+      return 1;
+    }
+  }
+  return 0; 
+}
+
+
+/*********************************************************************************************/
+
+
+static void motValCallAction(Ihandle* ih, int ival, int cb_state)
+{
+  double old_val = ih->data->val;
+  IFn cb;
+
+  ih->data->val = (((double)ival/(double)SHRT_MAX)*(ih->data->vmax - ih->data->vmin)) + ih->data->vmin;
+  iupValCropValue(ih);
+
+  cb = (IFn)IupGetCallback(ih, "VALUECHANGED_CB");
+  if (cb)
+  {
+    if (ih->data->val == old_val)
+      return;
+
+    cb(ih);
+  }
+  else
+  {
+    IFnd cb_old;
+    if (cb_state == 0)
+      cb_old = (IFnd) IupGetCallback(ih, "MOUSEMOVE_CB");
+    else if (cb_state == -1)
+      cb_old = (IFnd) IupGetCallback(ih, "BUTTON_RELEASE_CB");
+    else 
+      cb_old = (IFnd) IupGetCallback(ih, "BUTTON_PRESS_CB");
+
+    if (cb_old)
+      cb_old(ih, ih->data->val);
+  }
+}
+
+static void motValIncPageValue(Ihandle *ih, int dir)
+{
+  int pagesize, ival;
+  pagesize = (int)(ih->data->pagestep*SHRT_MAX);
+
+  if (ih->data->inverted)
+    dir *= -1;
+
+  XtVaGetValues(ih->handle, XmNvalue, &ival, NULL);
+  ival += dir*pagesize;
+  if (ival < 0) ival = 0;
+  if (ival > SHRT_MAX) ival = SHRT_MAX;
+  XtVaSetValues(ih->handle, XmNvalue, ival, NULL);
+
+  motValCallAction(ih, ival, 1);
+}
+
+static void motValIncLineValue(Ihandle *ih, int dir)
+{
+  int linesize, ival;
+  linesize = (int)(ih->data->step*SHRT_MAX);
+
+  if (ih->data->inverted)
+    dir *= -1;
+
+  XtVaGetValues(ih->handle, XmNvalue, &ival, NULL);
+  ival += dir*linesize;
+  if (ival < 0) ival = 0;
+  if (ival > SHRT_MAX) ival = SHRT_MAX;
+  XtVaSetValues(ih->handle, XmNvalue, ival, NULL);
+
+  motValCallAction(ih, ival, 1);
+}
+
+static void motValKeyPressEvent(Widget w, Ihandle *ih, XKeyEvent *evt, Boolean *cont)
+{
+  KeySym motcode;
+
+  *cont = True;
+  iupmotKeyPressEvent(w, ih, (XEvent*)evt, cont);
+  if (*cont == False)
+    return;
+
+  motcode = XKeycodeToKeysym(iupmot_display, evt->keycode, 0);
+
+  /* add missing support for numeric keyboard */
+  /* add missing support for left/right in vertical
+    and up/down in horizontal */
+  if (motcode == XK_Left || motcode == XK_KP_Left || 
+      motcode == XK_Up || motcode == XK_KP_Up)
+  {
+    motValIncLineValue(ih, -1);
+    *cont = False;
+    return;
+  }
+  if (motcode == XK_Right || motcode == XK_KP_Right || 
+      motcode == XK_Down || motcode == XK_KP_Down)
+  {
+    motValIncLineValue(ih, 1);
+    *cont = False;
+    return;
+  }
+  if (motcode == XK_Prior || motcode == XK_KP_Page_Up)
+  {
+    motValIncPageValue(ih, -1);
+    *cont = False;
+    return;
+  }
+  if (motcode == XK_Next || motcode == XK_KP_Page_Down)
+  {
+    motValIncPageValue(ih, 1);
+    *cont = False;
+    return;
+  }
+
+  /* change Home and End default behaviour */
+  if (ih->data->inverted)
+  {
+    if (motcode==XK_Home || motcode==XK_KP_Home)
+    {
+      int ival = SHRT_MAX;  /* set to maximum */
+      XtVaSetValues(ih->handle, XmNvalue, ival, NULL);
+      motValCallAction(ih, ival, 1);
+      *cont = False;
+      return;
+    }
+    if (motcode==XK_End || motcode==XK_KP_End)
+    {
+      int ival = 0; /* set to minimum */
+      XtVaSetValues(ih->handle, XmNvalue, ival, NULL);
+      motValCallAction(ih, ival, 1);
+      *cont = False;
+      return;
+    }
+  }
+  else
+  {
+    /* add missing support for numeric keyboard */
+    if (motcode==XK_KP_Home)
+    {
+      int ival = 0; /* set to minimum */
+      XtVaSetValues(ih->handle, XmNvalue, ival, NULL);
+      motValCallAction(ih, ival, 1);
+      *cont = False;
+      return;
+    }
+    if (motcode==XK_KP_End)
+    {
+      int ival = SHRT_MAX;  /* set to maximum */
+      XtVaSetValues(ih->handle, XmNvalue, ival, NULL);
+      motValCallAction(ih, ival, 1);
+      *cont = False;
+      return;
+    }
+  }
+}
+
+static void motValValueChangedCallback(Widget w, Ihandle* ih, XmScaleCallbackStruct *cbs)
+{
+  int cb_state = 1;
+
+  if(cbs->reason == XmCR_DRAG)
+    cb_state = 0;
+  else if (cbs->event && (cbs->event->type==ButtonRelease || cbs->event->type==KeyRelease))
+   cb_state = -1;
+
+  motValCallAction(ih, cbs->value, cb_state);
+
+  (void)w;  
+}
+
+static void motValButtonPressReleaseEvent(Widget w, Ihandle* ih, XButtonEvent* evt, Boolean* cont)
+{
+  (void)w;
+  (void)cont;
+
+  /* When Button1 is pressed, the Scrollbar loses its focus to the scale,
+     So we avoid calling GETFOCUS/KILLFOCUS. 
+  */
+
+  if (evt->type==ButtonPress && evt->button==Button1)
+  {
+    iupAttribSetStr(ih, "_IUPVAL_IGNOREFOCUS", "1");
+  }
+  if (evt->type==ButtonRelease && evt->button==Button1)
+  {
+    iupAttribSetStr(ih, "_IUPVAL_IGNOREFOCUS", NULL);
+    iupAttribSetStr(ih, "_IUPVAL_IGNOREKILLFOCUS", "1");
+  }
+}
+
+static void motValFocusChangeEvent(Widget w, Ihandle *ih, XEvent *evt, Boolean *cont)
+{
+  if (iupAttribGet(ih, "_IUPVAL_IGNOREFOCUS"))
+    return;
+
+  if (evt->type == FocusOut && iupAttribGet(ih, "_IUPVAL_IGNOREKILLFOCUS"))
+  {
+    iupAttribSetStr(ih, "_IUPVAL_IGNOREKILLFOCUS", NULL);
+    return;
+  }
+
+  iupmotFocusChangeEvent(w, ih, evt, cont);
+}
+
+
+/*********************************************************************************************/
+
+
+static int motValMapMethod(Ihandle* ih)
+{
+  int num_args = 0;
+  Arg args[30];
+  int show_ticks;
+
+  /* Core */
+  iupmotSetArg(args, num_args, XmNmappedWhenManaged, False);  /* not visible when managed */
+  iupmotSetArg(args, num_args, XmNx, 0);  /* x-position */
+  iupmotSetArg(args, num_args, XmNy, 0);  /* y-position */
+  iupmotSetArg(args, num_args, XmNwidth, 10);  /* default width to avoid 0 */
+  iupmotSetArg(args, num_args, XmNheight, 10); /* default height to avoid 0 */
+  /* Primitive */
+  if (iupAttribGetBoolean(ih, "CANFOCUS"))
+    iupmotSetArg(args, num_args, XmNtraversalOn, True);
+  else
+    iupmotSetArg(args, num_args, XmNtraversalOn, False);
+  iupmotSetArg(args, num_args, XmNhighlightThickness, 2);
+  iupmotSetArg(args, num_args, XmNnavigationType, XmTAB_GROUP);
+  /* Scale */
+  iupmotSetArg(args, num_args, XmNminimum, 0);
+  iupmotSetArg(args, num_args, XmNmaximum, SHRT_MAX);
+  iupmotSetArg(args, num_args, XmNslidingMode, XmSLIDER);
+  iupmotSetArg(args, num_args, XmNsliderMark, XmETCHED_LINE);
+  iupmotSetArg(args, num_args, XmNsliderSize, 16);
+  iupmotSetArg(args, num_args, XmNshowValue, XmNONE);
+
+  if (ih->data->type == IVAL_HORIZONTAL)
+  {
+    iupmotSetArg(args, num_args, XmNorientation, XmHORIZONTAL);
+    if (ih->data->inverted)
+      iupmotSetArg(args, num_args, XmNprocessingDirection, XmMAX_ON_LEFT);
+    else
+      iupmotSetArg(args, num_args, XmNprocessingDirection, XmMAX_ON_RIGHT);
+  }
+  else
+  {
+    iupmotSetArg(args, num_args, XmNorientation, XmVERTICAL);
+    if (ih->data->inverted)
+      iupmotSetArg(args, num_args, XmNprocessingDirection, XmMAX_ON_TOP);
+    else
+      iupmotSetArg(args, num_args, XmNprocessingDirection, XmMAX_ON_BOTTOM);
+  }
+
+  ih->handle = XtCreateManagedWidget(
+    iupDialogGetChildIdStr(ih),  /* child identifier */
+    xmScaleWidgetClass,          /* widget class */
+    iupChildTreeGetNativeParentHandle(ih), /* widget parent */
+    args, num_args);
+
+  if (!ih->handle)
+    return IUP_ERROR;
+
+  /* callbacks */
+  XtAddEventHandler(ih->handle, EnterWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+  XtAddEventHandler(ih->handle, LeaveWindowMask, False, (XtEventHandler)iupmotEnterLeaveWindowEvent, (XtPointer)ih);
+
+  /* XmScale changes the default behavior of these, must set directly into the scrollbar                           */
+  /* XtAddEventHandler(ih->handle, FocusChangeMask, False, (XtEventHandler)iupmotFocusChangeEvent, (XtPointer)ih); */
+  /* XtAddEventHandler(ih->handle, KeyPressMask,    False, (XtEventHandler)iupmotKeyPressEvent, (XtPointer)ih);    */
+
+  XtAddCallback(ih->handle, XmNdragCallback, (XtCallbackProc)motValValueChangedCallback, (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNvalueChangedCallback, (XtCallbackProc)motValValueChangedCallback, (XtPointer)ih);
+  XtAddCallback(ih->handle, XmNhelpCallback, (XtCallbackProc)iupmotHelpCallback, (XtPointer)ih);
+
+  {
+    Widget sb = XtNameToWidget(ih->handle, "Scrollbar");  /* TODO: Test this in other Motifs */
+    if (sb)
+    {
+      XtAddEventHandler(sb, FocusChangeMask, False, (XtEventHandler)motValFocusChangeEvent, (XtPointer)ih);
+      XtAddEventHandler(sb, KeyPressMask,    False, (XtEventHandler)motValKeyPressEvent, (XtPointer)ih);
+      XtAddEventHandler(sb, ButtonPressMask|ButtonReleaseMask, False, (XtEventHandler)motValButtonPressReleaseEvent, (XtPointer)ih);
+    }
+  }
+
+  /* Ticks can only be created before XtRealizeWidget */
+  show_ticks = iupAttribGetInt(ih, "SHOWTICKS");
+  if (show_ticks)
+  {
+    if (show_ticks<2) show_ticks=2;
+    ih->data->show_ticks = show_ticks; /* non zero value, can be changed later, but not to zero */
+  }
+
+  ih->serial = iupDialogGetChildId(ih); /* must be after using the string */
+
+  /* initialize the widget */
+  XtRealizeWidget(ih->handle);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvValInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = motValMapMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, motValSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "BACKGROUND", NULL, motValSetBackgroundAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);
+
+  /* Special */
+
+  /* IupVal only */
+  iupClassRegisterAttribute(ic, "VALUE", iupValGetValueAttrib, motValSetValueAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);  
+  iupClassRegisterAttribute(ic, "PAGESTEP", iupValGetPageStepAttrib, motValSetPageStepAttrib, IUPAF_SAMEASSYSTEM, "0.1", IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SHOWTICKS", iupValGetShowTicksAttrib, motValSetShowTicksAttrib, IUPAF_SAMEASSYSTEM, "0", IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "STEP", iupValGetStepAttrib, motValSetStepAttrib, IUPAF_SAMEASSYSTEM, "0.01", IUPAF_NO_INHERIT);
+}
diff --git a/iup/src/mot/iupunix_help.c b/iup/src/mot/iupunix_help.c
new file mode 100755
index 0000000..02be1da
--- /dev/null
+++ b/iup/src/mot/iupunix_help.c
@@ -0,0 +1,44 @@
+/** \file
+ * \brief Motif Driver IupHelp
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "iup.h"
+
+#include "iup_str.h"
+
+int IupHelp(const char *url)
+{
+  char *cmd;
+  int ret;
+  char *browser = getenv("IUP_HELPAPP");
+  if (!browser) 
+    browser = IupGetGlobal("HELPAPP");
+    
+  if (!browser) 
+  { 
+    char* system = IupGetGlobal("SYSTEM"); 
+    if (iupStrEqualNoCase(system, "Linux") ||
+        iupStrEqualNoCase(system, "FreeBSD"))
+      browser = "firefox";
+    else if (iupStrEqualNoCase(system, "Darwin"))
+      browser = "safari";
+    else if (iupStrEqualPartial(system, "CYGWIN"))
+      browser = "iexplore";
+    else  
+      browser = "netscape";
+  }
+  
+  cmd = (char*)malloc(sizeof(char)*(strlen(url)+strlen(browser)+3));
+  sprintf(cmd, "%s %s &", browser, url);
+  ret = system(cmd); 
+  free(cmd);
+  if (ret == -1)
+    return -1;
+  return 1;
+}
diff --git a/iup/src/mot/iupunix_info.c b/iup/src/mot/iupunix_info.c
new file mode 100755
index 0000000..b522638
--- /dev/null
+++ b/iup/src/mot/iupunix_info.c
@@ -0,0 +1,305 @@
+/** \file
+ * \brief UNIX System Information
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <stdio.h>
+#include <stdlib.h> 
+#include <string.h> 
+#include <limits.h>
+#include <sys/stat.h>
+
+/* This module should depend only on IUP core headers 
+   and UNIX system headers. NO Motif headers allowed. */
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <sys/utsname.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+#include "iup_str.h"
+#include "iup_drvinfo.h"
+
+
+int iupdrvMakeDirectory(const char* name) 
+{
+  mode_t oldmask = umask((mode_t)0);
+  int fail =  mkdir(name, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP |
+                          S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH);
+  umask (oldmask);
+  if (fail)
+    return 0;
+  return 1;
+}
+
+int iupdrvIsFile(const char* name)
+{
+  struct stat status;
+  if (stat(name, &status) != 0)
+    return 0;
+  if (S_ISDIR(status.st_mode))
+    return 0;
+  return 1;
+}
+
+int iupdrvIsDirectory(const char* name)
+{
+  struct stat status;
+  if (stat(name, &status) != 0)
+    return 0;
+  if (S_ISDIR(status.st_mode))
+    return 1;
+  return 0;
+}            
+
+char* iupdrvGetCurrentDirectory(void)
+{
+  size_t size = 256;
+  char *buffer = (char *)malloc(size);
+
+  for (;;)
+  {
+    if (getcwd(buffer, size) != NULL)
+      return buffer;
+
+    if (errno != ERANGE)
+    {
+      free(buffer);
+      return NULL;
+    }
+
+    size += size;
+    buffer = (char *)realloc(buffer, size);
+  }
+
+  return NULL;
+}
+
+int iupdrvSetCurrentDirectory(const char* dir)
+{
+  return chdir(dir) == 0? 1: 0;
+}
+
+int iupdrvGetWindowDecor(void* wnd, int *border, int *caption)
+{
+  XWindowAttributes wa;
+  wa.x = 0; wa.y = 0;
+  XGetWindowAttributes((Display*)iupdrvGetDisplay(), (Window)wnd, &wa);
+  if (wa.x > 0 && wa.y > 0 && wa.y >= wa.x)
+  {
+    *border = wa.x;
+    *caption = wa.y - *border;
+    return 1;
+  }
+
+  *border = 0;
+  *caption = 0;
+
+  return 0;
+}
+
+static int xGetWorkAreaSize(Display* display, int screen, int *width, int *height)
+{
+  /* _NET_WORKAREA, x, y, width, height CARDINAL[][4]/32 */
+  static Atom workarea = 0;
+  Atom type;
+  long *data;
+  int format;
+  unsigned long after, ndata;
+
+  if (!workarea)
+    workarea = XInternAtom(display, "_NET_WORKAREA", False);
+
+  XGetWindowProperty(display, RootWindow(display, screen),
+                     workarea, 0, LONG_MAX, False, XA_CARDINAL, &type, &format, &ndata,
+                     &after, (unsigned char **)&data);
+  if (type != XA_CARDINAL || data == NULL)
+  {
+    if (data) XFree(data);
+    return 0;
+  }
+
+  *width = data[2];    /* get only for the first desktop */
+  *height = data[3];
+
+  XFree(data);
+  return 1;
+}
+
+void iupdrvGetScreenSize(int *width, int *height)
+{
+  Display* display = (Display*)iupdrvGetDisplay();
+  int screen = XDefaultScreen(display);
+  if (!xGetWorkAreaSize(display, screen, width, height))
+  {
+    *width = DisplayWidth(display, screen);
+    *height = DisplayHeight(display, screen);
+  }
+}
+
+void iupdrvGetFullSize(int *width, int *height)
+{
+  Display* display = (Display*)iupdrvGetDisplay();
+  int screen = XDefaultScreen(display);
+  Window root = RootWindow(display, screen);
+  XWindowAttributes wa;
+  XGetWindowAttributes(display, root, &wa);
+  *width = wa.width;
+  *height = wa.height;
+}
+
+static int xCheckVisualInfo(Display* drv_display, int bpp)
+{
+  int nitems;
+  XVisualInfo info, *ret_info;
+
+  info.depth = bpp;
+  ret_info = XGetVisualInfo(drv_display, VisualDepthMask, &info, &nitems);
+  if (ret_info != NULL)
+  {
+    XFree(ret_info);
+    return 1;
+  }
+  return 0;
+}
+
+int iupdrvGetScreenDepth(void)
+{
+  static int first = 1;
+  static int bpp;
+
+  if (first)
+  {
+    Display* drv_display = (Display*)iupdrvGetDisplay();
+
+    if (xCheckVisualInfo(drv_display, 24))
+    {
+      bpp = 24;
+      return bpp;
+    }
+
+    if (xCheckVisualInfo(drv_display, 16))
+    {
+      bpp = 16;
+      return bpp;
+    }
+
+    if (xCheckVisualInfo(drv_display, 8))
+    {
+      bpp = 8;
+      return bpp;
+    }
+
+    if (xCheckVisualInfo(drv_display, 4))
+    {
+      bpp = 4;
+      return bpp;
+    }
+
+    bpp = 2;
+
+    first = 0;
+  }
+
+  return bpp;
+}
+
+void iupdrvGetCursorPos(int *x, int *y)
+{
+  Window root, child;
+  int cx, cy;
+  unsigned int keys;
+  Display* display = (Display*)iupdrvGetDisplay();
+  int screen = XDefaultScreen(display);
+
+  XQueryPointer(display, RootWindow(display, screen),
+                &root, &child, x, y, &cx, &cy, &keys);
+}
+
+static int xCheckModifier(KeyCode* modifiermap, int max_keypermod, int index, const char* keys)
+{
+  int i;
+  for (i = 0; i < max_keypermod; i++)
+  {
+    KeyCode key = modifiermap[max_keypermod * index + i];
+    if (key)
+    {
+      int KeyIndex = key / 8;
+      int KeyMask = 1 << (key % 8);
+      if (keys[KeyIndex] & KeyMask)
+        return 1;
+    }
+  }
+  return 0;
+}
+
+void iupdrvGetKeyState(char* key)
+{
+  char keys[32];
+  Display* display = (Display*)iupdrvGetDisplay();
+  XModifierKeymap *modMap = XGetModifierMapping(display);
+  XQueryKeymap(display, keys);
+
+  if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, ShiftMapIndex, keys))
+    key[0] = 'S';
+  else
+    key[0] = ' ';
+  if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, ControlMapIndex, keys))
+    key[1] = 'C';
+  else
+    key[1] = ' ';
+  if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, Mod1MapIndex, keys) ||
+      xCheckModifier(modMap->modifiermap, modMap->max_keypermod, Mod5MapIndex, keys))
+    key[2] = 'A';
+  else
+    key[2] = ' ';
+  if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, Mod4MapIndex, keys))
+    key[3] = 'Y';
+  else
+    key[3] = ' ';
+
+  key[4] = 0;
+
+  XFreeModifiermap(modMap);
+}
+
+char *iupdrvGetSystemName(void)
+{
+  struct utsname un;
+  char *str = iupStrGetMemory(50); 
+
+  uname(&un);
+  strcpy(str, un.sysname);
+
+  return str;
+}
+
+char *iupdrvGetSystemVersion(void)
+{
+  struct utsname un;
+  char *str = iupStrGetMemory(60); 
+
+  uname(&un);
+  strcpy(str, un.release);
+  strcat(str, ".");
+  strcat(str, un.version);
+
+  return str;
+}
+
+char *iupdrvGetComputerName(void)
+{
+  char* str = iupStrGetMemory(50);
+  gethostname(str, 50);
+  return str;
+}
+
+char *iupdrvGetUserName(void)
+{
+  return (char*)getlogin();
+}