[wxWidgets.git] / src / gtk1 / treectrl.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        treectrl.cpp
// Purpose:
// Author:      Denis Pershin
// Created:     07/05/98
// Id:          $Id$
// Copyright:   (c) 1998 Denis Pershin and Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "treectrl.h"
#endif

#include "wx/gtk/treectrl.h"
#include "wx/settings.h"
#include "wx/log.h"

#ifdef USE_GDK_IMLIB
#include "../gdk_imlib/gdk_imlib.h"
#endif

//-----------------------------------------------------------------------------
// wxTreeItem
//-----------------------------------------------------------------------------

// clicked

void gtk_treeitem_expand_callback(GtkWidget *WXUNUSED(widget), wxTreeItem *treeitem) {
  if (treeitem->ignore)
    return;
  treeitem->SendExpanding(treeitem->m_owner);
  treeitem->SendExpand(treeitem->m_owner);
};

void gtk_treeitem_collapse_callback( GtkWidget *WXUNUSED(widget), wxTreeItem *treeitem) {
  if (treeitem->ignore)
    return;
  treeitem->SendCollapsing(treeitem->m_owner);
  treeitem->SendCollapse(treeitem->m_owner);
};

void gtk_treeitem_select_callback( GtkWidget *WXUNUSED(widget), wxTreeItem *treeitem) {
  treeitem->SendSelChanging(treeitem->m_owner);
  treeitem->m_state |= wxTREE_STATE_SELECTED;
  treeitem->SendSelChanged(treeitem->m_owner);
}

void gtk_treeitem_deselect_callback( GtkWidget *WXUNUSED(widget), wxTreeItem *treeitem) {
  treeitem->SendSelChanging(treeitem->m_owner);
  treeitem->m_state &= !wxTREE_STATE_SELECTED;
  treeitem->SendSelChanged(treeitem->m_owner);
}

IMPLEMENT_DYNAMIC_CLASS(wxTreeItem, wxObject)

wxTreeItem::wxTreeItem() {
  m_mask = 0;
  m_itemId = 0;
  m_state = 0;
  m_stateMask = 0;
  m_image = -1;
  m_children = 0;
  m_selectedImage = -1;
  m_tree = NULL;
  m_parentwidget = NULL;
  m_widget = NULL;
  m_data = 0;
  m_owner = 0;
  expand_handler = 0;
  collapse_handler = 0;
};

wxTreeItem::wxTreeItem(GtkWidget *parent, const wxTreeItem &item) {
  m_mask = item.m_mask;
  m_text = item.m_text;
  m_itemId = item.m_itemId;
  m_state = item.m_state;
  m_stateMask = item.m_stateMask;
  m_image = item.m_image;
  m_tree = NULL;
  m_owner = 0;
  m_selectedImage = item.m_selectedImage;
  m_children = item.m_children;
  m_childlist = item.m_childlist;
  m_data = item.m_data;
  m_parentwidget = parent;
  expand_handler = 0;
  collapse_handler = 0;

  Create();
}

void wxTreeItem::Create() {
  wxASSERT(m_parentwidget != NULL);

  m_widget = GTK_TREE_ITEM(gtk_tree_item_new_with_label ((char *)(const char *)m_text));
  gtk_container_add (GTK_CONTAINER(m_parentwidget), GTK_WIDGET(m_widget));
  gtk_widget_show(GTK_WIDGET(m_widget));

  ignore  = FALSE;

  gtk_signal_connect(GTK_OBJECT(m_widget), "select",
      GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );

  gtk_signal_connect(GTK_OBJECT(m_widget), "deselect",
      GTK_SIGNAL_FUNC(gtk_treeitem_deselect_callback), (gpointer)this );

  if (expand_handler == 0)
    expand_handler = gtk_signal_connect(GTK_OBJECT(m_widget), "expand",
      GTK_SIGNAL_FUNC(gtk_treeitem_expand_callback), (gpointer)this );

  if (collapse_handler == 0)
    collapse_handler = gtk_signal_connect( GTK_OBJECT(m_widget), "collapse",
      GTK_SIGNAL_FUNC(gtk_treeitem_collapse_callback), (gpointer)this );

  if ((m_mask & wxTREE_MASK_CHILDREN) != 0)
    AddSubtree();
}

wxTreeItem::~wxTreeItem() {
  if (m_owner != NULL)
    SendDelete(m_owner);
  DeleteChildren();
  if ((m_widget != NULL) && (m_parentwidget != NULL))
    gtk_container_remove(GTK_CONTAINER(m_parentwidget),
                         GTK_WIDGET(m_widget));
//  if (m_tree != NULL) {
//    gtk_widget_destroy(GTK_WIDGET(m_tree));
//    m_tree = NULL;
//  }
    
//  if (m_widget != NULL)
//    gtk_widget_destroy(GTK_WIDGET(m_widget));
}

void wxTreeItem::AddSubtree() {
  if (m_widget == NULL)
    return;

  m_tree = GTK_TREE(gtk_tree_new());
  gtk_tree_item_set_subtree(GTK_TREE_ITEM(m_widget), GTK_WIDGET(m_tree));
  gtk_widget_show(GTK_WIDGET(m_tree));

  ignore = TRUE;
  gtk_tree_item_expand(m_widget);
  gtk_tree_item_collapse(m_widget);
  ignore  = FALSE;
}

void wxTreeItem::AddChild(wxTreeItem *child) {
  wxASSERT(child != NULL);

  m_childlist.Append(child);
}

bool wxTreeItem::HasChildren() {
  return (m_childlist.Number() != 0);
}

void wxTreeItem::DeleteChildren() {
  wxTreeItem *item;
  
  long no = GetChildrenNumber();
  for (long i=0; i<no; i++)
    if ((item = GetChild(i)) != 0)
      delete item;
  m_childlist.Clear();
  
  if ((no == 0) && (m_widget != NULL))
    gtk_tree_item_remove_subtree(m_widget);

  m_tree = NULL;
  
  if ((m_mask & wxTREE_MASK_CHILDREN) != 0)
    if (m_widget != NULL)
      if (m_widget->subtree == 0)
        AddSubtree();
}

int wxTreeItem::NumberOfVisibleDescendents() {
  wxTreeItem *item;
  long no = GetChildrenNumber();
  long num = 0;
  for (long i=0; i<no; i++)
    if ((item = GetChild(i)) != 0)
      num += item->NumberOfVisibleDescendents();
  
  num+=no;

  return num;
}

wxTreeItem *wxTreeItem::FindItem(long itemId) const {
  if (m_itemId == itemId) return (wxTreeItem*)(this);
  wxNode *node = m_childlist.First();
  while (node) {
    wxTreeItem *item = (wxTreeItem*)node->Data();
    wxTreeItem *res = item->FindItem( itemId );
    if (res) return (wxTreeItem*)(res);
    node = node->Next();
  };
  return NULL;
};

wxTreeItem *wxTreeItem::FindItem(GtkTreeItem *item) const {
  if (m_widget == item)
    return (wxTreeItem*)(this);
  wxNode *node = m_childlist.First();
  while (node) {
    wxTreeItem *i = (wxTreeItem*)node->Data();
    wxTreeItem *res = i->FindItem(item);
    if (res) return (wxTreeItem*)(res);
    node = node->Next();
  };
  return NULL;
};

void wxTreeItem::PrepareEvent(wxTreeEvent &event) {
  event.m_item.m_itemId = m_itemId;
  event.m_item.m_state = m_state;
  event.m_item.m_text = m_text;
  event.m_item.m_image = m_image;
  event.m_item.m_selectedImage = m_selectedImage;
  event.m_item.m_children = (GetChildrenNumber() > 0);
  event.m_item.m_data = m_data;
  event.m_oldItem = 0;
  event.m_code = 0;
//  event.m_pointDrag.x = 0;
//  event.m_pointDrag.y = 0;
};

void wxTreeItem::SendDelete(wxWindow *target) {
  wxTreeEvent event(wxEVT_COMMAND_TREE_DELETE_ITEM, target->GetId());
  PrepareEvent(event);
  event.SetEventObject(target);
  target->ProcessEvent(event);
};

void wxTreeItem::SendExpand(wxWindow *target) {
  wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_EXPANDED, target->GetId());
  PrepareEvent(event);
  event.SetEventObject(target);
  target->ProcessEvent(event);
};

void wxTreeItem::SendExpanding(wxWindow *target) {
  wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_EXPANDING, target->GetId());
  PrepareEvent(event);
  event.SetEventObject(target);
  target->ProcessEvent(event);
};

void wxTreeItem::SendCollapse(wxWindow *target) {
  wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSED, target->GetId());
  PrepareEvent(event);
  event.SetEventObject(target);
  target->ProcessEvent(event);
};

void wxTreeItem::SendCollapsing(wxWindow *target) {
  wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSING, target->GetId());
  PrepareEvent(event);
  event.SetEventObject(target);
  target->ProcessEvent(event);
};

void wxTreeItem::SendSelChanged(wxWindow *target) {
  wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGED, target->GetId());
  PrepareEvent(event);
  event.SetEventObject(target);
  target->ProcessEvent(event);
};

void wxTreeItem::SendSelChanging(wxWindow *target) {
  wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, target->GetId());
  PrepareEvent(event);
  event.SetEventObject(target);
  target->ProcessEvent(event);
};

//-----------------------------------------------------------------------------
// wxTreeCtrl
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxScrolledWindow)

wxTreeCtrl::wxTreeCtrl() {
  m_current = NULL;
  m_lastId = 0;
  m_isCreated = FALSE;
  m_imageList = NULL;
  m_smallImageList = NULL;
};

wxTreeCtrl::wxTreeCtrl(wxWindow *parent, wxWindowID id,
            const wxPoint& pos, const wxSize& size,
            long style, const wxString& name ) {
  m_current = NULL;
  m_lastId = 0;
  m_isCreated = FALSE;
  m_imageList = NULL;
  m_smallImageList = NULL;
  Create( parent, id, pos, size, style, name );
};

wxTreeCtrl::~wxTreeCtrl() {
  DeleteAllItems();
};

bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id,
            const wxPoint& pos, const wxSize& size,
            long style, const wxString& name ) {
  m_needParent = TRUE;
  
  PreCreation( parent, id, pos, size, style, name );
    
  m_widget = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_widget),
      GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	    
  m_tree = GTK_TREE(gtk_tree_new());
  
/*
  gtk_signal_connect( GTK_OBJECT(m_tree), "selection_changed",
      GTK_SIGNAL_FUNC(gtk_treectrl_selection_changed_callback), (gpointer)this);
  gtk_signal_connect( GTK_OBJECT(m_tree), "select_child",
      GTK_SIGNAL_FUNC(gtk_treectrl_select_child_callback), (gpointer)this);
  gtk_signal_connect( GTK_OBJECT(m_tree), "unselect_child",
      GTK_SIGNAL_FUNC(gtk_treectrl_unselect_child_callback), (gpointer)this);
*/

  gtk_container_add(GTK_CONTAINER(m_widget), GTK_WIDGET(m_tree));
  gtk_widget_show(GTK_WIDGET(m_tree));

  PostCreation();

  gtk_widget_realize(GTK_WIDGET(m_tree));
  
  Show(TRUE);

  return TRUE;
};

int wxTreeCtrl::GetCount() const
{
  if (!m_anchor) return 0;
  return m_anchor->NumberOfVisibleDescendents();
};

long wxTreeCtrl::InsertItem(long parent, const wxString& label,
      int image, int selImage, long insertAfter) {
  wxTreeItem item;
  if (!label.IsNull() || (label == "")) {
    item.m_text = label;
    item.m_mask |= wxTREE_MASK_TEXT;
  };

  if (image >= 0) {
    item.m_image = image;
    item.m_mask |= wxTREE_MASK_IMAGE;
  };

  if (selImage >= 0) {
    item.m_selectedImage = selImage;
    item.m_mask |= wxTREE_MASK_SELECTED_IMAGE;
  };

  return InsertItem(parent, item, insertAfter);
};

long wxTreeCtrl::InsertItem( long parent, wxTreeItem &info, long WXUNUSED(insertAfter) ) {
  int oldMask = info.m_mask;
  long ret = 0;
  wxTreeItem *p = NULL;
  wxTreeItem *new_child;

  if (parent == 0) {
    if (m_anchor)
      return -1;
  } else {
    p = FindItem(parent);
    if (!p) return -1;
  };

  if ((info.m_mask & wxTREE_MASK_HANDLE) == 0) {
    m_lastId++;
    info.m_itemId = m_lastId;
    info.m_mask |= wxTREE_MASK_HANDLE;
    ret = m_lastId;
  } else
    ret = info.m_itemId;

  if (p) {
    if (p->m_tree == NULL)
      p->AddSubtree();
  
    new_child = new wxTreeItem(GTK_WIDGET(p->m_tree), info);
    p->AddChild(new_child);
gtk_widget_draw_default(GTK_WIDGET(m_tree));
  } else {
    new_child = new wxTreeItem(GTK_WIDGET(m_tree), info);
    m_anchor = new_child;
  }

/* Disabled until wxImageList q solved  >>> seems it solved */
/*
  wxBitmap *bmp;
  if ((new_child->m_mask & wxTREE_MASK_IMAGE) != 0) {
    if (m_imageList != NULL) {
//      if ((bmp = m_imageList->GetBitmap(new_child->m_image)) != NULL) {
      if ((bmp = m_imageList->GetBitmap(0)) != NULL) {
        if (bmp->Ok()) {
          GdkBitmap *mask = NULL;
          if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
          GtkWidget *pixmap = gtk_pixmap_new(bmp->GetPixmap(), mask);

gtk_widget_unref(new_child->m_widget->plus_pix_widget);
gtk_container_remove(GTK_CONTAINER(new_child->m_widget->pixmaps_box),
                     new_child->m_widget->plus_pix_widget);
gtk_container_add(GTK_CONTAINER(new_child->m_widget->pixmaps_box),
                  pixmap);
          gtk_widget_show(pixmap);
          GTK_TREE_ITEM(new_child->m_widget)->plus_pix_widget = pixmap;
        }
      }

      if ((bmp = m_imageList->GetBitmap(1)) != NULL) {
        if (bmp->Ok()) {
          GdkBitmap *mask = NULL;
          if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
          GtkWidget *pixmap = gtk_pixmap_new(bmp->GetPixmap(), mask);

gtk_widget_unref(new_child->m_widget->minus_pix_widget);
//gtk_container_remove(GTK_CONTAINER(new_child->m_widget->pixmaps_box),
//                     new_child->m_widget->plus_pix_widget);
//gtk_container_add(GTK_CONTAINER(new_child->m_widget->pixmaps_box),
//                  pixmap);
          gtk_widget_show(pixmap);
          GTK_TREE_ITEM(new_child->m_widget)->minus_pix_widget = pixmap;
        }
      }
    }
  }
*/

  new_child->m_owner = this;

  info.m_mask = oldMask;
  return ret;
};


bool wxTreeCtrl::ExpandItem( long item, int action ) {
  wxTreeItem *i = FindItem( item );
  if (!i)
    return FALSE;

  switch (action) {
    case wxTREE_EXPAND_EXPAND:
      gtk_tree_item_expand(GTK_TREE_ITEM(i->m_widget));
      break;

    case wxTREE_EXPAND_COLLAPSE_RESET:
    case wxTREE_EXPAND_COLLAPSE:
      gtk_tree_item_collapse(GTK_TREE_ITEM(i->m_widget));
      break;

    case wxTREE_EXPAND_TOGGLE:
      if ((i->GetState() & wxTREE_STATE_EXPANDED) == 0)
        gtk_tree_item_expand(GTK_TREE_ITEM(i->m_widget));
      else
        gtk_tree_item_collapse(GTK_TREE_ITEM(i->m_widget));
      break;
  }

  return TRUE;
};

void wxTreeCtrl::DeleteItem( long item )
{
  wxTreeItem *pItem = FindItem( item );
  wxCHECK_RET( pItem != NULL, "wxTreeCtrl::DeleteItem: no such pItem." );

//  pItem->m_parent->m_childlist.DeleteObject(pItem);
}

void wxTreeCtrl::DeleteChildren( long item )
{
  wxTreeItem *pItem = FindItem( item );
  wxCHECK_RET( pItem != NULL, "wxTreeCtrl::DeleteChildren: no such pItem." );

  pItem->DeleteChildren();
}

bool wxTreeCtrl::DeleteAllItems()
{
  delete m_anchor;
  m_anchor = NULL;
  return TRUE;
};

/*
bool wxTreeCtrl::GetItem( wxTreeItem &info ) const
{
  wxTreeItem *i = FindItem( info.m_itemId );
  if (!i) return FALSE;
  i->GetItem( info );
  return TRUE;
};
*/

long wxTreeCtrl::GetItemData( long item ) const
{
  wxTreeItem *i = FindItem( item );
  if (!i) return 0;
  return i->m_data;
};

wxString wxTreeCtrl::GetItemText( long item ) const
{
  wxTreeItem *i = FindItem( item );
  if (!i) return "";
  return i->m_text;
};

int wxTreeCtrl::GetItemImage(long item) const
{
  wxTreeItem *i = FindItem( item );
  return i == 0 ? -1 : i->GetImage();
}

long wxTreeCtrl::GetParent( long item ) const
{
  wxTreeItem *i = FindItem( item );
  if (!i) return -1;
/*
  i = i->m_parent;
  if (!i) return -1;
  return i->m_parent->m_itemId;
*/
  return -1;
};

long wxTreeCtrl::GetRootItem() const
{
  if (m_anchor) return m_anchor->m_itemId;
  return -1;
};

/*
long wxTreeCtrl::GetSelection() const
{
  return m_current ? m_current->GetItemId() : -1;
};

bool wxTreeCtrl::SelectItem(long itemId)
{
  wxTreeItem *pItem = FindItem(itemId);
  if ( !pItem ) {
    wxLogDebug("Can't select an item %d which doesn't exist.", itemId);

    return FALSE;
  }

  SelectItem(pItem);

  return TRUE;
};

void wxTreeCtrl::SelectItem(wxTreeItem *item, bool bDoEvents )
{
  if (m_current != item)
  {
    if (m_current)
    {
      m_current->SetHilight( FALSE );
//      RefreshLine( m_current );
    };
    m_current = item;
    m_current->SetHilight( TRUE );
//    RefreshLine( m_current );

    if (bDoEvents) m_current->SendSelected( this );
  }
}
*/

bool wxTreeCtrl::ItemHasChildren( long item ) const
{
  wxTreeItem *i = FindItem( item );
  if (!i) return FALSE;
  return i->HasChildren();
};

void wxTreeCtrl::SetIndent( int indent )
{
  m_indent = indent;
  Refresh();
};

int wxTreeCtrl::GetIndent() const
{
  return m_indent;
};

/*
bool wxTreeCtrl::SetItem( wxTreeItem &info )
{
  wxTreeItem *i = FindItem( info.m_itemId );
  if (!i) return FALSE;
  wxClientDC dc(this);
  i->SetItem( info, &dc );
  Refresh();
  return TRUE;
};

bool wxTreeCtrl::SetItemData( long item, long data )
{
  wxTreeItem *i = FindItem( item );
  if (!i) return FALSE;
  i->m_data = data;
  return TRUE;
};

bool wxTreeCtrl::SetItemText( long item, const wxString &text )
{
  wxTreeItem *i = FindItem( item );
  if (!i) return FALSE;
  wxClientDC dc(this);
  i->SetText( text, &dc );
  return TRUE;
};

void wxTreeCtrl::SetItemImage(long item, int image, int imageSel) const
{
  wxTreeItem *i = FindItem( item );
  if ( i != 0 ) {
    i->SetImage(image);
    i->SetSelectedImage(imageSel);
  }
}

long wxTreeCtrl::HitTest( const wxPoint& point, int &flags )
{
  flags = 0;
  if (!m_anchor) return -1;
  return m_anchor->HitTest( point, flags );
};
*/

wxImageList *wxTreeCtrl::GetImageList( int which ) const
{
  if (which == wxIMAGE_LIST_NORMAL) return m_imageList;
  return m_smallImageList;
};

void wxTreeCtrl::SetImageList( wxImageList *imageList, int which )
{
  if (which == wxIMAGE_LIST_NORMAL)
  {
    if (m_imageList) delete m_imageList;
    m_imageList = imageList;
  }
  else
  {
    if (m_smallImageList) delete m_smallImageList;
    m_smallImageList = imageList;
  };
};

wxTreeItem *wxTreeCtrl::FindItem( long itemId ) const {
  if (!m_anchor) return NULL;
  return m_anchor->FindItem( itemId );
  return 0;
};

wxTreeItem *wxTreeCtrl::FindItem(GtkTreeItem *item) const {
  if (!m_anchor) return NULL;
  return m_anchor->FindItem(item);
  return 0;
};

//-----------------------------------------------------------------------------
// wxTreeEvent
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent,wxCommandEvent)

wxTreeEvent::wxTreeEvent( wxEventType commandType, int id ) :
  wxCommandEvent( commandType, id )
{
  m_code = 0;
  m_oldItem = 0;
};

/* Bunch of old code might be useful */
/*
  wxBitmap *bmp;

  if ((bmp = m_imageList->GetItem(0))->Ok()) {
    GdkBitmap *mask = NULL;
    if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
    GtkWidget *pixmap = gtk_pixmap_new( bmp->GetPixmap(), mask );

    gtk_widget_set_parent(pixmap, GTK_WIDGET(new_child->m_widget));
    gtk_widget_show(pixmap);
    GTK_TREE_ITEM(new_child->m_widget)->pixmaps_box = pixmap;
  }

  if ((bmp = m_imageList->GetItem(1))->Ok()) {
    GdkBitmap *mask = NULL;
    if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
    GtkWidget *pixmap = gtk_pixmap_new( bmp->GetPixmap(), mask );

    gtk_widget_set_parent(pixmap, GTK_WIDGET(new_child->m_widget));
    gtk_widget_show(pixmap);
    GTK_TREE_ITEM(new_child->m_widget)->plus_pix_widget = pixmap;
  }

  if ((bmp = m_imageList->GetItem(2))->Ok()) {
    GdkBitmap *mask = NULL;
    if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
    GtkWidget *pixmap = gtk_pixmap_new( bmp->GetPixmap(), mask );

    gtk_widget_set_parent(pixmap, GTK_WIDGET(new_child->m_widget));
    gtk_widget_show(pixmap);
    GTK_TREE_ITEM(new_child->m_widget)->minus_pix_widget = pixmap;
  }

  if (p)
    if (p->m_childlist.Number() == 1) {
      gtk_tree_item_collapse(GTK_TREE_ITEM(p->m_widget));
      gtk_tree_item_expand(GTK_TREE_ITEM(p->m_widget));
    }
*/
Commit	Line	Data
f4e325b3 DP	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: treectrl.cpp
	3	// Purpose:
	4	// Author: Denis Pershin
	5	// Created: 07/05/98
	6	// Id: $Id$
	7	// Copyright: (c) 1998 Denis Pershin and Julian Smart
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	#ifdef __GNUG__
e8cd8b1b	12	#pragma implementation "treectrl.h"
f4e325b3 DP	13	#endif
	14
	15	#include "wx/gtk/treectrl.h"
	16	#include "wx/settings.h"
	17	#include "wx/log.h"
	18
	19	#ifdef USE_GDK_IMLIB
	20	#include "../gdk_imlib/gdk_imlib.h"
	21	#endif
	22
	23	//-----------------------------------------------------------------------------
	24	// wxTreeItem
	25	//-----------------------------------------------------------------------------
	26
	27	// clicked
	28
	29	void gtk_treeitem_expand_callback(GtkWidget WXUNUSED(widget), wxTreeItem treeitem) {
befe54c6 DP	30	if (treeitem->ignore)
befe54c6 DP	31	return;
f4e325b3 DP	32	treeitem->SendExpanding(treeitem->m_owner);
	33	treeitem->SendExpand(treeitem->m_owner);
	34	};
	35
	36	void gtk_treeitem_collapse_callback( GtkWidget WXUNUSED(widget), wxTreeItem treeitem) {
befe54c6 DP	37	if (treeitem->ignore)
befe54c6 DP	38	return;
f4e325b3 DP	39	treeitem->SendCollapsing(treeitem->m_owner);
	40	treeitem->SendCollapse(treeitem->m_owner);
	41	};
	42
	43	void gtk_treeitem_select_callback( GtkWidget WXUNUSED(widget), wxTreeItem treeitem) {
	44	treeitem->SendSelChanging(treeitem->m_owner);
	45	treeitem->m_state \|= wxTREE_STATE_SELECTED;
	46	treeitem->SendSelChanged(treeitem->m_owner);
	47	}
	48
	49	void gtk_treeitem_deselect_callback( GtkWidget WXUNUSED(widget), wxTreeItem treeitem) {
	50	treeitem->SendSelChanging(treeitem->m_owner);
	51	treeitem->m_state &= !wxTREE_STATE_SELECTED;
	52	treeitem->SendSelChanged(treeitem->m_owner);
	53	}
	54
	55	IMPLEMENT_DYNAMIC_CLASS(wxTreeItem, wxObject)
	56
	57	wxTreeItem::wxTreeItem() {
	58	m_mask = 0;
	59	m_itemId = 0;
	60	m_state = 0;
	61	m_stateMask = 0;
	62	m_image = -1;
	63	m_children = 0;
	64	m_selectedImage = -1;
	65	m_tree = NULL;
	66	m_parentwidget = NULL;
	67	m_widget = NULL;
	68	m_data = 0;
	69	m_owner = 0;
	70	expand_handler = 0;
	71	collapse_handler = 0;
	72	};
	73
	74	wxTreeItem::wxTreeItem(GtkWidget *parent, const wxTreeItem &item) {
	75	m_mask = item.m_mask;
	76	m_text = item.m_text;
	77	m_itemId = item.m_itemId;
	78	m_state = item.m_state;
	79	m_stateMask = item.m_stateMask;
	80	m_image = item.m_image;
	81	m_tree = NULL;
	82	m_owner = 0;
	83	m_selectedImage = item.m_selectedImage;
	84	m_children = item.m_children;
	85	m_childlist = item.m_childlist;
	86	m_data = item.m_data;
	87	m_parentwidget = parent;
	88	expand_handler = 0;
	89	collapse_handler = 0;
	90
	91	Create();
	92	}
	93
	94	void wxTreeItem::Create() {
	95	wxASSERT(m_parentwidget != NULL);
	96
	97	m_widget = GTK_TREE_ITEM(gtk_tree_item_new_with_label ((char )(const char )m_text));
	98	gtk_container_add (GTK_CONTAINER(m_parentwidget), GTK_WIDGET(m_widget));
	99	gtk_widget_show(GTK_WIDGET(m_widget));
	100
befe54c6 DP	101	ignore = FALSE;
befe54c6 DP	102
f4e325b3 DP	103	gtk_signal_connect(GTK_OBJECT(m_widget), "select",
	104	GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );
	105
	106	gtk_signal_connect(GTK_OBJECT(m_widget), "deselect",
	107	GTK_SIGNAL_FUNC(gtk_treeitem_deselect_callback), (gpointer)this );
	108
befe54c6 DP	109	if (expand_handler == 0)
	110	expand_handler = gtk_signal_connect(GTK_OBJECT(m_widget), "expand",
	111	GTK_SIGNAL_FUNC(gtk_treeitem_expand_callback), (gpointer)this );
	112
	113	if (collapse_handler == 0)
	114	collapse_handler = gtk_signal_connect( GTK_OBJECT(m_widget), "collapse",
	115	GTK_SIGNAL_FUNC(gtk_treeitem_collapse_callback), (gpointer)this );
	116
f4e325b3 DP	117	if ((m_mask & wxTREE_MASK_CHILDREN) != 0)
	118	AddSubtree();
	119	}
	120
	121	wxTreeItem::~wxTreeItem() {
	122	if (m_owner != NULL)
	123	SendDelete(m_owner);
	124	DeleteChildren();
	125	if ((m_widget != NULL) && (m_parentwidget != NULL))
	126	gtk_container_remove(GTK_CONTAINER(m_parentwidget),
	127	GTK_WIDGET(m_widget));
	128	// if (m_tree != NULL) {
	129	// gtk_widget_destroy(GTK_WIDGET(m_tree));
	130	// m_tree = NULL;
	131	// }
	132
	133	// if (m_widget != NULL)
	134	// gtk_widget_destroy(GTK_WIDGET(m_widget));
	135	}
	136
	137	void wxTreeItem::AddSubtree() {
	138	if (m_widget == NULL)
	139	return;
	140
	141	m_tree = GTK_TREE(gtk_tree_new());
f4e325b3 DP	142	gtk_tree_item_set_subtree(GTK_TREE_ITEM(m_widget), GTK_WIDGET(m_tree));
f4e325b3 DP	143	gtk_widget_show(GTK_WIDGET(m_tree));
befe54c6 DP	144
	145	ignore = TRUE;
	146	gtk_tree_item_expand(m_widget);
	147	gtk_tree_item_collapse(m_widget);
	148	ignore = FALSE;
f4e325b3 DP	149	}
	150
	151	void wxTreeItem::AddChild(wxTreeItem *child) {
	152	wxASSERT(child != NULL);
	153
	154	m_childlist.Append(child);
	155	}
	156
	157	bool wxTreeItem::HasChildren() {
	158	return (m_childlist.Number() != 0);
	159	}
	160
	161	void wxTreeItem::DeleteChildren() {
	162	wxTreeItem *item;
befe54c6	163
f4e325b3 DP	164	long no = GetChildrenNumber();
	165	for (long i=0; i<no; i++)
	166	if ((item = GetChild(i)) != 0)
	167	delete item;
	168	m_childlist.Clear();
befe54c6 DP	169
	170	if ((no == 0) && (m_widget != NULL))
	171	gtk_tree_item_remove_subtree(m_widget);
	172
f4e325b3 DP	173	m_tree = NULL;
	174
	175	if ((m_mask & wxTREE_MASK_CHILDREN) != 0)
	176	if (m_widget != NULL)
	177	if (m_widget->subtree == 0)
	178	AddSubtree();
	179	}
	180
	181	int wxTreeItem::NumberOfVisibleDescendents() {
	182	wxTreeItem *item;
	183	long no = GetChildrenNumber();
	184	long num = 0;
	185	for (long i=0; i<no; i++)
	186	if ((item = GetChild(i)) != 0)
	187	num += item->NumberOfVisibleDescendents();
	188
	189	num+=no;
	190
	191	return num;
	192	}
	193
	194	wxTreeItem *wxTreeItem::FindItem(long itemId) const {
	195	if (m_itemId == itemId) return (wxTreeItem*)(this);
	196	wxNode *node = m_childlist.First();
	197	while (node) {
	198	wxTreeItem item = (wxTreeItem)node->Data();
	199	wxTreeItem *res = item->FindItem( itemId );
	200	if (res) return (wxTreeItem*)(res);
	201	node = node->Next();
	202	};
	203	return NULL;
	204	};
	205
	206	wxTreeItem wxTreeItem::FindItem(GtkTreeItem item) const {
	207	if (m_widget == item)
	208	return (wxTreeItem*)(this);
	209	wxNode *node = m_childlist.First();
	210	while (node) {
	211	wxTreeItem i = (wxTreeItem)node->Data();
	212	wxTreeItem *res = i->FindItem(item);
	213	if (res) return (wxTreeItem*)(res);
	214	node = node->Next();
	215	};
	216	return NULL;
	217	};
	218
	219	void wxTreeItem::PrepareEvent(wxTreeEvent &event) {
	220	event.m_item.m_itemId = m_itemId;
	221	event.m_item.m_state = m_state;
	222	event.m_item.m_text = m_text;
	223	event.m_item.m_image = m_image;
	224	event.m_item.m_selectedImage = m_selectedImage;
	225	event.m_item.m_children = (GetChildrenNumber() > 0);
	226	event.m_item.m_data = m_data;
	227	event.m_oldItem = 0;
	228	event.m_code = 0;
	229	// event.m_pointDrag.x = 0;
	230	// event.m_pointDrag.y = 0;
	231	};
	232
	233	void wxTreeItem::SendDelete(wxWindow *target) {
	234	wxTreeEvent event(wxEVT_COMMAND_TREE_DELETE_ITEM, target->GetId());
	235	PrepareEvent(event);
	236	event.SetEventObject(target);
237	target->ProcessEvent(event);
238	};
239
240	void wxTreeItem::SendExpand(wxWindow *target) {
241	wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_EXPANDED, target->GetId());
242	PrepareEvent(event);
243	event.SetEventObject(target);
244	target->ProcessEvent(event);
245	};
246
247	void wxTreeItem::SendExpanding(wxWindow *target) {
248	wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_EXPANDING, target->GetId());
249	PrepareEvent(event);
250	event.SetEventObject(target);
251	target->ProcessEvent(event);
252	};
253
254	void wxTreeItem::SendCollapse(wxWindow *target) {
255	wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSED, target->GetId());
256	PrepareEvent(event);
257	event.SetEventObject(target);
258	target->ProcessEvent(event);
259	};
260
261	void wxTreeItem::SendCollapsing(wxWindow *target) {
262	wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSING, target->GetId());
263	PrepareEvent(event);
264	event.SetEventObject(target);
265	target->ProcessEvent(event);
266	};
267
268	void wxTreeItem::SendSelChanged(wxWindow *target) {
269	wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGED, target->GetId());
270	PrepareEvent(event);
271	event.SetEventObject(target);
272	target->ProcessEvent(event);
273	};
274
275	void wxTreeItem::SendSelChanging(wxWindow *target) {
276	wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, target->GetId());
277	PrepareEvent(event);
278	event.SetEventObject(target);
279	target->ProcessEvent(event);
280	};
281
282	//-----------------------------------------------------------------------------
283	// wxTreeCtrl
284	//-----------------------------------------------------------------------------
285
286	IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxScrolledWindow)
287
288	wxTreeCtrl::wxTreeCtrl() {
289	m_current = NULL;
290	m_lastId = 0;
291	m_isCreated = FALSE;
292	m_imageList = NULL;
293	m_smallImageList = NULL;
294	};
295
296	wxTreeCtrl::wxTreeCtrl(wxWindow *parent, wxWindowID id,
297	const wxPoint& pos, const wxSize& size,
298	long style, const wxString& name ) {
299	m_current = NULL;
300	m_lastId = 0;
301	m_isCreated = FALSE;
302	m_imageList = NULL;
303	m_smallImageList = NULL;
304	Create( parent, id, pos, size, style, name );
305	};
306
307	wxTreeCtrl::~wxTreeCtrl() {
308	DeleteAllItems();
309	};
310
311	bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id,
312	const wxPoint& pos, const wxSize& size,
313	long style, const wxString& name ) {
314	m_needParent = TRUE;
315
316	PreCreation( parent, id, pos, size, style, name );
317
318	m_widget = gtk_scrolled_window_new(NULL, NULL);
319	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_widget),
320	GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
321
322	m_tree = GTK_TREE(gtk_tree_new());
323
324	/*
325	gtk_signal_connect( GTK_OBJECT(m_tree), "selection_changed",
326	GTK_SIGNAL_FUNC(gtk_treectrl_selection_changed_callback), (gpointer)this);
327	gtk_signal_connect( GTK_OBJECT(m_tree), "select_child",
328	GTK_SIGNAL_FUNC(gtk_treectrl_select_child_callback), (gpointer)this);
329	gtk_signal_connect( GTK_OBJECT(m_tree), "unselect_child",
330	GTK_SIGNAL_FUNC(gtk_treectrl_unselect_child_callback), (gpointer)this);
331	*/
332
333	gtk_container_add(GTK_CONTAINER(m_widget), GTK_WIDGET(m_tree));
334	gtk_widget_show(GTK_WIDGET(m_tree));
335
336	PostCreation();
337
338	gtk_widget_realize(GTK_WIDGET(m_tree));
339
340	Show(TRUE);
341
342	return TRUE;
343	};
344
345	int wxTreeCtrl::GetCount() const
346	{
347	if (!m_anchor) return 0;
348	return m_anchor->NumberOfVisibleDescendents();
349	};
350
befe54c6	351	long wxTreeCtrl::InsertItem(long parent, const wxString& label,
f4e325b3 DP	352	int image, int selImage, long insertAfter) {
f4e325b3 DP	353	wxTreeItem item;
f4e325b3 DP	354	if (!label.IsNull() \|\| (label == "")) {
	355	item.m_text = label;
	356	item.m_mask \|= wxTREE_MASK_TEXT;
	357	};
	358
	359	if (image >= 0) {
	360	item.m_image = image;
	361	item.m_mask \|= wxTREE_MASK_IMAGE;
	362	};
	363
	364	if (selImage >= 0) {
	365	item.m_selectedImage = selImage;
	366	item.m_mask \|= wxTREE_MASK_SELECTED_IMAGE;
	367	};
	368
	369	return InsertItem(parent, item, insertAfter);
	370	};
	371
	372	long wxTreeCtrl::InsertItem( long parent, wxTreeItem &info, long WXUNUSED(insertAfter) ) {
	373	int oldMask = info.m_mask;
	374	long ret = 0;
	375	wxTreeItem *p = NULL;
	376	wxTreeItem *new_child;
	377
	378	if (parent == 0) {
	379	if (m_anchor)
	380	return -1;
	381	} else {
	382	p = FindItem(parent);
	383	if (!p) return -1;
	384	};
	385
	386	if ((info.m_mask & wxTREE_MASK_HANDLE) == 0) {
	387	m_lastId++;
	388	info.m_itemId = m_lastId;
	389	info.m_mask \|= wxTREE_MASK_HANDLE;
	390	ret = m_lastId;
	391	} else
	392	ret = info.m_itemId;
	393
	394	if (p) {
	395	if (p->m_tree == NULL)
	396	p->AddSubtree();
	397
	398	new_child = new wxTreeItem(GTK_WIDGET(p->m_tree), info);
	399	p->AddChild(new_child);
befe54c6	400	gtk_widget_draw_default(GTK_WIDGET(m_tree));
f4e325b3 DP	401	} else {
	402	new_child = new wxTreeItem(GTK_WIDGET(m_tree), info);
	403	m_anchor = new_child;
	404	}
	405
befe54c6 DP	406	/* Disabled until wxImageList q solved >>> seems it solved */
	407	/*
	408	wxBitmap *bmp;
	409	if ((new_child->m_mask & wxTREE_MASK_IMAGE) != 0) {
	410	if (m_imageList != NULL) {
	411	// if ((bmp = m_imageList->GetBitmap(new_child->m_image)) != NULL) {
	412	if ((bmp = m_imageList->GetBitmap(0)) != NULL) {
	413	if (bmp->Ok()) {
	414	GdkBitmap *mask = NULL;
	415	if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
	416	GtkWidget *pixmap = gtk_pixmap_new(bmp->GetPixmap(), mask);
	417
	418	gtk_widget_unref(new_child->m_widget->plus_pix_widget);
	419	gtk_container_remove(GTK_CONTAINER(new_child->m_widget->pixmaps_box),
	420	new_child->m_widget->plus_pix_widget);
	421	gtk_container_add(GTK_CONTAINER(new_child->m_widget->pixmaps_box),
	422	pixmap);
	423	gtk_widget_show(pixmap);
	424	GTK_TREE_ITEM(new_child->m_widget)->plus_pix_widget = pixmap;
	425	}
	426	}
	427
	428	if ((bmp = m_imageList->GetBitmap(1)) != NULL) {
	429	if (bmp->Ok()) {
	430	GdkBitmap *mask = NULL;
	431	if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
	432	GtkWidget *pixmap = gtk_pixmap_new(bmp->GetPixmap(), mask);
	433
	434	gtk_widget_unref(new_child->m_widget->minus_pix_widget);
	435	//gtk_container_remove(GTK_CONTAINER(new_child->m_widget->pixmaps_box),
	436	// new_child->m_widget->plus_pix_widget);
	437	//gtk_container_add(GTK_CONTAINER(new_child->m_widget->pixmaps_box),
	438	// pixmap);
	439	gtk_widget_show(pixmap);
	440	GTK_TREE_ITEM(new_child->m_widget)->minus_pix_widget = pixmap;
	441	}
	442	}
f4e325b3 DP	443	}
	444	}
	445	*/
	446
	447	new_child->m_owner = this;
	448
	449	info.m_mask = oldMask;
	450	return ret;
	451	};
	452
	453
	454	bool wxTreeCtrl::ExpandItem( long item, int action ) {
	455	wxTreeItem *i = FindItem( item );
	456	if (!i)
	457	return FALSE;
	458
	459	switch (action) {
	460	case wxTREE_EXPAND_EXPAND:
	461	gtk_tree_item_expand(GTK_TREE_ITEM(i->m_widget));
	462	break;
	463
	464	case wxTREE_EXPAND_COLLAPSE_RESET:
	465	case wxTREE_EXPAND_COLLAPSE:
	466	gtk_tree_item_collapse(GTK_TREE_ITEM(i->m_widget));
	467	break;
	468
	469	case wxTREE_EXPAND_TOGGLE:
	470	if ((i->GetState() & wxTREE_STATE_EXPANDED) == 0)
	471	gtk_tree_item_expand(GTK_TREE_ITEM(i->m_widget));
	472	else
	473	gtk_tree_item_collapse(GTK_TREE_ITEM(i->m_widget));
	474	break;
	475	}
	476
	477	return TRUE;
	478	};
	479
	480	void wxTreeCtrl::DeleteItem( long item )
	481	{
	482	wxTreeItem *pItem = FindItem( item );
	483	wxCHECK_RET( pItem != NULL, "wxTreeCtrl::DeleteItem: no such pItem." );
	484
	485	// pItem->m_parent->m_childlist.DeleteObject(pItem);
	486	}
	487
	488	void wxTreeCtrl::DeleteChildren( long item )
	489	{
	490	wxTreeItem *pItem = FindItem( item );
	491	wxCHECK_RET( pItem != NULL, "wxTreeCtrl::DeleteChildren: no such pItem." );
	492
	493	pItem->DeleteChildren();
	494	}
	495
	496	bool wxTreeCtrl::DeleteAllItems()
	497	{
	498	delete m_anchor;
	499	m_anchor = NULL;
	500	return TRUE;
	501	};
	502
	503	/*
	504	bool wxTreeCtrl::GetItem( wxTreeItem &info ) const
	505	{
	506	wxTreeItem *i = FindItem( info.m_itemId );
507	if (!i) return FALSE;
508	i->GetItem( info );
509	return TRUE;
510	};
511	*/
512
513	long wxTreeCtrl::GetItemData( long item ) const
514	{
515	wxTreeItem *i = FindItem( item );
516	if (!i) return 0;
517	return i->m_data;
518	};
519
520	wxString wxTreeCtrl::GetItemText( long item ) const
521	{
522	wxTreeItem *i = FindItem( item );
523	if (!i) return "";
524	return i->m_text;
525	};
526
527	int wxTreeCtrl::GetItemImage(long item) const
528	{
529	wxTreeItem *i = FindItem( item );
530	return i == 0 ? -1 : i->GetImage();
531	}
532
533	long wxTreeCtrl::GetParent( long item ) const
534	{
535	wxTreeItem *i = FindItem( item );
536	if (!i) return -1;
537	/*
538	i = i->m_parent;
539	if (!i) return -1;
540	return i->m_parent->m_itemId;
541	*/
542	return -1;
543	};
544
545	long wxTreeCtrl::GetRootItem() const
546	{
547	if (m_anchor) return m_anchor->m_itemId;
548	return -1;
549	};
550
551	/*
552	long wxTreeCtrl::GetSelection() const
553	{
554	return m_current ? m_current->GetItemId() : -1;
555	};
556
557	bool wxTreeCtrl::SelectItem(long itemId)
558	{
559	wxTreeItem *pItem = FindItem(itemId);
560	if ( !pItem ) {
561	wxLogDebug("Can't select an item %d which doesn't exist.", itemId);
562
563	return FALSE;
564	}
565
566	SelectItem(pItem);
567
568	return TRUE;
569	};
570
571	void wxTreeCtrl::SelectItem(wxTreeItem *item, bool bDoEvents )
572	{
573	if (m_current != item)
574	{
575	if (m_current)
576	{
577	m_current->SetHilight( FALSE );
578	// RefreshLine( m_current );
579	};
580	m_current = item;
581	m_current->SetHilight( TRUE );
582	// RefreshLine( m_current );
583
584	if (bDoEvents) m_current->SendSelected( this );
585	}
586	}
587	*/
588
589	bool wxTreeCtrl::ItemHasChildren( long item ) const
590	{
591	wxTreeItem *i = FindItem( item );
592	if (!i) return FALSE;
593	return i->HasChildren();
594	};
595
596	void wxTreeCtrl::SetIndent( int indent )
597	{
598	m_indent = indent;
599	Refresh();
600	};
601
602	int wxTreeCtrl::GetIndent() const
603	{
604	return m_indent;
605	};
606
607	/*
608	bool wxTreeCtrl::SetItem( wxTreeItem &info )
609	{
610	wxTreeItem *i = FindItem( info.m_itemId );
611	if (!i) return FALSE;
612	wxClientDC dc(this);
613	i->SetItem( info, &dc );
614	Refresh();
615	return TRUE;
616	};
617
618	bool wxTreeCtrl::SetItemData( long item, long data )
619	{
620	wxTreeItem *i = FindItem( item );
621	if (!i) return FALSE;
622	i->m_data = data;
623	return TRUE;
624	};
625
626	bool wxTreeCtrl::SetItemText( long item, const wxString &text )
627	{
628	wxTreeItem *i = FindItem( item );
629	if (!i) return FALSE;
630	wxClientDC dc(this);
631	i->SetText( text, &dc );
632	return TRUE;
633	};
634
635	void wxTreeCtrl::SetItemImage(long item, int image, int imageSel) const
636	{
637	wxTreeItem *i = FindItem( item );
638	if ( i != 0 ) {
639	i->SetImage(image);
640	i->SetSelectedImage(imageSel);
641	}
642	}
643
644	long wxTreeCtrl::HitTest( const wxPoint& point, int &flags )
645	{
646	flags = 0;
647	if (!m_anchor) return -1;
648	return m_anchor->HitTest( point, flags );
649	};
650	*/
651
652	wxImageList *wxTreeCtrl::GetImageList( int which ) const
653	{
654	if (which == wxIMAGE_LIST_NORMAL) return m_imageList;
655	return m_smallImageList;
656	};
657
658	void wxTreeCtrl::SetImageList( wxImageList *imageList, int which )
659	{
660	if (which == wxIMAGE_LIST_NORMAL)
661	{
662	if (m_imageList) delete m_imageList;
663	m_imageList = imageList;
664	}
665	else
666	{
667	if (m_smallImageList) delete m_smallImageList;
668	m_smallImageList = imageList;
669	};
670	};
671
672	wxTreeItem *wxTreeCtrl::FindItem( long itemId ) const {
673	if (!m_anchor) return NULL;
674	return m_anchor->FindItem( itemId );
675	return 0;
676	};
677
678	wxTreeItem wxTreeCtrl::FindItem(GtkTreeItem item) const {
679	if (!m_anchor) return NULL;
680	return m_anchor->FindItem(item);
681	return 0;
682	};
683
684	//-----------------------------------------------------------------------------
685	// wxTreeEvent
686	//-----------------------------------------------------------------------------
687
688	IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent,wxCommandEvent)
689
690	wxTreeEvent::wxTreeEvent( wxEventType commandType, int id ) :
691	wxCommandEvent( commandType, id )
692	{
693	m_code = 0;
694	m_oldItem = 0;
695	};
696
697	/* Bunch of old code might be useful */
698	/*
699	wxBitmap *bmp;
700
701	if ((bmp = m_imageList->GetItem(0))->Ok()) {
702	GdkBitmap *mask = NULL;
703	if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
704	GtkWidget *pixmap = gtk_pixmap_new( bmp->GetPixmap(), mask );
705
706	gtk_widget_set_parent(pixmap, GTK_WIDGET(new_child->m_widget));
707	gtk_widget_show(pixmap);
708	GTK_TREE_ITEM(new_child->m_widget)->pixmaps_box = pixmap;
709	}
710
711	if ((bmp = m_imageList->GetItem(1))->Ok()) {
712	GdkBitmap *mask = NULL;
713	if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
714	GtkWidget *pixmap = gtk_pixmap_new( bmp->GetPixmap(), mask );
715
716	gtk_widget_set_parent(pixmap, GTK_WIDGET(new_child->m_widget));
717	gtk_widget_show(pixmap);
718	GTK_TREE_ITEM(new_child->m_widget)->plus_pix_widget = pixmap;
719	}
720
721	if ((bmp = m_imageList->GetItem(2))->Ok()) {
722	GdkBitmap *mask = NULL;
723	if (bmp->GetMask()) mask = bmp->GetMask()->GetBitmap();
724	GtkWidget *pixmap = gtk_pixmap_new( bmp->GetPixmap(), mask );
725
726	gtk_widget_set_parent(pixmap, GTK_WIDGET(new_child->m_widget));
727	gtk_widget_show(pixmap);
728	GTK_TREE_ITEM(new_child->m_widget)->minus_pix_widget = pixmap;
729	}
730
731	if (p)
732	if (p->m_childlist.Number() == 1) {
733	gtk_tree_item_collapse(GTK_TREE_ITEM(p->m_widget));
734	gtk_tree_item_expand(GTK_TREE_ITEM(p->m_widget));
735	}
736	*/