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

1 files changed, 1439 insertions, 0 deletions

diff --git a/iup/src/gtk/iupgtk_list.c b/iup/src/gtk/iupgtk_list.c
new file mode 100755
index 0000000..80f6cce
--- /dev/null
+++ b/iup/src/gtk/iupgtk_list.c
@@ -0,0 +1,1439 @@
+/** \file
+ * \brief List Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.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_layout.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_drv.h"
+#include "iup_drvfont.h"
+#include "iup_mask.h"
+#include "iup_key.h"
+#include "iup_list.h"
+
+#include "iupgtk_drv.h"
+
+
+static void gtkListSelectionChanged(GtkTreeSelection* selection, Ihandle* ih);
+static void gtkListComboBoxChanged(GtkComboBox* widget, Ihandle* ih);
+
+
+void iupdrvListAddItemSpace(Ihandle* ih, int *h)
+{
+  (void)ih;
+  *h += 3;
+}
+
+void iupdrvListAddBorders(Ihandle* ih, int *x, int *y)
+{
+  int border_size = 2*5;
+  (*x) += border_size;
+  (*y) += border_size;
+
+  if (ih->data->is_dropdown)
+  {
+#ifdef HILDON
+    (*x) += 9; /* extra space for the dropdown button */
+#else
+    (*x) += 5; /* extra space for the dropdown button */
+#endif
+
+    if (ih->data->has_editbox)
+      (*x) += 5; /* another extra space for the dropdown button */
+    else
+    {
+      (*y) += 4; /* extra padding space */
+      (*x) += 4; /* extra padding space */
+    }
+  }
+  else
+  {
+    if (ih->data->has_editbox)
+      (*y) += 2*3; /* internal border between editbox and list */
+  }
+}
+
+static int gtkListConvertXYToPos(Ihandle* ih, int x, int y)
+{
+  if (!ih->data->is_dropdown)
+  {
+    GtkTreePath* path;
+    if (gtk_tree_view_get_dest_row_at_pos((GtkTreeView*)ih->handle, x, y, &path, NULL))
+    {
+      int* indices = gtk_tree_path_get_indices(path);
+      int pos = indices[0]+1;  /* IUP starts at 1 */
+      gtk_tree_path_free (path);
+      return pos;
+    }
+  }
+
+  return -1;
+}
+
+static GtkTreeModel* gtkListGetModel(Ihandle* ih)
+{
+  if (ih->data->is_dropdown)
+    return gtk_combo_box_get_model((GtkComboBox*)ih->handle);
+  else
+    return gtk_tree_view_get_model((GtkTreeView*)ih->handle);
+}
+
+int iupdrvListGetCount(Ihandle* ih)
+{
+  GtkTreeModel *model = gtkListGetModel(ih);
+  return gtk_tree_model_iter_n_children(model, NULL);
+}
+
+void iupdrvListAppendItem(Ihandle* ih, const char* value)
+{
+  GtkTreeModel *model = gtkListGetModel(ih);
+  GtkTreeIter iter;
+  gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+  gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, iupgtkStrConvertToUTF8(value), -1);
+}
+
+void iupdrvListInsertItem(Ihandle* ih, int pos, const char* value)
+{
+  GtkTreeModel *model = gtkListGetModel(ih);
+  GtkTreeIter iter;
+  gtk_list_store_insert(GTK_LIST_STORE(model), &iter, pos);
+  gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, iupgtkStrConvertToUTF8(value), -1);
+}
+
+void iupdrvListRemoveItem(Ihandle* ih, int pos)
+{
+  GtkTreeModel *model = gtkListGetModel(ih);
+  GtkTreeIter iter;
+  if (gtk_tree_model_iter_nth_child(model, &iter, NULL, pos))
+  {
+    if (ih->data->is_dropdown && !ih->data->has_editbox)
+    {
+      /* must check if removing the current item */
+      int curpos = gtk_combo_box_get_active((GtkComboBox*)ih->handle);
+      if (pos == curpos)
+      {
+        if (curpos > 0) curpos--;
+        else curpos++;
+
+        gtk_combo_box_set_active((GtkComboBox*)ih->handle, curpos);
+      }
+    }
+
+    gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
+  }
+}
+
+void iupdrvListRemoveAllItems(Ihandle* ih)
+{
+  GtkTreeModel *model = gtkListGetModel(ih);
+  gtk_list_store_clear(GTK_LIST_STORE(model));
+}
+
+
+/*********************************************************************************/
+
+
+static int gtkListSetStandardFontAttrib(Ihandle* ih, const char* value)
+{
+  iupdrvSetStandardFontAttrib(ih, value);
+
+  if (ih->handle)
+  {
+    if (ih->data->is_dropdown)
+    {
+      GtkCellRenderer* renderer = (GtkCellRenderer*)iupAttribGet(ih, "_IUPGTK_RENDERER");
+      if (renderer)
+      {
+        g_object_set(G_OBJECT(renderer), "font-desc", (PangoFontDescription*)iupgtkGetPangoFontDescAttrib(ih), NULL);
+        iupgtkFontUpdateObjectPangoLayout(ih, G_OBJECT(renderer));
+      }
+    }
+
+    if (ih->data->has_editbox)
+    {
+      GtkEntry* entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+      gtk_widget_modify_font((GtkWidget*)entry, (PangoFontDescription*)iupgtkGetPangoFontDescAttrib(ih));
+      iupgtkFontUpdatePangoLayout(ih, gtk_entry_get_layout(entry));
+    }
+  }
+  return 1;
+}
+
+static char* gtkListGetIdValueAttrib(Ihandle* ih, const char* name_id)
+{
+  int pos = iupListGetPos(ih, name_id);
+  if (pos != -1)
+  {
+    GtkTreeIter iter;
+    GtkTreeModel* model = gtkListGetModel(ih);
+    if (gtk_tree_model_iter_nth_child(model, &iter, NULL, pos))
+    {
+      gchar *text = NULL;
+      gtk_tree_model_get(model, &iter, 0, &text, -1);
+      if (text)
+      {
+        char* ret_str = iupStrGetMemoryCopy(iupgtkStrConvertFromUTF8(text));
+        g_free(text);
+        return ret_str;
+      }
+    }
+  }
+  return NULL;
+}
+
+static int gtkListSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  unsigned char r, g, b;
+
+  GtkScrolledWindow* scrolled_window = (GtkScrolledWindow*)iupAttribGet(ih, "_IUP_EXTRAPARENT");
+  if (scrolled_window && !ih->data->is_dropdown)
+  {
+    /* ignore given value, must use only from parent for the scrollbars */
+    char* parent_value = iupBaseNativeParentGetBgColor(ih);
+
+    if (iupStrToRGB(parent_value, &r, &g, &b))
+    {
+      GtkWidget* sb;
+
+      if (!GTK_IS_SCROLLED_WINDOW(scrolled_window))
+        scrolled_window = (GtkScrolledWindow*)iupAttribGet(ih, "_IUPGTK_SCROLLED_WINDOW");
+
+      iupgtkBaseSetBgColor((GtkWidget*)scrolled_window, r, g, b);
+
+#if GTK_CHECK_VERSION(2, 8, 0)
+      sb = gtk_scrolled_window_get_hscrollbar(scrolled_window);
+      if (sb) iupgtkBaseSetBgColor(sb, r, g, b);
+
+      sb = gtk_scrolled_window_get_vscrollbar(scrolled_window);
+      if (sb) iupgtkBaseSetBgColor(sb, r, g, b);
+#endif
+    }
+  }
+
+  if (!iupStrToRGB(value, &r, &g, &b))
+    return 0;
+
+  if (ih->data->has_editbox)
+  {
+    GtkWidget* entry = (GtkWidget*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+    iupgtkBaseSetBgColor(entry, r, g, b);
+  }
+
+  {
+    GtkCellRenderer* renderer = (GtkCellRenderer*)iupAttribGet(ih, "_IUPGTK_RENDERER");
+    if (renderer)
+    {
+      GdkColor color;
+      iupgdkColorSet(&color, r, g, b);
+      g_object_set(G_OBJECT(renderer), "cell-background-gdk", &color, NULL);
+    }
+  }
+
+  return iupdrvBaseSetBgColorAttrib(ih, value);
+}
+
+static int gtkListSetFgColorAttrib(Ihandle* ih, const char* value)
+{
+  unsigned char r, g, b;
+  if (!iupStrToRGB(value, &r, &g, &b))
+    return 0;
+
+  iupgtkBaseSetFgColor(ih->handle, r, g, b);
+
+  if (ih->data->has_editbox)
+  {
+    GtkWidget* entry = (GtkWidget*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+    iupgtkBaseSetFgColor(entry, r, g, b);
+  }
+
+  {
+    GtkCellRenderer* renderer = (GtkCellRenderer*)iupAttribGet(ih, "_IUPGTK_RENDERER");
+    if (renderer)
+    {
+      GdkColor color;
+      iupgdkColorSet(&color, r, g, b);
+      g_object_set(G_OBJECT(renderer), "foreground-gdk", &color, NULL);
+    }
+  }
+
+  return 1;
+}
+
+static char* gtkListGetValueAttrib(Ihandle* ih)
+{
+  if (ih->data->has_editbox)
+  {
+    GtkEntry* entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+    return iupStrGetMemoryCopy(iupgtkStrConvertFromUTF8(gtk_entry_get_text(entry)));
+  }
+  else 
+  {
+    if (ih->data->is_dropdown)
+    {
+      int pos = gtk_combo_box_get_active((GtkComboBox*)ih->handle);
+      char* str = iupStrGetMemory(50);
+      sprintf(str, "%d", pos+1);  /* IUP starts at 1 */
+      return str;
+    }
+    else
+    {
+      GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle));
+      if (!ih->data->is_multiple)
+      {
+        GtkTreeIter iter;
+        GtkTreeModel* tree_model;
+        if (gtk_tree_selection_get_selected(selection, &tree_model, &iter))
+        {
+          char* str;
+          GtkTreePath *path = gtk_tree_model_get_path(tree_model, &iter);
+          int* indices = gtk_tree_path_get_indices(path);
+          str = iupStrGetMemory(50);
+          sprintf(str, "%d", indices[0]+1);  /* IUP starts at 1 */
+          gtk_tree_path_free (path);
+          return str;
+        }
+      }
+      else
+      {
+        GList *il, *list = gtk_tree_selection_get_selected_rows(selection, NULL);
+        int count = iupdrvListGetCount(ih);
+        char* str = iupStrGetMemory(count+1);
+        memset(str, '-', count);
+        str[count]=0;
+        for (il=list; il; il=il->next)
+        {
+          GtkTreePath* path = (GtkTreePath*)il->data;
+          int* indices = gtk_tree_path_get_indices(path);
+          str[indices[0]] = '+';
+          gtk_tree_path_free(path);
+        }
+        g_list_free(list);
+        return str;
+      }
+    }
+  }
+
+  return NULL;
+}
+
+static int gtkListSetValueAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->has_editbox)
+  {
+    GtkEntry* entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+    if (!value) value = "";
+    iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", "1");
+    gtk_entry_set_text(entry, iupgtkStrConvertToUTF8(value));
+    iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", NULL);
+  }
+  else 
+  {
+    if (ih->data->is_dropdown)
+    {
+      int pos;
+      GtkTreeModel *model = gtkListGetModel(ih);
+      g_signal_handlers_block_by_func(G_OBJECT(ih->handle), G_CALLBACK(gtkListComboBoxChanged), ih);
+      if (iupStrToInt(value, &pos)==1 && 
+          (pos>0 && pos<gtk_tree_model_iter_n_children(model, NULL)))
+      {
+        gtk_combo_box_set_active((GtkComboBox*)ih->handle, pos-1);    /* IUP starts at 1 */
+        iupAttribSetInt(ih, "_IUPLIST_OLDVALUE", pos);
+      }
+      else
+      {
+        gtk_combo_box_set_active((GtkComboBox*)ih->handle, -1);    /* none */
+        iupAttribSetStr(ih, "_IUPLIST_OLDVALUE", NULL);
+      }
+      g_signal_handlers_unblock_by_func(G_OBJECT(ih->handle), G_CALLBACK(gtkListComboBoxChanged), ih);
+    }
+    else
+    {
+      GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle));
+      if (!ih->data->is_multiple)
+      {
+        int pos;
+        g_signal_handlers_block_by_func(G_OBJECT(selection), G_CALLBACK(gtkListSelectionChanged), ih);
+        if (iupStrToInt(value, &pos)==1)
+        {
+          GtkTreePath* path = gtk_tree_path_new_from_indices(pos-1, -1);   /* IUP starts at 1 */
+          gtk_tree_selection_select_path(selection, path);
+          gtk_tree_path_free(path);
+          iupAttribSetInt(ih, "_IUPLIST_OLDVALUE", pos);
+        }
+        else
+        {
+          gtk_tree_selection_unselect_all(selection);
+          iupAttribSetStr(ih, "_IUPLIST_OLDVALUE", NULL);
+        }
+        g_signal_handlers_unblock_by_func(G_OBJECT(selection), G_CALLBACK(gtkListSelectionChanged), ih);
+      }
+      else
+      {
+        /* User has changed a multiple selection on a simple list. */
+	      int i, len, count;
+
+        g_signal_handlers_block_by_func(G_OBJECT(selection), G_CALLBACK(gtkListSelectionChanged), ih);
+
+        /* Clear all selections */
+        gtk_tree_selection_unselect_all(selection);
+
+        if (!value)
+        {
+          iupAttribSetStr(ih, "_IUPLIST_OLDVALUE", NULL);
+          return 0;
+        }
+
+	      len = strlen(value);
+        count = iupdrvListGetCount(ih);
+        if (len < count) 
+          count = len;
+
+        /* update selection list */
+        for (i = 0; i<count; i++)
+        {
+          if (value[i]=='+')
+          {
+            GtkTreePath* path = gtk_tree_path_new_from_indices(i, -1);
+            gtk_tree_selection_select_path(selection, path);
+            gtk_tree_path_free(path);
+          }
+        }
+        iupAttribStoreStr(ih, "_IUPLIST_OLDVALUE", value);
+        g_signal_handlers_unblock_by_func(G_OBJECT(selection), G_CALLBACK(gtkListSelectionChanged), ih);
+      }
+    }
+  }
+
+  return 0;
+}
+
+static int gtkListSetShowDropdownAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->is_dropdown)
+  {
+    if (iupStrBoolean(value))
+      gtk_combo_box_popup((GtkComboBox*)ih->handle); 
+    else
+      gtk_combo_box_popdown((GtkComboBox*)ih->handle); 
+  }
+  return 0;
+}
+
+static int gtkListSetTopItemAttrib(Ihandle* ih, const char* value)
+{
+  if (!ih->data->is_dropdown)
+  {
+    int pos = 1;
+    if (iupStrToInt(value, &pos))
+    {
+      GtkTreePath* path = gtk_tree_path_new_from_indices(pos-1, -1);   /* IUP starts at 1 */
+      gtk_tree_view_scroll_to_cell((GtkTreeView*)ih->handle, path, NULL, FALSE, 0, 0);
+      gtk_tree_path_free(path);
+    }
+  }
+  return 0;
+}
+
+static int gtkListSetSpacingAttrib(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)
+  {
+    GtkCellRenderer* renderer = (GtkCellRenderer*)iupAttribGet(ih, "_IUPGTK_RENDERER");
+    if (renderer)
+      g_object_set(G_OBJECT(renderer), "xpad", ih->data->spacing, 
+                                       "ypad", ih->data->spacing, 
+                                       NULL);
+    return 0;
+  }
+  else
+    return 1; /* store until not mapped, when mapped will be set again */
+}
+
+static int gtkListSetPaddingAttrib(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)
+  {
+#if GTK_CHECK_VERSION(2, 10, 0)
+    GtkEntry* entry;
+    GtkBorder border;
+    border.bottom = border.top = ih->data->vert_padding;
+    border.left = border.right = ih->data->horiz_padding;
+    entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+    gtk_entry_set_inner_border(entry, &border);
+#endif
+    return 0;
+  }
+  else
+    return 1; /* store until not mapped, when mapped will be set again */
+}
+
+static int gtkListSetSelectionAttrib(Ihandle* ih, const char* value)
+{
+  int start=1, end=1;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+  if (!value)
+    return 0;
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  if (!value || iupStrEqualNoCase(value, "NONE"))
+  {
+    gtk_editable_select_region(GTK_EDITABLE(entry), 0, 0);
+    return 0;
+  }
+
+  if (iupStrEqualNoCase(value, "ALL"))
+  {
+    gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
+    return 0;
+  }
+
+  if (iupStrToIntInt(value, &start, &end, ':')!=2) 
+    return 0;
+
+  if(start<1 || end<1) 
+    return 0;
+
+  start--; /* IUP starts at 1 */
+  end--;
+
+  gtk_editable_select_region(GTK_EDITABLE(entry), start, end);
+
+  return 0;
+}
+
+static char* gtkListGetSelectionAttrib(Ihandle* ih)
+{
+  char *str;
+  int start, end;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return NULL;
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  if (gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end))
+  {
+    start++; /* IUP starts at 1 */
+    end++;
+    str = iupStrGetMemory(100);
+    sprintf(str, "%d:%d", (int)start, (int)end);
+    return str;
+  }
+
+  return NULL;
+}
+
+static int gtkListSetSelectionPosAttrib(Ihandle* ih, const char* value)
+{
+  int start=0, end=0;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+  if (!value)
+    return 0;
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  if (!value || iupStrEqualNoCase(value, "NONE"))
+  {
+    gtk_editable_select_region(GTK_EDITABLE(entry), 0, 0);
+    return 0;
+  }
+
+  if (iupStrEqualNoCase(value, "ALL"))
+  {
+    gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
+    return 0;
+  }
+
+  if (iupStrToIntInt(value, &start, &end, ':')!=2) 
+    return 0;
+
+  if(start<0 || end<0) 
+    return 0;
+
+  gtk_editable_select_region(GTK_EDITABLE(entry), start, end);
+
+  return 0;
+}
+
+static char* gtkListGetSelectionPosAttrib(Ihandle* ih)
+{
+  int start, end;
+  char *str;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return NULL;
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  if (gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end))
+  {
+    str = iupStrGetMemory(100);
+    sprintf(str, "%d:%d", (int)start, (int)end);
+    return str;
+  }
+
+  return NULL;
+}
+
+static int gtkListSetSelectedTextAttrib(Ihandle* ih, const char* value)
+{
+  int start, end;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+  if (!value)
+    return 0;
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  if (gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end))
+  {
+    /* disable callbacks */
+    iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", "1");
+    gtk_editable_delete_selection(GTK_EDITABLE(entry));
+    gtk_editable_insert_text(GTK_EDITABLE(entry), iupgtkStrConvertToUTF8(value), -1, &start);
+    iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", NULL);
+  }
+
+  return 0;
+}
+
+static char* gtkListGetSelectedTextAttrib(Ihandle* ih)
+{
+  int start, end;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return NULL;
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  if (gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end))
+  {
+    char* selectedtext = gtk_editable_get_chars(GTK_EDITABLE(entry), start, end);
+    char* str = iupStrGetMemoryCopy(iupgtkStrConvertFromUTF8(selectedtext));
+    g_free(selectedtext);
+    return str;
+  }
+
+  return NULL;
+}
+
+static int gtkListSetCaretAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 1;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  pos--; /* IUP starts at 1 */
+  if (pos < 0) pos = 0;
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  gtk_editable_set_position(GTK_EDITABLE(entry), pos);
+
+  return 0;
+}
+
+static char* gtkListGetCaretAttrib(Ihandle* ih)
+{
+  if (ih->data->has_editbox)
+  {
+    char* str = iupStrGetMemory(50);
+    GtkEntry* entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+    int pos = gtk_editable_get_position(GTK_EDITABLE(entry));
+    pos++; /* IUP starts at 1 */
+    sprintf(str, "%d", (int)pos);
+    return str;
+  }
+  else
+    return NULL;
+}
+
+static int gtkListSetCaretPosAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 0;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  if (pos < 0) pos = 0;
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  gtk_editable_set_position(GTK_EDITABLE(entry), pos);
+
+  return 0;
+}
+
+static char* gtkListGetCaretPosAttrib(Ihandle* ih)
+{
+  if (ih->data->has_editbox)
+  {
+    char* str = iupStrGetMemory(50);
+    GtkEntry* entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+    int pos = gtk_editable_get_position(GTK_EDITABLE(entry));
+    sprintf(str, "%d", (int)pos);
+    return str;
+  }
+  else
+    return NULL;
+}
+
+static int gtkListSetScrollToAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 1;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  if (pos < 1) pos = 1;
+  pos--;  /* return to GTK referece */
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  gtk_editable_set_position(GTK_EDITABLE(entry), pos);
+
+  return 0;
+}
+
+static int gtkListSetScrollToPosAttrib(Ihandle* ih, const char* value)
+{
+  int pos = 0;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+  if (!value)
+    return 0;
+
+  sscanf(value,"%i",&pos);
+  if (pos < 0) pos = 0;
+
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  gtk_editable_set_position(GTK_EDITABLE(entry), pos);
+
+  return 0;
+}
+
+static int gtkListSetInsertAttrib(Ihandle* ih, const char* value)
+{
+  gint pos;
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+  if (!value)
+    return 0;
+
+  iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", "1");  /* disable callbacks */
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  pos = gtk_editable_get_position(GTK_EDITABLE(entry));
+  gtk_editable_insert_text(GTK_EDITABLE(entry), iupgtkStrConvertToUTF8(value), -1, &pos);
+  iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", NULL);
+
+  return 0;
+}
+
+static int gtkListSetAppendAttrib(Ihandle* ih, const char* value)
+{
+  if (ih->data->has_editbox)
+  {
+    GtkEntry* entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+    gint pos = strlen(gtk_entry_get_text(entry))+1;
+    iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", "1"); /* disable callbacks */
+    gtk_editable_insert_text(GTK_EDITABLE(entry), iupgtkStrConvertToUTF8(value), -1, &pos);
+    iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", NULL);
+  }
+  return 0;
+}
+
+static int gtkListSetNCAttrib(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)
+  {
+    GtkEntry* entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+    gtk_entry_set_max_length(entry, ih->data->nc);
+  }
+
+  return 0;
+}
+
+static int gtkListSetClipboardAttrib(Ihandle *ih, const char *value)
+{
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+
+  /* disable callbacks */
+  iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", "1");
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  if (iupStrEqualNoCase(value, "COPY"))
+    gtk_editable_copy_clipboard(GTK_EDITABLE(entry));
+  else if (iupStrEqualNoCase(value, "CUT"))
+    gtk_editable_cut_clipboard(GTK_EDITABLE(entry));
+  else if (iupStrEqualNoCase(value, "PASTE"))
+    gtk_editable_paste_clipboard(GTK_EDITABLE(entry));
+  else if (iupStrEqualNoCase(value, "CLEAR"))
+    gtk_editable_delete_selection(GTK_EDITABLE(entry));
+  iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", NULL);
+  return 0;
+}
+
+static int gtkListSetReadOnlyAttrib(Ihandle* ih, const char* value)
+{
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return 0;
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  gtk_editable_set_editable(GTK_EDITABLE(entry), !iupStrBoolean(value));
+  return 0;
+}
+
+static char* gtkListGetReadOnlyAttrib(Ihandle* ih)
+{
+  GtkEntry* entry;
+  if (!ih->data->has_editbox)
+    return NULL;
+  entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+  if (!gtk_editable_get_editable(GTK_EDITABLE(entry)))
+    return "YES";
+  else
+    return "NO";
+}
+
+
+/*********************************************************************************/
+
+
+static void gtkListEditMoveCursor(GtkWidget* entry, GtkMovementStep step, gint count, gboolean extend_selection, Ihandle* ih)
+{
+  int pos;
+
+  IFniii cb = (IFniii)IupGetCallback(ih, "CARET_CB");
+  if (!cb) return;
+
+  pos = gtk_editable_get_position(GTK_EDITABLE(entry));
+
+  if (pos != ih->data->last_caret_pos)
+  {
+    ih->data->last_caret_pos = pos;
+
+    cb(ih, 1, pos+1, pos);
+  }
+
+  (void)step;
+  (void)count;
+  (void)extend_selection;
+}
+
+static gboolean gtkListEditKeyPressEvent(GtkWidget* entry, GdkEventKey *evt, Ihandle *ih)
+{
+  if (iupgtkKeyPressEvent(entry, evt, ih) == TRUE)
+    return TRUE;
+
+  if ((evt->keyval == GDK_Up || evt->keyval == GDK_KP_Up) ||
+      (evt->keyval == GDK_Prior || evt->keyval == GDK_KP_Page_Up) ||
+      (evt->keyval == GDK_Down || evt->keyval == GDK_KP_Down) ||
+      (evt->keyval == GDK_Next || evt->keyval == GDK_KP_Page_Down))
+  {
+    int pos = -1;
+    GtkTreeIter iter;
+    GtkTreeModel* model = NULL;
+    GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle));
+    if (gtk_tree_selection_get_selected(selection, &model, &iter))
+    {
+      GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
+      int* indices = gtk_tree_path_get_indices(path);
+      pos = indices[0];
+      gtk_tree_path_free(path);
+    }
+
+    if (pos == -1)
+      pos = 0;
+    else if (evt->keyval == GDK_Up || evt->keyval == GDK_KP_Up)
+    {
+      pos--;
+      if (pos < 0) pos = 0;
+    }
+    else if (evt->keyval == GDK_Prior || evt->keyval == GDK_KP_Page_Up)
+    {
+      pos -= 5;
+      if (pos < 0) pos = 0;
+    }
+    else if (evt->keyval == GDK_Down || evt->keyval == GDK_KP_Down)
+    {
+      int count = gtk_tree_model_iter_n_children(model, NULL);
+      pos++;
+      if (pos > count-1) pos = count-1;
+    }
+    else if (evt->keyval == GDK_Next || evt->keyval == GDK_KP_Page_Down)
+    {
+      int count = gtk_tree_model_iter_n_children(model, NULL);
+      pos += 5;
+      if (pos > count-1) pos = count-1;
+    }
+
+    if (pos != -1)
+    {
+      GtkTreePath* path = gtk_tree_path_new_from_indices(pos, -1);
+      g_signal_handlers_block_by_func(G_OBJECT(selection), G_CALLBACK(gtkListSelectionChanged), ih);
+      gtk_tree_selection_select_path(selection, path);
+      g_signal_handlers_unblock_by_func(G_OBJECT(selection), G_CALLBACK(gtkListSelectionChanged), ih);
+      gtk_tree_path_free(path);
+      iupAttribSetInt(ih, "_IUPLIST_OLDVALUE", pos);
+
+      if (!model) model = gtkListGetModel(ih);
+
+      if (gtk_tree_model_iter_nth_child(model, &iter, NULL, pos))
+      {
+        gchar *text = NULL;
+        gtk_tree_model_get(model, &iter, 0, &text, -1);
+        if (text)
+        {
+          gtk_entry_set_text((GtkEntry*)entry, text);
+          g_free(text);
+        }
+      }
+
+    }
+  }
+
+  return FALSE;
+}
+
+static gboolean gtkListEditKeyReleaseEvent(GtkWidget *widget, GdkEventKey *evt, Ihandle *ih)
+{
+  gtkListEditMoveCursor(widget, 0, 0, 0, ih);
+  (void)evt;
+  return FALSE;
+}
+
+static gboolean gtkListEditButtonEvent(GtkWidget *widget, GdkEventButton *evt, Ihandle *ih)
+{
+  gtkListEditMoveCursor(widget, 0, 0, 0, ih);
+  (void)evt;
+  return FALSE;
+}
+
+static int gtkListCallEditCb(Ihandle* ih, GtkEditable *editable, const char* insert_value, int len, int start, int end)
+{
+  char *new_value, *value;
+  int ret = -1, key = 0;
+
+  IFnis cb = (IFnis)IupGetCallback(ih, "EDIT_CB");
+  if (!cb && !ih->data->mask)
+    return -1; /* continue */
+
+  value = iupStrGetMemoryCopy(iupgtkStrConvertFromUTF8(gtk_entry_get_text(GTK_ENTRY(editable))));
+
+  if (!insert_value)
+  {
+    new_value = iupStrDup(value);
+    if (end<0) end = strlen(value)+1;
+    iupStrRemove(new_value, start, end, 1);
+  }
+  else
+  {
+    if (!value)
+      new_value = iupStrDup(insert_value);
+    else
+    {
+      if (len < end-start)
+      {
+        new_value = iupStrDup(value);
+        new_value = iupStrInsert(new_value, insert_value, start, end);
+      }
+      else
+        new_value = iupStrInsert(value, insert_value, start, end);
+    }
+  }
+
+  if (insert_value && insert_value[0]!=0 && insert_value[1]==0)
+    key = insert_value[0];
+
+  if (!new_value)
+    return -1; /* continue */
+
+  if (ih->data->nc && (int)strlen(new_value) > ih->data->nc)
+  {
+    if (new_value != value) free(new_value);
+    return 0; /* abort */
+  }
+
+  if (ih->data->mask && iupMaskCheck(ih->data->mask, new_value)==0)
+  {
+    if (new_value != value) free(new_value);
+    return 0; /* abort */
+  }
+
+  if (cb)
+  {
+    int cb_ret = cb(ih, key, (char*)new_value);
+    if (cb_ret==IUP_IGNORE)
+      ret = 0; /* abort */
+    else if (cb_ret==IUP_CLOSE)
+    {
+      IupExitLoop();
+      ret = 0; /* abort */
+    }
+    else if (cb_ret!=0 && key!=0 && 
+             cb_ret != IUP_DEFAULT && cb_ret != IUP_CONTINUE)  
+      ret = cb_ret; /* abort and replace */
+  }
+
+  if (new_value != value) free(new_value);
+  return ret; /* continue */
+}
+
+static void gtkListEditDeleteText(GtkEditable *editable, int start, int end, Ihandle* ih)
+{
+  if (iupAttribGet(ih, "_IUPGTK_DISABLE_TEXT_CB"))
+    return;
+
+  if (gtkListCallEditCb(ih, editable, NULL, 0, start, end)==0)
+    g_signal_stop_emission_by_name(editable, "delete_text");
+}
+
+static void gtkListEditInsertText(GtkEditable *editable, char *insert_value, int len, int *pos, Ihandle* ih)
+{
+  int ret;
+
+  if (iupAttribGet(ih, "_IUPGTK_DISABLE_TEXT_CB"))
+    return;
+
+  ret = gtkListCallEditCb(ih, editable, iupStrGetMemoryCopy(iupgtkStrConvertFromUTF8(insert_value)), len, *pos, *pos);
+  if (ret == 0)
+    g_signal_stop_emission_by_name(editable, "insert_text");
+  else if (ret != -1)
+  {
+    insert_value[0] = (char)ret;  /* replace key */
+
+    /* disable callbacks */
+    iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", "1");
+    gtk_editable_insert_text(editable, insert_value, 1, pos);
+    iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", NULL);
+
+    g_signal_stop_emission_by_name(editable, "insert_text"); 
+  }
+}
+
+static void gtkListEditChanged(void* dummy, Ihandle* ih)
+{
+  if (iupAttribGet(ih, "_IUPGTK_DISABLE_TEXT_CB"))
+    return;
+
+  iupBaseCallValueChangedCb(ih);
+  (void)dummy;
+}
+
+static void gtkListComboBoxPopupShownChanged(GtkComboBox* widget, GParamSpec *pspec, Ihandle* ih)
+{
+  IFni cb = (IFni)IupGetCallback(ih, "DROPDOWN_CB");
+  if (cb)
+  {
+    gboolean popup_shown;
+    g_object_get(widget, "popup-shown", &popup_shown, NULL);
+    cb(ih, popup_shown);
+  }
+  (void)pspec;
+}
+
+static void gtkListComboBoxChanged(GtkComboBox* widget, Ihandle* ih)
+{
+  IFnsii cb = (IFnsii)IupGetCallback(ih, "ACTION");
+  if (cb)
+  {
+    int pos = gtk_combo_box_get_active((GtkComboBox*)ih->handle);
+    pos++;  /* IUP starts at 1 */
+    iupListSingleCallActionCallback(ih, cb, pos);
+  }
+
+  if (!ih->data->has_editbox)
+    iupBaseCallValueChangedCb(ih);
+
+  (void)widget;
+}
+
+static gboolean gtkListSimpleKeyPressEvent(GtkWidget *widget, GdkEventKey *evt, Ihandle *ih)
+{
+  if (iupgtkKeyPressEvent(widget, evt, ih) == TRUE)
+    return TRUE;
+
+  if (evt->keyval == GDK_Return || evt->keyval == GDK_KP_Enter)
+    return TRUE; /* used to avoid the call to DBLCLICK_CB in the default processing */
+  return FALSE;
+}
+
+static void gtkListRowActivated(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, Ihandle* ih)
+{
+  IFnis cb = (IFnis) IupGetCallback(ih, "DBLCLICK_CB");
+  if (cb)
+  {
+    int* indices = gtk_tree_path_get_indices(path);
+    iupListSingleCallDblClickCallback(ih, cb, indices[0]+1);  /* IUP starts at 1 */
+  }
+  (void)column;
+  (void)tree_view;
+}
+
+static void gtkListSelectionChanged(GtkTreeSelection* selection, Ihandle* ih)
+{
+  if (ih->data->has_editbox)
+  {
+    /* must manually update its contents */
+    GtkTreeIter iter;
+    GtkTreeModel* tree_model;
+    if (gtk_tree_selection_get_selected(selection, &tree_model, &iter))
+    {
+      GtkTreePath *path = gtk_tree_model_get_path(tree_model, &iter);
+      char* value = NULL;
+      gtk_tree_model_get(tree_model, &iter, 0, &value, -1);
+      if (value)
+      {
+        GtkEntry* entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
+        gtk_entry_set_text(entry, value);
+        g_free(value);
+      }
+      gtk_tree_path_free(path);
+    }
+  }
+
+  if (!ih->data->is_multiple)
+  {
+    IFnsii cb = (IFnsii)IupGetCallback(ih, "ACTION");
+    if (cb)
+    {
+      GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle));
+      GtkTreeIter iter;
+      GtkTreeModel* tree_model;
+      if (gtk_tree_selection_get_selected(selection, &tree_model, &iter))
+      {
+        GtkTreePath *path = gtk_tree_model_get_path(tree_model, &iter);
+        int* indices = gtk_tree_path_get_indices(path);
+        iupListSingleCallActionCallback(ih, cb, indices[0]+1);  /* IUP starts at 1 */
+        gtk_tree_path_free (path);
+      }
+    }
+  }
+  else
+  {
+    IFns multi_cb = (IFns)IupGetCallback(ih, "MULTISELECT_CB");
+    IFnsii cb = (IFnsii) IupGetCallback(ih, "ACTION");
+    if (multi_cb || cb)
+    {
+      GList *il, *list = gtk_tree_selection_get_selected_rows(selection, NULL);
+      int i, sel_count = g_list_length(list);
+      int* pos = malloc(sizeof(int)*sel_count);
+      for (il=list, i=0; il; il=il->next, i++)
+      {
+        GtkTreePath* path = (GtkTreePath*)il->data;
+        int* indices = gtk_tree_path_get_indices(path);
+        pos[i] = indices[0];
+        gtk_tree_path_free(path);
+      }
+      g_list_free(list);
+
+      iupListMultipleCallActionCallback(ih, cb, multi_cb, pos, sel_count);
+      free(pos);
+    }
+  }
+
+  if (!ih->data->has_editbox)
+    iupBaseCallValueChangedCb(ih);
+}
+
+
+/*********************************************************************************/
+
+
+static int gtkListMapMethod(Ihandle* ih)
+{
+  GtkScrolledWindow* scrolled_window = NULL;
+  GtkListStore *store;
+
+  store = gtk_list_store_new(1, G_TYPE_STRING);
+
+  if (ih->data->is_dropdown)
+  {
+    GtkCellRenderer *renderer = NULL;
+
+    if (ih->data->has_editbox)
+      ih->handle = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(store), 0);
+    else
+      ih->handle = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
+    g_object_unref(store);
+
+    if (!ih->handle)
+      return IUP_ERROR;
+
+    g_object_set(G_OBJECT(ih->handle), "has-frame", TRUE, NULL);
+
+    if (ih->data->has_editbox)
+    {
+      GtkWidget *entry;
+#if GTK_CHECK_VERSION(2, 12, 0)
+      GList* list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(ih->handle));
+      renderer = list->data;
+      g_list_free(list);
+#endif
+
+      entry = gtk_bin_get_child(GTK_BIN(ih->handle));
+      iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry);
+
+      g_signal_connect(G_OBJECT(entry), "focus-in-event",     G_CALLBACK(iupgtkFocusInOutEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "focus-out-event",    G_CALLBACK(iupgtkFocusInOutEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "show-help",          G_CALLBACK(iupgtkShowHelp), ih);
+      g_signal_connect(G_OBJECT(entry), "key-press-event",    G_CALLBACK(iupgtkKeyPressEvent), ih);
+
+      g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih);
+      g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih);
+      /* g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(gtkListEditChanged), ih); */
+      g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih);  /* only report some caret movements */
+      g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih);  /* if connected "after" then it is ignored */
+      g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih);
+
+      if (!iupAttribGetBoolean(ih, "CANFOCUS"))
+        GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
+    }
+    else
+    {
+      /* had to add an event box just to get get/killfocus,enter/leave events */
+      GtkWidget *box = gtk_event_box_new();
+      gtk_container_add((GtkContainer*)box, ih->handle);
+      iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)box);
+
+      renderer = gtk_cell_renderer_text_new();
+      gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ih->handle), renderer, TRUE);
+      gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ih->handle), renderer, "text", 0, NULL);
+
+      g_signal_connect(G_OBJECT(box), "focus-in-event",  G_CALLBACK(iupgtkFocusInOutEvent), ih);
+      g_signal_connect(G_OBJECT(box), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
+      g_signal_connect(G_OBJECT(box), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
+      g_signal_connect(G_OBJECT(box), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
+      g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
+      g_signal_connect(G_OBJECT(ih->handle), "show-help",       G_CALLBACK(iupgtkShowHelp), ih);
+
+      if (!iupAttribGetBoolean(ih, "CANFOCUS"))
+        GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
+      else
+        GTK_WIDGET_FLAGS(box) |= GTK_CAN_FOCUS;
+    }
+
+    g_signal_connect(ih->handle, "changed", G_CALLBACK(gtkListComboBoxChanged), ih);
+    g_signal_connect(ih->handle, "notify::popup-shown", G_CALLBACK(gtkListComboBoxPopupShownChanged), ih);
+
+    if (renderer)
+    {
+      renderer->xpad = 0;
+      renderer->ypad = 0;
+      iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer);
+    }
+  }
+  else
+  {
+    GtkCellRenderer *renderer;
+    GtkTreeSelection* selection;
+    GtkTreeViewColumn *column;
+    GtkPolicyType scrollbar_policy;
+
+    ih->handle = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
+    g_object_unref(store);
+
+    if (!ih->handle)
+      return IUP_ERROR;
+
+    scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL);
+
+    if (ih->data->has_editbox)
+    {
+      GtkBox* vbox = (GtkBox*)gtk_vbox_new(FALSE, 0);
+
+      GtkWidget *entry = gtk_entry_new();
+      gtk_widget_show(entry);
+      gtk_box_pack_start(vbox, entry, FALSE, FALSE, 0);
+      iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry);
+
+      gtk_widget_show((GtkWidget*)vbox);
+      gtk_box_pack_end(vbox, (GtkWidget*)scrolled_window, TRUE, TRUE, 0);
+      iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)vbox);
+      iupAttribSetStr(ih, "_IUPGTK_SCROLLED_WINDOW", (char*)scrolled_window);
+
+      GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; /* focus goes only to the edit box */
+      if (!iupAttribGetBoolean(ih, "CANFOCUS"))
+        GTK_WIDGET_FLAGS(entry) &= ~GTK_CAN_FOCUS;
+
+      g_signal_connect(G_OBJECT(entry), "focus-in-event",     G_CALLBACK(iupgtkFocusInOutEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "focus-out-event",    G_CALLBACK(iupgtkFocusInOutEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "show-help",          G_CALLBACK(iupgtkShowHelp), ih);
+
+      g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih);
+      g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih);
+      g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(gtkListEditChanged), ih);
+      g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih);  /* only report some caret movements */
+      g_signal_connect(G_OBJECT(entry), "key-press-event",    G_CALLBACK(gtkListEditKeyPressEvent), ih);
+      g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih);
+      g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih);  /* if connected "after" then it is ignored */
+      g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih);
+    }
+    else
+    {
+      iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)scrolled_window);
+
+      if (!iupAttribGetBoolean(ih, "CANFOCUS"))
+        GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
+
+      g_signal_connect(G_OBJECT(ih->handle), "focus-in-event",     G_CALLBACK(iupgtkFocusInOutEvent), ih);
+      g_signal_connect(G_OBJECT(ih->handle), "focus-out-event",    G_CALLBACK(iupgtkFocusInOutEvent), ih);
+      g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
+      g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
+      g_signal_connect(G_OBJECT(ih->handle), "key-press-event",    G_CALLBACK(gtkListSimpleKeyPressEvent), ih);
+      g_signal_connect(G_OBJECT(ih->handle), "show-help",          G_CALLBACK(iupgtkShowHelp), ih);
+    }
+
+    column = gtk_tree_view_column_new();
+
+    renderer = gtk_cell_renderer_text_new();
+    gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE);
+    gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer, "text", 0, NULL);
+
+    iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer);
+    g_object_set(G_OBJECT(renderer), "xpad", 0, NULL);
+    g_object_set(G_OBJECT(renderer), "ypad", 0, NULL);
+
+    gtk_tree_view_append_column(GTK_TREE_VIEW(ih->handle), column);
+    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(ih->handle), FALSE);
+    gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ih->handle), FALSE);   /* TODO: check "start-interactive-search" signal */
+
+    gtk_container_add((GtkContainer*)scrolled_window, ih->handle);
+    gtk_widget_show((GtkWidget*)scrolled_window);
+    gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_IN); 
+
+    if (ih->data->sb)
+    {
+      if (iupAttribGetBoolean(ih, "AUTOHIDE"))
+        scrollbar_policy = GTK_POLICY_AUTOMATIC;
+      else
+        scrollbar_policy = GTK_POLICY_ALWAYS;
+    }
+    else
+      scrollbar_policy = GTK_POLICY_NEVER;
+
+    gtk_scrolled_window_set_policy(scrolled_window, scrollbar_policy, scrollbar_policy);
+
+    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle));
+    if (!ih->data->has_editbox && ih->data->is_multiple)
+    {
+      gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
+#if GTK_CHECK_VERSION(2, 10, 0)
+      gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(ih->handle), TRUE);
+#endif
+    }
+    else
+      gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
+
+    g_signal_connect(G_OBJECT(selection), "changed",  G_CALLBACK(gtkListSelectionChanged), ih);
+    g_signal_connect(G_OBJECT(ih->handle), "row-activated", G_CALLBACK(gtkListRowActivated), ih);
+    g_signal_connect(G_OBJECT(ih->handle), "motion-notify-event",G_CALLBACK(iupgtkMotionNotifyEvent), ih);
+    g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(iupgtkButtonEvent), ih);
+    g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(iupgtkButtonEvent), ih);
+  }
+
+  if (iupAttribGetBoolean(ih, "SORT"))
+    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), 0, GTK_SORT_ASCENDING);
+
+  /* add to the parent, all GTK controls must call this. */
+  iupgtkBaseAddToParent(ih);
+
+  if (scrolled_window)
+    gtk_widget_realize((GtkWidget*)scrolled_window);
+  gtk_widget_realize(ih->handle);
+
+  /* configure for DRAG&DROP */
+  if (IupGetCallback(ih, "DROPFILES_CB"))
+    iupAttribSetStr(ih, "DRAGDROP", "YES");
+
+  IupSetCallback(ih, "_IUP_XY2POS_CB", (Icallback)gtkListConvertXYToPos);
+
+  iupListSetInitialItems(ih);
+
+  return IUP_NOERROR;
+}
+
+void iupdrvListInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = gtkListMapMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Overwrite Common */
+  iupClassRegisterAttribute(ic, "STANDARDFONT", NULL, gtkListSetStandardFontAttrib, IUPAF_SAMEASSYSTEM, "DEFAULTFONT", IUPAF_NOT_MAPPED);
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", NULL, gtkListSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "TXTBGCOLOR", IUPAF_DEFAULT);
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, gtkListSetFgColorAttrib, IUPAF_SAMEASSYSTEM, "TXTFGCOLOR", IUPAF_DEFAULT);
+
+  /* IupList only */
+  iupClassRegisterAttributeId(ic, "IDVALUE", gtkListGetIdValueAttrib, iupListSetIdValueAttrib, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "VALUE", gtkListGetValueAttrib, gtkListSetValueAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SHOWDROPDOWN", NULL, gtkListSetShowDropdownAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "TOPITEM", NULL, gtkListSetTopItemAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "DRAGDROP", NULL, iupgtkSetDragDropAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SPACING", iupListGetSpacingAttrib, gtkListSetSpacingAttrib, NULL, NULL, IUPAF_NOT_MAPPED);
+
+  iupClassRegisterAttribute(ic, "PADDING", iupListGetPaddingAttrib, gtkListSetPaddingAttrib, IUPAF_SAMEASSYSTEM, "0x0", IUPAF_NOT_MAPPED);
+  iupClassRegisterAttribute(ic, "SELECTEDTEXT", gtkListGetSelectedTextAttrib, gtkListSetSelectedTextAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SELECTION", gtkListGetSelectionAttrib, gtkListSetSelectionAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SELECTIONPOS", gtkListGetSelectionPosAttrib, gtkListSetSelectionPosAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "CARET", gtkListGetCaretAttrib, gtkListSetCaretAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "CARETPOS", gtkListGetCaretPosAttrib, gtkListSetCaretPosAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "INSERT", NULL, gtkListSetInsertAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "APPEND", NULL, gtkListSetAppendAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "READONLY", gtkListGetReadOnlyAttrib, gtkListSetReadOnlyAttrib, NULL, NULL, IUPAF_DEFAULT);
+  iupClassRegisterAttribute(ic, "NC", iupListGetNCAttrib, gtkListSetNCAttrib, NULL, NULL, IUPAF_NOT_MAPPED);
+  iupClassRegisterAttribute(ic, "CLIPBOARD", NULL, gtkListSetClipboardAttrib, NULL, NULL, IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SCROLLTO", NULL, gtkListSetScrollToAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+  iupClassRegisterAttribute(ic, "SCROLLTOPOS", NULL, gtkListSetScrollToPosAttrib, NULL, NULL, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
+}