vdk-2.5.1/src/vdktreeview.cc

/*
 * ===========================
 * VDK Visual Development Kit
 * Version 2.0
 * November 2001
 * ===========================
 *
 * Copyright (C) 1998, Mario Motta
 * Developed by Mario Motta <mmotta@guest.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */
#include <vdk/vdktreeview.h>
#include <vdk/colors.h>
#include <string.h>
#include <stdlib.h>
static void col_clicked_cb (GtkTreeViewColumn *col, gpointer data);
static void selection_cb (GtkTreeSelection *selection, gpointer *gp);
static void row_activated_cb (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column,gpointer *gp);

VDKTreeViewModelTuple::VDKTreeViewModelTuple(int n, int key, VDKUStringCompareFunction less,
			VDKUStringCompareFunction equal) :
    StringRow(n),
    KeyIndex("KeyIndex",this,key),
    Less("Less",this,less),
    Equal("Equal",this,equal)
{
}

VDKTreeViewModelTuple::~VDKTreeViewModelTuple()
{
}

int
VDKTreeViewModelTuple::operator < (VDKTreeViewModelTuple& t)
{
	int key_index = KeyIndex;
	VDKUStringCompareFunction less = Less;
	if (less) return less((*this)[key_index],t[key_index]);
	else return (*this)[key_index] < t[key_index];
}

int
VDKTreeViewModelTuple::operator == (VDKTreeViewModelTuple& t)
{
	int key_index = KeyIndex;
	VDKUStringCompareFunction equal = Equal;
	if(equal) return equal((*this)[key_index],t[key_index]);
	else return (*this)[key_index] == t[key_index];
}

/*
 */
VDKTreeViewModel::VDKTreeViewModel(GType* types, int ncol)
{
  model = gtk_tree_store_newv (ncol,types);
}
/*
 */
VDKTreeViewModel::VDKTreeViewModel(GtkTreeModel *tvmodel)
{
  model = GTK_TREE_STORE(tvmodel);
}
/*
 */
void
VDKTreeViewModel::AppendBlank(GtkTreeIter* iter,GtkTreeIter* parent)
{
  gtk_tree_store_append (GTK_TREE_STORE (model), iter, parent);
}
/*
 */
void
VDKTreeViewModel::PrependBlank(GtkTreeIter* iter,GtkTreeIter* parent)
{
  gtk_tree_store_prepend (GTK_TREE_STORE (model), iter, parent);
}
/*
 */
void
VDKTreeViewModel::InsertTuple(GtkTreeIter* iter,VDKTreeViewModelTuple &tuple, GtkTreeIter* parent, bool recurse)
{
  int t = 0;
  VDKTreeViewModelIterator ti(this,parent);
  for(;ti;ti++)
    {
      VDKTreeViewModelTuple visited_tuple;
      GetTuple(ti.current(),visited_tuple);
      // sets key index and compare function in visited tuple
      int key_index = tuple.KeyIndex;
      VDKUStringCompareFunction less = tuple.Less;
      VDKUStringCompareFunction equal = tuple.Equal;
      visited_tuple.KeyIndex = key_index;
      visited_tuple.Less = less;
      visited_tuple.Equal = equal;
      // insert before greater node
      if(tuple < visited_tuple)
        {
          gtk_tree_store_insert_before (GTK_TREE_STORE(GtkModel()),
                                             iter,
                                             NULL,
                                             ti.current());
          for(t = 0; t < tuple.size(); t++)
              SetCell(iter,t,(char*) tuple[t]);
          return ;
        }
      else if(recurse && ti.HasChild())
	{
	 InsertTuple(iter,tuple, ti.current(),recurse);
	 return;
	}
    }
  // append to last node
  AppendBlank(iter,parent);
  for(t = 0; t < tuple.size(); t++)
      SetCell(iter,t,(char*) tuple[t]);
  return ;
}

/*
 */
void
VDKTreeViewModel::Remove(GtkTreeIter* i)
{
  gtk_tree_store_remove (GTK_TREE_STORE (model), i);
  return ;
}
/*
 */
void
VDKTreeViewModel::Clear()
{
  gtk_tree_store_clear(GTK_TREE_STORE (model));
}
/*
 */
void
VDKTreeViewModel::SetData(GtkTreeIter* node,...)
{
  va_list ap;
  va_start(ap,node);
  gtk_tree_store_set_valist(GTK_TREE_STORE(model),node,ap);
  va_end(ap);
}
/*
 */
VDKTreeViewModel::~VDKTreeViewModel()
{
}

/*
 */
bool
VDKTreeViewModel::Root(GtkTreeIter* iter)
{
  return gtk_tree_model_get_iter_root(GTK_TREE_MODEL(model),iter) ? true : false;
}
/*
 */
bool
VDKTreeViewModel::Next(GtkTreeIter* iter)
{
  return gtk_tree_model_iter_next(GTK_TREE_MODEL(model), iter) ? true : false;
}

bool
VDKTreeViewModel::Child(GtkTreeIter* iter,GtkTreeIter* parent)
{
  return gtk_tree_model_iter_children (GTK_TREE_MODEL(model), iter, parent) ? true : false;
}

/*
  local buffer should be freed by caller if not NULL.
 */

char *
VDKTreeViewModel::GetCell(GtkTreeIter* node, int column)
{
  const char* buff;
  char* local = NULL;
  GValue value = {0, };
  gtk_tree_model_get_value (GTK_TREE_MODEL(model), node, column, &value);
  GType type = gtk_tree_model_get_column_type  (GTK_TREE_MODEL(model), column);
  switch(type)
    {
    case G_TYPE_CHAR:
      {
	char val =  g_value_get_char(&value);
	local = new char[2];
	local[0] = val;
	local[1] = '\0';
      }
      break;
    case G_TYPE_STRING:
      if ( (buff = g_value_get_string (&value)) )
	{
	  local = new char[strlen(buff)+1];
	  strcpy(local,buff);
	}
      break;
    case G_TYPE_BOOLEAN:
      {
	bool val = g_value_get_boolean (&value);
	local = new char[8];
	sprintf(local,"%s",val ? "1" : "0");
      }
      break;
    case G_TYPE_INT:
      {
	int val = g_value_get_int(&value);
	local = new char[32];
	sprintf(local,"%d",val);
      }
      break;
    case G_TYPE_UINT:
      {
	unsigned int val = g_value_get_uint(&value);
	local = new char[32];
	sprintf(local,"%u",val);
      }
      break;
    case G_TYPE_LONG:
      {
	long val = g_value_get_long(&value);
	local = new char[32];
	sprintf(local,"%ld",val);
      }
      break;
    case G_TYPE_ULONG:
      {
	unsigned long val = g_value_get_ulong(&value);
	local = new char[32];
	sprintf(local,"%lu",val);
      }
      break;
    case G_TYPE_FLOAT:
      {
	float val = (float)g_value_get_ulong(&value);
	local = new char[64];
	sprintf(local,"%f",val);
      }
      break;
    case G_TYPE_DOUBLE:
      {
	double val = g_value_get_double(&value);
	local = new char[64];
	sprintf(local,"%f",val);
      }
      break;
    case G_TYPE_POINTER:
      {
	void* val = g_value_get_pointer(&value);
	local = new char[16];
	sprintf(local,"%p",val);
      }
    default:
      {
        if( type == GDK_TYPE_PIXBUF)
	  {
	    void* val = g_value_get_pointer(&value);
	    local = new char[16];
	    sprintf(local,"%p",val);
	  }
      }
    }
  g_value_unset (&value);
  return local;
}

/*
 */
void
VDKTreeViewModel::SetCell(GtkTreeIter* node, int column, const char* val)
{
  GValue value  = {0, };
  GType type = gtk_tree_model_get_column_type  (GTK_TREE_MODEL(model), column);
  g_value_init(&value,type);
  switch(type)
    {
    case G_TYPE_CHAR:
      g_value_set_char (&value,val[0]);
      break;
    case G_TYPE_STRING:
      g_value_set_string (&value,val);
      break;
    case G_TYPE_BOOLEAN:
      if(!strcasecmp("true",val))
	       g_value_set_boolean (&value, 1);
      else if(!strcasecmp("false",val))
	       g_value_set_boolean (&value, 0);
      else
	       g_value_set_boolean (&value, atoi(val));
      break;
    case G_TYPE_INT:
      g_value_set_int (&value, atoi(val));
      break;
    case G_TYPE_UINT:
      {
	     unsigned int v = (unsigned int) atoi(val);
	     g_value_set_uint (&value, v);
      }
      break;
    case G_TYPE_LONG:
      g_value_set_long (&value, atol(val));
      break;
    case G_TYPE_ULONG:
      {
	unsigned long v = (unsigned long) atol(val);
	g_value_set_ulong (&value, v);
      }
      break;
    case G_TYPE_FLOAT:
      g_value_set_float(&value, (gfloat)atof(val));
      break;
    case G_TYPE_DOUBLE:
      {
	char * endptr;
	double v = strtod(val,&endptr);
	g_value_set_double (&value, v);
      }
      break;
    default:
        g_value_unset (&value);
	return;
    }
  gtk_tree_store_set_value (GTK_TREE_STORE(model),node,column,&value);
  g_value_unset (&value);
}

/*
linear search on tree (depth first)
*/
static GtkTreeIter*
recurse(VDKTreeViewModel * model, int column, char* value, GtkTreeIter* iter)
{
  VDKTreeViewModelIterator ti(model,iter);
  GtkTreeIter * found = NULL;
  for(;ti;ti++)
    {
      char* visited_value = model->GetCell(ti.current(),column);
      if(visited_value && !strcmp(value,visited_value))
	{
	  delete[] visited_value;
	  found = ti.current();
	  break;
	}
      else if(visited_value)
	delete[] visited_value;
      if(ti.HasChild())
	{
	  found = recurse (model,column,value,ti.current());
	  if(found)
	    break;
	}
    }
  return found;
}

bool
VDKTreeViewModel::Find(GtkTreeIter* iter,int column, char* value)
{
  GtkTreeIter *found_iter = recurse(this,column,value,NULL);
  if(found_iter)
    {
      *iter = *found_iter;
      return true;
    }
  else
    return false;
}


/*
 */
void
VDKTreeViewModel::GetTuple(GtkTreeIter* node,VDKTreeViewModelTuple& tuple)
{
  int t;
  char* local;
  int n_columns = gtk_tree_model_get_n_columns (GTK_TREE_MODEL(model));
  tuple.resize(n_columns);
  for(t = 0; t < n_columns; t++)
    {
      local = GetCell(node,t);
      if(local)
	{
	  tuple[t] = local;
	  delete[] local;
	}
    }
  return ;
}


/*
                 VDK_TREE_VIEW_ITERAROR
*/
/*
 */
VDKTreeViewModelIterator::VDKTreeViewModelIterator(VDKTreeViewModel* model,GtkTreeIter* parent):
  model(model)
{
  if(parent)
    {
      if(gtk_tree_model_iter_children (GTK_TREE_MODEL(model->GtkModel()), &iter, parent))
	internal_iter = &iter;
      else
	internal_iter = NULL;
    }
  else if(gtk_tree_model_get_iter_root(GTK_TREE_MODEL(model->GtkModel()) ,&iter))
    internal_iter = &iter;
  else
    internal_iter = NULL;

}


void
VDKTreeViewModelIterator::operator++()
{
  if(gtk_tree_model_iter_next(GTK_TREE_MODEL(model->GtkModel()), &iter))
    internal_iter = &iter;
  else
    internal_iter = NULL;
}

void
VDKTreeViewModelIterator::operator++(int)
{
  if(gtk_tree_model_iter_next(GTK_TREE_MODEL(model->GtkModel()), &iter))
    internal_iter = &iter;
  else
    internal_iter = NULL;
}

bool
VDKTreeViewModelIterator::HasChild()
{
  if(internal_iter)
    {
      if(gtk_tree_model_iter_has_child (GTK_TREE_MODEL(model->GtkModel()), &iter))
	return true;
    }
  return false;
}


/*

                  VDKTREEVIEWCOLUMN
 */

void
VDKTreeViewColumn::edited_callback (GtkCellRendererText *cell,
	gchar               *path_string,
	gchar               *new_text,
	gpointer             data)
{
  VDKTreeViewColumn* column = reinterpret_cast<VDKTreeViewColumn*>(data);
  VDKTreeView* tree = column->Owner();
  VDKTreeViewModel *model = tree->Model;
  int t = 0;
  VDKTreeViewIter iter(model ?
       GTK_TREE_MODEL(model->GtkModel()) : NULL);
  tree->Selections().flush();
  GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
  gtk_tree_model_get_iter (GTK_TREE_MODEL(model->GtkModel()), &iter, path);
  tree->Selections().add(iter);
  VDKTreeViewColumnListIterator li(*tree->Columns());
  for(;li;li++,t++)
      if(column == li.current())
      break;
  t = t < tree->Columns()->size() ? t : -1;
  if(t>=0)
    {
      tree->ChangedColumn(t);
      tree->ChangedText(new_text);
      tree->SignalEmit(cell_edited_signal);
      tree->SignalEmit("cell_edited_signal");
      gtk_tree_path_free (path);
    }

}
/*
 */
void
VDKTreeViewColumn::toggled_callback (GtkCellRendererToggle *cell,
	 gchar                 *path_string,
	 gpointer               data)
{
  VDKTreeViewColumn* column = reinterpret_cast<VDKTreeViewColumn*>(data);
  VDKTreeView* tree = dynamic_cast<VDKTreeView*>(column->Owner());
  VDKTreeViewModel *model = tree->Model;
  if(column && tree && model)
  {
    int t = 0;
    VDKTreeViewIter iter(model ?
       GTK_TREE_MODEL(model->GtkModel()) : NULL);
    tree->Selections().flush();
    GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
    gtk_tree_model_get_iter (GTK_TREE_MODEL(model->GtkModel()), &iter, path);
    tree->Selections().add(iter);
    VDKTreeViewColumnListIterator li(*tree->Columns());
    for(;li;li++,t++)
      if(column == li.current())
      	break;
    t = t < tree->Columns()->size() ? t : -1;
    if(t>=0)
      {
       tree->ChangedColumn(t);
//       gtk_tree_model_get (GTK_TREE_MODEL(model->GtkModel()),
//          &iter, t, &value, -1);
       tree->SignalEmit(cell_toggled_signal);
       tree->SignalEmit("cell_toggled_signal");
       gtk_tree_path_free (path);
      }
  }
}
/*
 */
VDKTreeViewColumn::VDKTreeViewColumn(VDKTreeView *owner, int col,
  char* title, bool editable, int ecol):
  owner(owner), handler_seq_no(0),
  NormalBackground("NormalBackground",this,VDKRgb(-1,-1,-1),
		   &VDKTreeViewColumn::SetNormalBackground),
  Foreground("Foreground",this,VDKRgb(-1,-1,-1),
	     &VDKTreeViewColumn::SetForeground),
  Font("Font",this,NULL,&VDKTreeViewColumn::SetFont),
  Title("Title",this,NULL,&VDKTreeViewColumn::SetTitle,&VDKTreeViewColumn::GetTitle),
  Width("Width",this,0,&VDKTreeViewColumn::SetWidth,&VDKTreeViewColumn::GetWidth),
  Sortable("Sortable",this,false,&VDKTreeViewColumn::SetSortable)
{
  VDKTreeViewModel* model = owner->Model;
  // error if no model ..... and/or editable stuff
  GType type = gtk_tree_model_get_column_type  (GTK_TREE_MODEL(model->GtkModel()), col);
  if( type == GDK_TYPE_PIXBUF)
    {
      cell = gtk_cell_renderer_pixbuf_new ();
      column = gtk_tree_view_column_new_with_attributes (title,cell,"pixbuf",col, (gchar*)NULL);
    }
  else
    {
      switch(type)
	{
	case G_TYPE_STRING:
	  cell = gtk_cell_renderer_text_new ();
	  if(!editable)
	    column = gtk_tree_view_column_new_with_attributes (title,cell,
        "text",col,(gchar*)NULL);
	  else
	    {
	    column = gtk_tree_view_column_new_with_attributes (title,cell,
							       "text",col,
							       "editable",ecol >= 0 ? ecol : 0,
							       (gchar*)NULL);
	    g_signal_connect_data (G_OBJECT (cell), "edited",
		        G_CALLBACK (VDKTreeViewColumn::edited_callback),
            this, NULL,(GConnectFlags) 0);
	    }
	  break;

	case G_TYPE_BOOLEAN:
	  cell = gtk_cell_renderer_toggle_new ();
	  /*
	  g_object_set (G_OBJECT (cell),"activatable", TRUE, "radio", FALSE, (gchar*)NULL);

	  */
	  column = gtk_tree_view_column_new_with_attributes (title,cell,
      "active", col,(gchar*)NULL);
	  if(editable)
	     g_signal_connect_data (G_OBJECT (cell), "toggled",
		    G_CALLBACK (VDKTreeViewColumn::toggled_callback),
        this, NULL,(GConnectFlags) 0);
	  break;
	default:
	  column = NULL; // ERROR
	}
    }


  if(column)
    {
      if(title)
	Title = title;
      SetWidth(0);
      owner->Columns()->add(this);
      gtk_tree_view_append_column (GTK_TREE_VIEW (owner->WrappedWidget()), GTK_TREE_VIEW_COLUMN (column));
    }
}


/*
 */
VDKTreeViewColumn::~VDKTreeViewColumn()
{
}

/*
 */
void
VDKTreeViewColumn::ActiveTitle(bool flag)
{
  gtk_tree_view_column_set_clickable (GtkColumn(), flag);
  if(flag && (handler_seq_no == (gulong) 0))
    handler_seq_no = g_signal_connect_data (G_OBJECT (GtkColumn()), "clicked",
			 (GCallback) ::col_clicked_cb, owner ,NULL,(GConnectFlags) 0);
}
/*
 */
void
VDKTreeViewColumn::SetNormalBackground(VDKRgb rgb)
{
    VDKColor *color = NULL;
    color = new VDKColor( owner->Owner() ,rgb.red, rgb.green, rgb.blue);
    g_object_set (G_OBJECT (cell),"background-gdk", color->Color(),(gchar*)NULL);
}
/*
 */
void
VDKTreeViewColumn::SetForeground(VDKRgb rgb)
{
   VDKColor *color = NULL;
   color = new VDKColor( owner->Owner() ,rgb.red, rgb.green, rgb.blue);
   g_object_set (G_OBJECT (cell),"foreground-gdk", color->Color(),(gchar*)NULL);
}

/*
 */
void
VDKTreeViewColumn::SetFont(VDKFont* font)
{
  g_object_set (G_OBJECT (cell),"font-desc", font->AsPangoFontDescription(),(gchar*)NULL);
}
/*
 */
void
VDKTreeViewColumn::SetTitle(const char* title)
{
  gtk_tree_view_column_set_title  (GTK_TREE_VIEW_COLUMN (column),title);
}
/*
 */
const char*
VDKTreeViewColumn::GetTitle()
{
  return gtk_tree_view_column_get_title  (GTK_TREE_VIEW_COLUMN (column));
}
/*
 */
void
VDKTreeViewColumn::SetWidth(int w)
{
  if(w > 0)
    {
      gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED);
      gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column),w);
    }
  else
    gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_AUTOSIZE);
}
/*
 */
int
VDKTreeViewColumn::GetWidth()
{
  return gtk_tree_view_column_get_width (GTK_TREE_VIEW_COLUMN (column));
}

/*
 */
void
VDKTreeViewColumn::SetSortable(bool flag )
{
  int t = 0;
  if(flag)
    {
      VDKTreeViewColumnListIterator li(*owner->Columns());
      for(;li;li++,t++)
	if(this == li.current())
	  gtk_tree_view_column_set_sort_column_id (GtkColumn(),t);
    }
  else
    gtk_tree_view_column_set_sort_column_id (GtkColumn(),-1);
}

/*


                      VDKTREEVIEWITERATOR CLASS
                      =========================

*/
bool
VDKTreeViewIter::Child(VDKTreeViewIter* child_iter)
{
  if(model && gtk_tree_model_iter_children(model,child_iter,this))
    {
      child_iter->Model(model);
      return true;
    }
  else
    return false;
}

bool
VDKTreeViewIter::Parent(VDKTreeViewIter* parent_iter)
{
  if (model && gtk_tree_model_iter_parent (model,parent_iter,this))
    {
      parent_iter->Model(model);
      return true;
    }
  else
    return false;
}
/*

                       VDKTREEVIEW CLASS

 */
void
col_clicked_cb (GtkTreeViewColumn *col, gpointer gp)
{
  VDKTreeView * tree = reinterpret_cast<VDKTreeView*>(gp);
  VDKTreeViewColumnListIterator li(*(tree->Columns()));
  int t = 0;
  for(;li;li++,t++)
    {
      if(li.current()->GtkColumn() == col)
	{
	  tree->SelectedColumn(t);
	  tree->SignalEmit(click_column_signal);
	  tree->SignalEmit("click_column_signal");
	  return;
	}
    }
  tree->SelectedColumn(-1);
}

void
selection_cb (GtkTreeSelection *selection,
	      gpointer     *gp)
{
  VDKTreeView* tree = reinterpret_cast<VDKTreeView*>(gp);
  VDKTreeViewModel *model = tree->Model;
  VDKTreeViewIter iter(model ? GTK_TREE_MODEL(model->GtkModel()) : NULL);
  tree->Selections().flush();
  if (!gtk_tree_selection_get_selected (selection, NULL,&iter))
    return;
  else
    {
      tree->Selections().add(iter);
      tree->SignalEmit(select_row_signal);
      tree->SignalEmit("select_row_signal");
    }
}


static
void visit_selection  (GtkTreeModel *model,  GtkTreePath *path,  GtkTreeIter *iter, gpointer gp)
{
  VDKTreeViewIter i(model);
  VDKTreeView* tree = reinterpret_cast<VDKTreeView*>(gp);
  //  gtk_tree_model_get_iter (model, &i, path);
  /*
    uhmmm...
    using GtkTreeIter private data could not be a good idea on compatibility side,
    in  other hand i suspect a O(n2) time using gtk_tree_model_get_iter()
  */
  i.stamp = iter->stamp;
  i.user_data = iter->user_data;
  i.user_data2 = iter->user_data2;
  i.user_data3 = iter->user_data3;
  tree->Selections().add(i);
}


void
row_activated_cb (GtkTreeView *tree_view,
		  GtkTreePath *path,
		  GtkTreeViewColumn *column,
		  gpointer  *gp)
{
  VDKTreeView* tree = reinterpret_cast<VDKTreeView*>(gp);
  tree->SignalEmit(row_activated_signal);
  tree->SignalEmit("row_activated_signal");
}


void
VDKTreeView::GetSelections()
{
  Selections().flush();
  gtk_tree_selection_selected_foreach(selection, visit_selection, this);
}

/*
 */
VDKTreeView::VDKTreeView(VDKForm* owner, VDKTreeViewModel* model, GtkSelectionMode mode):
  VDKObject(owner),
  ActiveSearch("ActiveSearch", this, false,
  				&VDKTreeView::SetActiveSearch, &VDKTreeView::GetActiveSearch),
  SearchColumn("SearchColumn", this, -1,
  				&VDKTreeView::SetSearchColumn, &VDKTreeView::GetSearchColumn),
  SearchEqualFunc("SearchEqualFunc", this, ::SearchTVDefaultEqualFunc,
  					&VDKTreeView::SetSearchEqualFunc, &VDKTreeView::GetSearchEqualFunc),
  Model("Model",this, NULL, &VDKTreeView::SetModel, NULL),
  SelectedColumn("SelectedColumn", this, -1),
  ChangedColumn("ChangedColumn", this, -1),
  ChangedText("ChangedText", this, NULL)
{
  if(model)
    {
      widget = sigwid = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model->GtkModel()));
      Model(model);
    }
   else
       widget = sigwid = gtk_tree_view_new ();
  ConnectDefaultSignals();
  gtk_tree_selection_set_mode (GTK_TREE_SELECTION (gtk_tree_view_get_selection (GTK_TREE_VIEW (sigwid))),mode);
  //
  columns = new VDKTreeViewColumnList;
  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sigwid));
  switch(mode)
    {
    case GTK_SELECTION_SINGLE:
    case GTK_SELECTION_BROWSE:
      g_signal_connect_data(selection, "changed",
        G_CALLBACK (selection_cb), this,
        NULL,(GConnectFlags) 0);
      g_signal_connect_data (sigwid, "row_activated",
        G_CALLBACK (row_activated_cb), this,
        NULL,(GConnectFlags) 0);
      break;
    case GTK_SELECTION_MULTIPLE:
      g_signal_connect_data (sigwid, "row_activated", G_CALLBACK (row_activated_cb), this, NULL,(GConnectFlags) 0);
      break;
    case GTK_SELECTION_NONE:
      break;
    }
  SetSearchColumn(-1);
}
/*
 */
VDKTreeView::~VDKTreeView()
{
  VDKTreeViewModel *model = Model;
  if(model)
    delete model;
  delete columns;
}

/*
 */
void
VDKTreeView::SetModel(VDKTreeViewModel* mod)
{
  VDKTreeViewModel *old = Model;
  gtk_tree_view_set_model (GTK_TREE_VIEW(widget),GTK_TREE_MODEL (mod->GtkModel()));
  if(old)
    {
      delete old;
    }
}

/*
 */
void
VDKTreeView::SelectNode(GtkTreeIter* iter)
{
  if(iter)
    gtk_tree_selection_select_iter  (selection,iter);
}
/*
 */
void
VDKTreeView::UnselectNode(GtkTreeIter* iter)
{
  if(iter)
    gtk_tree_selection_unselect_iter  (selection,iter);
}
/*
 */
void
VDKTreeView::Expand(GtkTreeIter* iter, bool expand_all)
{
  if(!iter)
    gtk_tree_view_expand_all(GTK_TREE_VIEW(sigwid));
  else
    {
      VDKTreeViewModel *model = Model;
      GtkTreePath* path = gtk_tree_model_get_path (GTK_TREE_MODEL(model->GtkModel()),iter);
      if(path)
	{
	  gtk_tree_view_expand_row (GTK_TREE_VIEW(sigwid),path,expand_all);
	  gtk_tree_path_free(path);
	}
    }
}
/*
 */
void
VDKTreeView::RemoveSelected(void)
{
  GetSelections();
  VDKTreeViewModel* model = Model;
  VDKTreeViewIterListIterator li(Selections());
  for(li.last();li;li--)
    model->Remove(&li.current());
  Selections().flush();
}
/*
 */
void
VDKTreeView::SetSearchColumn(int colnum)
{
  if (colnum < -1) colnum = -1;
  if (colnum >= 0) SetActiveSearch(true);
  else SetActiveSearch(false);
  gtk_tree_view_set_search_column(GTK_TREE_VIEW(widget), colnum);
}

// This function is used for default interactive search
gboolean
SearchTVDefaultEqualFunc(GtkTreeModel *model, gint column, const gchar *key,
					GtkTreeIter *iter, gpointer search_data)
{
  gboolean result;

  VDKTreeViewModel tvmodel(model);
  char *local = tvmodel.GetCell(iter, column);
  if (!local) return true;
  result = (strstr(local, key) == NULL);
  delete[] local;
  return result;
}
/*
 */
void
VDKTreeView::SetSearchEqualFunc(GtkTreeViewSearchEqualFunc func)
{
  gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(widget), func, NULL, NULL);
}
/*
 */
void
VDKTreeView::SetBackground(VDKRgb rgb, GtkStateType state)
{
  VDKColor *color = new VDKColor(Owner(),rgb.red,rgb.green,rgb.blue);
  gtk_widget_modify_base (widget, state, color->Color());
}