src/gtk1/treectrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        treectrl.cpp
   3 // Purpose:     wxTreeCtrl
   4 // Author:      Denis Pershin
   5 // Modified by:
   6 // Created:     07/05/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Denis Pershin
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "treectrl.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include "wx/wx.h"
  25 #endif
  26
  27 #include "wx/gtk/treectrl.h"
  28 #include <wx/textctrl.h>
  29 #include "wx/log.h"
  30
  31 #include <gtk/gtk.h>
  32
  33 //static void wxConvertToGtkTreeItem(wxTreeCtrl *owner, wxTreeItem& info, GtkTreeItem **gtkItem);
  34 //static void wxConvertFromGtkTreeItem(wxTreeItem& info, GtkTreeItem *gtkItem);
  35
  36 static void gtk_treectrl_count_callback (GtkWidget *widget, gpointer data);
  37 static void gtk_treectrl_first_selected_callback(GtkWidget *widget, gpointer data);
  38 static void gtk_treectrl_first_visible_callback(GtkWidget *widget, gpointer data);
  39
  40 // static void gtk_treectrl_next_callback (GtkWidget *widget, gpointer data);
  41 // static void gtk_treectrl_next_visible_callback (GtkWidget *widget, gpointer data);
  42 // static void gtk_treectrl_next_selected_callback (GtkWidget *widget, gpointer data);
  43
  44 static void gtk_treeitem_expand_callback(GtkWidget *widget, wxTreeItemId *treeitem);
  45 static void gtk_treeitem_collapse_callback(GtkWidget *widget, wxTreeItemId *treeitem);
  46 static void gtk_treeitem_select_callback(GtkWidget *widget, wxTreeItemId *treeitem);
  47
  48 static void gtk_treeitem_expand_callback(GtkWidget *widget, wxTreeItemId *treeitem) {
  49   wxTreeCtrl *owner = (wxTreeCtrl *)gtk_object_get_data(GTK_OBJECT(widget), "owner");
  50   if (owner == NULL)
  51     return;
  52
  53 //  long id = (long)gtk_object_get_data(GTK_OBJECT(widget), "id");
  54   owner->SendExpanding(GTK_TREE_ITEM(widget));
  55   owner->SendExpanded(GTK_TREE_ITEM(widget));
  56 };
  57
  58 static void gtk_treeitem_collapse_callback(GtkWidget *widget, wxTreeItemId *treeitem) {
  59   wxTreeCtrl *owner = (wxTreeCtrl *)gtk_object_get_data(GTK_OBJECT(widget), "owner");
  60   if (owner == NULL)
  61     return;
  62
  63 //  long id = (long)gtk_object_get_data(GTK_OBJECT(widget), "id");
  64   owner->SendCollapsing(GTK_TREE_ITEM(widget));
  65   owner->SendCollapsed(GTK_TREE_ITEM(widget));
  66 };
  67
  68 static void gtk_treeitem_select_callback(GtkWidget *widget, wxTreeItemId *treeitem) {
  69   wxTreeCtrl *owner = (wxTreeCtrl *)gtk_object_get_data(GTK_OBJECT(widget), "owner");
  70   if (owner == NULL)
  71     return;
  72
  73 //  long id = (long)gtk_object_get_data(GTK_OBJECT(widget), "id");
  74   owner->SendSelChanging(GTK_TREE_ITEM(widget));
  75   owner->SendSelChanged(GTK_TREE_ITEM(widget));
  76 }
  77
  78 #if !USE_SHARED_LIBRARY
  79 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
  80
  81 #endif
  82
  83 void wxTreeCtrl::Init() {
  84   m_imageListNormal = NULL;
  85   m_imageListState = NULL;
  86   m_textCtrl = NULL;
  87 }
  88
  89 bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos,
  90                         const wxSize& size, long style,
  91                         const wxValidator& validator, const wxString& name) {
  92   Init();
  93
  94   int x = pos.x;
  95   int y = pos.y;
  96   int width = size.x;
  97   int height = size.y;
  98
  99   m_windowStyle = style;
 100
 101   SetParent(parent);
 102
 103   if (width <= 0)
 104     width = 100;
 105   if (height <= 0)
 106     height = 30;
 107   if (x < 0)
 108     x = 0;
 109   if (y < 0)
 110     y = 0;
 111
 112   m_needParent = TRUE;
 113
 114 printf("precreate\n");
 115   PreCreation( parent, id, pos, size, style, name );
 116
 117 printf("1\n");
 118
 119   m_widget = gtk_scrolled_window_new(NULL, NULL);
 120 printf("2\n");
 121   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_widget),
 122       GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 123
 124 printf("3\n");
 125   m_tree = GTK_TREE(gtk_tree_new());
 126
 127 printf("4\n");
 128   gtk_container_add(GTK_CONTAINER(m_widget), GTK_WIDGET(m_tree));
 129 printf("5\n");
 130   gtk_widget_show(GTK_WIDGET(m_tree));
 131
 132   SetName(name);
 133   SetValidator(validator);
 134
 135 printf("Robert's new insertion code :-)\n");
 136   m_parent->AddChild( this );
 137   (m_parent->m_insertCallback)( m_parent, this );
 138
 139 printf("postcreate\n");
 140   PostCreation();
 141
 142   gtk_widget_realize(GTK_WIDGET(m_tree));
 143
 144   Show(TRUE);
 145
 146   return TRUE;
 147 }
 148
 149 wxTreeCtrl::~wxTreeCtrl(void) {
 150   if (m_textCtrl)
 151     delete m_textCtrl;
 152 }
 153
 154 // Attributes
 155 static void gtk_treectrl_count_callback (GtkWidget *widget, gpointer data) {
 156   int count = (*((int *)data));
 157
 158   count++;
 159   if (GTK_IS_CONTAINER(widget))
 160     gtk_container_foreach(GTK_CONTAINER(widget), gtk_treectrl_count_callback, data);
 161 }
 162
 163 size_t wxTreeCtrl::GetCount() const {
 164   int count = 0;
 165
 166   if (m_anchor != NULL)
 167     gtk_treectrl_count_callback(GTK_WIDGET(m_anchor), &count);
 168   return count;
 169 }
 170
 171 unsigned int wxTreeCtrl::GetIndent() const {
 172   return m_tree->indent_value;
 173 }
 174
 175 void wxTreeCtrl::SetIndent(unsigned int indent) {
 176   m_tree->indent_value = indent;
 177 }
 178
 179 wxImageList *wxTreeCtrl::GetImageList() const {
 180   return m_imageListNormal;
 181 }
 182
 183 wxImageList *wxTreeCtrl::GetStateImageList() const {
 184   return m_imageListState;
 185 }
 186
 187 void wxTreeCtrl::SetImageList(wxImageList *imageList) {
 188   m_imageListNormal = imageList;
 189 }
 190
 191 void wxTreeCtrl::SetStateImageList(wxImageList *imageList) {
 192   m_imageListState = imageList;
 193 }
 194
 195 wxString wxTreeCtrl::GetItemText(const wxTreeItemId &item) const {
 196   char *t;
 197
 198   if (!item.IsOk())
 199     return wxString("");
 200
 201   GtkLabel *l = GTK_LABEL(gtk_object_get_data(GTK_OBJECT((GtkTreeItem *)item), "w_label"));
 202   gtk_label_get(l, &t);
 203
 204   return t;
 205 }
 206
 207 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item) const {
 208   if (!item.IsOk())
 209     return (-1);
 210
 211   return (int)gtk_object_get_data(GTK_OBJECT((GtkTreeItem *)item), "image");
 212 }
 213
 214 int wxTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const {
 215   if (!item.IsOk())
 216     return (-1);
 217
 218   return (int)gtk_object_get_data(GTK_OBJECT((GtkTreeItem *)item), "selectedImage");
 219 }
 220
 221 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const {
 222   if (!item.IsOk())
 223     return NULL;
 224
 225   return (wxTreeItemData *)gtk_object_get_data(GTK_OBJECT((GtkTreeItem *)item), "data");
 226 }
 227
 228 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text) {
 229   if (!item.IsOk())
 230     return;
 231
 232   GtkLabel *l = GTK_LABEL(gtk_object_get_data(GTK_OBJECT((GtkTreeItem *)item), "w_label"));
 233   gtk_label_set(l, text);
 234 }
 235
 236 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image) {
 237   if (!item.IsOk())
 238     return;
 239
 240   gtk_object_set_data(GTK_OBJECT((GtkTreeItem *)item), "image", (void *)image);
 241 }
 242
 243 void wxTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image) {
 244   if (!item.IsOk())
 245     return;
 246
 247   gtk_object_set_data(GTK_OBJECT((GtkTreeItem *)item), "selectedImage", (void *)image);
 248 }
 249
 250 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data) {
 251   if (!item.IsOk())
 252     return;
 253
 254   gtk_object_set_data(GTK_OBJECT((GtkTreeItem *)item), "data", data);
 255 }
 256
 257 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const {
 258   return GTK_WIDGET_VISIBLE(GTK_TREE_ITEM((GtkTreeItem *)item));
 259 }
 260
 261 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const {
 262   GtkTreeItem *p = (GtkTreeItem *)item;
 263
 264   if (p->subtree == NULL)
 265     return wxFalse;
 266
 267   if (GTK_TREE(p->subtree)->children == NULL)
 268     return wxFalse;
 269
 270   if (g_list_length(GTK_TREE(p->subtree)->children) == 0)
 271     return wxFalse;
 272
 273   return wxTrue;
 274 }
 275
 276 bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const {
 277   return (((GtkTreeItem *)item)->expanded != 0);
 278 }
 279
 280 bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const {
 281   GtkTreeItem *p = (GtkTreeItem *)item;
 282   GtkWidget *parent = GTK_WIDGET(p)->parent;
 283
 284   if (!GTK_IS_TREE(parent))
 285     return wxFalse;
 286
 287   if (g_list_index(GTK_TREE(parent)->children, p) == -1)
 288     return wxFalse;
 289
 290   return wxTrue;
 291 }
 292
 293 wxTreeItemId wxTreeCtrl::GetRootItem() const {
 294   return m_anchor;
 295 }
 296
 297 static void gtk_treectrl_first_selected_callback(GtkWidget *widget, gpointer data) {
 298   GtkTreeItem *p = (*((GtkTreeItem **)data));
 299
 300   GtkTree *tree = GTK_TREE(GTK_TREE_ITEM(widget)->subtree);
 301
 302   if (tree->selection != NULL) {
 303     p = (GtkTreeItem *)tree->selection->data;
 304     return;
 305   }
 306
 307   if (GTK_IS_CONTAINER(widget))
 308     gtk_container_foreach(GTK_CONTAINER(widget), gtk_treectrl_first_selected_callback, data);
 309 }
 310
 311 wxTreeItemId wxTreeCtrl::GetSelection() const {
 312   GtkTreeItem *p = NULL;
 313
 314   if (m_anchor == NULL)
 315     return NULL;
 316
 317   gtk_treectrl_first_selected_callback(GTK_WIDGET(m_anchor), &p);
 318
 319   return p;
 320 }
 321
 322 wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const {
 323   if (item.IsOk())
 324     return (GtkTreeItem *)gtk_object_get_data(GTK_OBJECT((GtkTreeItem *)item), "parent");
 325
 326   return NULL;
 327 }
 328
 329 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& cookie) const {
 330   GtkTreeItem *p = (GtkTreeItem *)item;
 331   GtkWidget *parent = GTK_WIDGET(p)->parent;
 332
 333   if (!GTK_IS_TREE(parent))
 334     return NULL;
 335
 336   cookie = 0;
 337   return GTK_TREE_ITEM(g_list_first(GTK_TREE(parent)->children)->data);
 338 }
 339
 340 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& item, long& cookie) const {
 341   GtkTreeItem *p = (GtkTreeItem *)item;
 342   GtkWidget *parent = GTK_WIDGET(p)->parent;
 343
 344   if (!GTK_IS_TREE(parent))
 345     return NULL;
 346
 347   cookie++;
 348   return GTK_TREE_ITEM(g_list_nth(GTK_TREE(parent)->children, cookie)->data);
 349 }
 350
 351 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 352 {
 353   GtkTreeItem *p = (GtkTreeItem *)item;
 354   GtkWidget *parent = GTK_WIDGET(p)->parent;
 355
 356   wxCHECK_MSG( GTK_IS_TREE(parent), NULL, "invalid tree item" );
 357
 358   return GTK_TREE_ITEM(g_list_last(GTK_TREE(parent)->children)->data);
 359 }
 360
 361 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const {
 362   GtkTreeItem *p = (GtkTreeItem *)item;
 363   GtkWidget *parent = GTK_WIDGET(p)->parent;
 364
 365   if (!GTK_IS_TREE(parent))
 366     return NULL;
 367
 368   if (g_list_index(GTK_TREE(parent)->children, p) == -1)
 369     return NULL;
 370
 371   return GTK_TREE_ITEM(g_list_next(g_list_find(GTK_TREE(parent)->children, p))->data);
 372 }
 373
 374 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const {
 375   GtkTreeItem *p = (GtkTreeItem *)item;
 376   GtkWidget *parent = GTK_WIDGET(p)->parent;
 377
 378   if (!GTK_IS_TREE(parent))
 379     return NULL;
 380
 381   if (g_list_index(GTK_TREE(parent)->children, p) == -1)
 382     return NULL;
 383
 384   return GTK_TREE_ITEM(g_list_previous(g_list_find(GTK_TREE(parent)->children, p))->data);
 385 }
 386
 387 static void gtk_treectrl_first_visible_callback(GtkWidget *widget, gpointer data) {
 388   GtkTreeItem *p = (*((GtkTreeItem **)data));
 389
 390   GtkTree *tree = GTK_TREE(GTK_TREE_ITEM(widget)->subtree);
 391
 392   if (tree->children != NULL) {
 393     guint len = g_list_length(tree->children);
 394     for (guint i=0; i<len; i++) {
 395       if (GTK_WIDGET_VISIBLE(GTK_WIDGET(GTK_TREE_ITEM((GtkTreeItem *)g_list_nth(tree->children, i)->data)))) {
 396         p = GTK_TREE_ITEM((GtkTreeItem *)g_list_nth(tree->children, i)->data);
 397         return;
 398       }
 399     }
 400   }
 401
 402   if (GTK_IS_CONTAINER(widget))
 403     gtk_container_foreach(GTK_CONTAINER(widget), gtk_treectrl_first_visible_callback, data);
 404 }
 405
 406 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const {
 407   GtkTreeItem *p = NULL;
 408
 409   if (m_anchor == NULL)
 410     return NULL;
 411
 412   gtk_treectrl_first_visible_callback(GTK_WIDGET(m_anchor), &p);
 413
 414   return p;
 415 }
 416
 417 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const {
 418   GtkTreeItem *p = (GtkTreeItem *)item;
 419   GtkTree *parent = GTK_TREE(GTK_WIDGET(p)->parent);
 420   GtkTreeItem *q;
 421
 422   if (!GTK_IS_TREE(parent))
 423     return NULL;
 424
 425   if (parent->children == NULL)
 426     return NULL;
 427
 428   q = GTK_TREE_ITEM(g_list_next(g_list_find(GTK_TREE(parent)->children, p))->data);
 429
 430   while (q != p) {
 431     q = GTK_TREE_ITEM(g_list_next(g_list_find(GTK_TREE(parent)->children, q))->data);
 432     if (GTK_WIDGET_VISIBLE(GTK_WIDGET(q)))
 433       return q;
 434   }
 435
 436   return NULL;
 437 }
 438
 439 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const {
 440   GtkTreeItem *p = (GtkTreeItem *)item;
 441   GtkTree *parent = GTK_TREE(GTK_WIDGET(p)->parent);
 442   GtkTreeItem *q;
 443
 444   if (!GTK_IS_TREE(parent))
 445     return NULL;
 446
 447   if (parent->children == NULL)
 448     return NULL;
 449
 450   q = GTK_TREE_ITEM(g_list_previous(g_list_find(GTK_TREE(parent)->children, p))->data);
 451
 452   while (q != p) {
 453     q = GTK_TREE_ITEM(g_list_previous(g_list_find(GTK_TREE(parent)->children, q))->data);
 454     if (GTK_WIDGET_VISIBLE(GTK_WIDGET(q)))
 455       return q;
 456   }
 457
 458   return NULL;
 459 }
 460
 461 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text, int image,
 462                      int selectedImage, wxTreeItemData *data) {
 463   return p_InsertItem(0, text, image, selectedImage, data);
 464 }
 465
 466 wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
 467                          const wxString& text, int image, int selectedImage,
 468                          wxTreeItemData *data) {
 469 #warning "Need to implement PrependItem"
 470   return NULL;
 471 }
 472
 473 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
 474                         const wxTreeItemId& idPrevious, const wxString& text,
 475                         int image, int selectedImage, wxTreeItemData *data) {
 476 #warning "Need to implement InsertItem"
 477   return NULL;
 478 }
 479
 480 wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
 481                         const wxString& text, int image, int selectedImage,
 482                         wxTreeItemData *data) {
 483   return p_InsertItem(parent, text, image, selectedImage, data);
 484 }
 485
 486 wxTreeItemId wxTreeCtrl::p_InsertItem(GtkTreeItem *p,
 487                         const wxString& text, int image, int selectedImage,
 488                         wxTreeItemData *data) {
 489   GtkTreeItem *item;
 490
 491 printf("begin insert\n");
 492
 493   item = GTK_TREE_ITEM(gtk_tree_item_new());
 494
 495   GtkHBox *m_box = GTK_HBOX(gtk_hbox_new(FALSE, 0));
 496   gtk_container_add (GTK_CONTAINER (item), GTK_WIDGET(m_box));
 497
 498   gtk_object_set_data(GTK_OBJECT(item), "w_box", m_box);
 499
 500   const wxBitmap *bmp;
 501   const wxImageList *list;
 502   if ((list = GetImageList(wxIMAGE_LIST_NORMAL)) != NULL)
 503     if ((bmp = list->GetBitmap(image)) != NULL)
 504       if (bmp->Ok()) {
 505         GdkBitmap *mask = NULL;
 506         if (bmp->GetMask())
 507           mask = bmp->GetMask()->GetBitmap();
 508         GtkPixmap *m_image_widget = GTK_PIXMAP(gtk_pixmap_new(bmp->GetPixmap(), mask));
 509         gtk_misc_set_alignment (GTK_MISC (m_image_widget), 0.0, 0.5);
 510         gtk_box_pack_start(GTK_BOX(m_box), GTK_WIDGET(m_image_widget), FALSE, FALSE, 0);
 511         gtk_object_set_data(GTK_OBJECT(item), "w_image", (void *)m_image_widget);
 512         gtk_object_set_data(GTK_OBJECT(item), "image", (void *)image);
 513         gtk_widget_show (GTK_WIDGET(m_image_widget));
 514       }
 515   GtkLabel *m_label_widget = GTK_LABEL(gtk_label_new ((char *)(const char *)text));
 516   gtk_misc_set_alignment (GTK_MISC (m_label_widget), 0.5, 0.5);
 517   gtk_box_pack_start(GTK_BOX(m_box), GTK_WIDGET(m_label_widget), FALSE, FALSE, 0);
 518   gtk_object_set_data(GTK_OBJECT(item), "w_label", m_label_widget);
 519   gtk_widget_show (GTK_WIDGET(m_label_widget));
 520
 521   gtk_widget_show(GTK_WIDGET(m_box));
 522
 523   gtk_object_set_data(GTK_OBJECT(item), "owner", this);
 524   gtk_object_set_data(GTK_OBJECT(item), "data", data);
 525   gtk_object_set_data(GTK_OBJECT(item), "parent", p);
 526
 527   if (p != 0) {
 528     if (p->subtree == NULL) {
 529       GtkTree *tree = GTK_TREE(gtk_tree_new());
 530       gtk_tree_item_set_subtree(GTK_TREE_ITEM(p), GTK_WIDGET(tree));
 531       gtk_widget_show(GTK_WIDGET(tree));
 532       p->expanded = 1;
 533     }
 534
 535     gtk_container_add(GTK_CONTAINER(p->subtree), GTK_WIDGET(item));
 536   } else {
 537 printf("Adding root\n");
 538 printf("m_tree = %p\n", m_tree);
 539     m_anchor = item;
 540     gtk_container_add(GTK_CONTAINER(m_tree), GTK_WIDGET(item));
 541   }
 542
 543   gtk_widget_show(GTK_WIDGET(item));
 544
 545   gtk_signal_connect(GTK_OBJECT(item), "select",
 546     GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );
 547
 548   gtk_signal_connect(GTK_OBJECT(item), "deselect",
 549     GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );
 550
 551   gtk_signal_connect(GTK_OBJECT(item), "expand",
 552     GTK_SIGNAL_FUNC(gtk_treeitem_expand_callback), (gpointer)this );
 553   gtk_signal_connect(GTK_OBJECT(item), "collapse",
 554     GTK_SIGNAL_FUNC(gtk_treeitem_collapse_callback), (gpointer)this );
 555
 556   return item;
 557 }
 558
 559 void wxTreeCtrl::Delete(const wxTreeItemId& item) {
 560   if (!item.IsOk())
 561     return;
 562
 563   GtkTreeItem *parent = GTK_TREE_ITEM(GTK_WIDGET((GtkTreeItem *)item)->parent);
 564   if (parent == NULL)
 565     return;
 566
 567   gtk_container_remove(GTK_CONTAINER(parent), GTK_WIDGET((GtkTreeItem *)item));
 568
 569   return;
 570 }
 571
 572 void wxTreeCtrl::DeleteAllItems() {
 573   gtk_tree_item_remove_subtree(m_anchor);
 574 }
 575
 576 void wxTreeCtrl::Expand(const wxTreeItemId& item) {
 577   if (!item.IsOk())
 578     return;
 579
 580   gtk_tree_item_expand(GTK_TREE_ITEM((GtkTreeItem *)item));
 581 }
 582
 583 void wxTreeCtrl::Collapse(const wxTreeItemId& item) {
 584   if (!item.IsOk())
 585     return;
 586
 587   gtk_tree_item_collapse(GTK_TREE_ITEM((GtkTreeItem *)item));
 588 }
 589
 590 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item) {
 591   if (!item.IsOk())
 592     return;
 593
 594   gtk_tree_item_collapse(GTK_TREE_ITEM((GtkTreeItem *)item));
 595   gtk_tree_item_remove_subtree(GTK_TREE_ITEM((GtkTreeItem *)item));
 596 }
 597
 598 void wxTreeCtrl::Toggle(const wxTreeItemId& item) {
 599   if (!item.IsOk())
 600     return;
 601
 602   if (((GtkTreeItem *)item)->expanded)
 603     gtk_tree_item_collapse(GTK_TREE_ITEM((GtkTreeItem *)item));
 604   else
 605     gtk_tree_item_expand(GTK_TREE_ITEM((GtkTreeItem *)item));
 606 }
 607
 608 static void gtk_treectrl_unselect_callback(GtkWidget *widget, gpointer data) {
 609   GtkTreeItem *p;
 610
 611   GtkTree *tree = GTK_TREE(GTK_TREE_ITEM(widget)->subtree);
 612
 613   if (tree->selection != NULL) {
 614     guint len = g_list_length(tree->selection);
 615     for (guint i=0; i<len; i++) {
 616       p = GTK_TREE_ITEM((GtkTreeItem *)g_list_nth(tree->selection, i)->data);
 617       gtk_tree_unselect_child(tree, GTK_WIDGET(p));
 618     }
 619   }
 620
 621   if (GTK_IS_CONTAINER(widget))
 622     gtk_container_foreach(GTK_CONTAINER(widget), gtk_treectrl_unselect_callback, data);
 623 }
 624
 625 void wxTreeCtrl::Unselect() {
 626   if (m_anchor == NULL)
 627     return;
 628
 629   gtk_treectrl_unselect_callback(GTK_WIDGET(m_anchor), NULL);
 630 }
 631
 632 void wxTreeCtrl::SelectItem(const wxTreeItemId& item) {
 633   if (!item.IsOk())
 634     return;
 635
 636   gtk_tree_item_select((GtkTreeItem *)item);
 637 }
 638
 639 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item) {
 640 #warning "Need to implement EnsureVisible"
 641 }
 642
 643 void wxTreeCtrl::ScrollTo(const wxTreeItemId& item) {
 644 #warning "Need to implement ScrollTo"
 645 }
 646
 647 wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
 648                           wxClassInfo* textControlClass) {
 649     wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
 650 #warning "Need to implement EditLabel"
 651 /*
 652   char *s;
 653   m_editItem = item;
 654
 655   GtkLabel *m_label = (GtkLabel *)gtk_object_get_data(GTK_OBJECT((GtkTreeItem *)item), "w_label");
 656   gtk_label_get(m_label, &s);
 657
 658   m_textCtrl = new wxTextCtrl(this, -1, s);
 659 //  m_textCtrl->SetValue(s);
 660
 661   gtk_object_set_data(GTK_OBJECT((GtkTreeItem *)item), "w_edit", m_textCtrl->m_widget);
 662
 663   gtk_container_remove(GTK_CONTAINER((GtkTreeItem *)item), GTK_WIDGET(m_label));
 664   gtk_container_add(GTK_CONTAINER((GtkTreeItem *)item), m_textCtrl->m_widget);
 665
 666 */
 667   return m_textCtrl;
 668 }
 669
 670 wxTextCtrl* wxTreeCtrl::GetEditControl() const {
 671   return m_textCtrl;
 672 }
 673
 674 void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges) {
 675 #warning "Need to implement EndEditLabel"
 676 /*
 677   GtkLabel *m_label = (GtkLabel *)gtk_object_get_data(GTK_OBJECT((GtkTreeItem *)m_editItem), "w_label");
 678   gtk_label_set(m_label, m_textCtrl->GetValue());
 679
 680   gtk_object_remove_data(GTK_OBJECT((GtkTreeItem *)m_editItem), "w_edit");
 681
 682   gtk_container_remove(GTK_CONTAINER((GtkTreeItem *)m_editItem), m_textCtrl->m_widget);
 683   gtk_container_add(GTK_CONTAINER((GtkTreeItem *)m_editItem), GTK_WIDGET(m_label));
 684
 685   delete m_textCtrl;
 686   m_textCtrl = NULL;
 687 */
 688 }
 689
 690 void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action) {
 691   switch (action) {
 692     case wxTREE_EXPAND_EXPAND:
 693       Expand(item);
 694       break;
 695
 696     case wxTREE_EXPAND_COLLAPSE:
 697       Collapse(item);
 698       break;
 699
 700     case wxTREE_EXPAND_COLLAPSE_RESET:
 701       CollapseAndReset(item);
 702       break;
 703
 704     case wxTREE_EXPAND_TOGGLE:
 705       Toggle(item);
 706       break;
 707
 708     default:
 709       wxFAIL_MSG("unknown action in wxTreeCtrl::ExpandItem");
 710   }
 711 }
 712
 713 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
 714                             const wxString& text, int image, int selImage,
 715                             long insertAfter) {
 716 //  InsertItem(parent, insertAfter, text, image, selImage);
 717   #warning "Need to implement InsertItem"
 718   return NULL;
 719 }
 720
 721 /* Old functions
 722 long wxTreeCtrl::GetChild(long item) const {
 723   GtkTreeItem *p;
 724   GtkTreeItem *next = NULL;
 725
 726   p = findGtkTreeItem(item);
 727   GList *list = gtk_container_children(GTK_CONTAINER(p));
 728   next = GTK_TREE_ITEM(list->data);;
 729
 730   if (next != NULL)
 731     return (long)gtk_object_get_data(GTK_OBJECT(next), "id");
 732
 733   return (-1);
 734 }
 735
 736 long wxTreeCtrl::GetFirstVisibleItem(void) const {
 737   GtkTreeItem *next = NULL;
 738
 739   GList *list = gtk_container_children(GTK_CONTAINER(m_anchor));
 740   next = GTK_TREE_ITEM(list->data);;
 741 //  gtk_container_foreach(GTK_CONTAINER(m_anchor), gtk_treectrl_next_visible_callback, &next);
 742
 743   if (next != NULL)
 744     return (long)gtk_object_get_data(GTK_OBJECT(next), "id");
 745
 746   return (-1);
 747 }
 748
 749 long wxTreeCtrl::GetNextVisibleItem(long item) const {
 750   GtkTreeItem *p;
 751   GtkTreeItem *next = NULL;
 752
 753   p = findGtkTreeItem(item);
 754   GList *list = gtk_container_children(GTK_CONTAINER(p));
 755   next = GTK_TREE_ITEM(list->data);;
 756 //  gtk_container_foreach(GTK_CONTAINER(p), gtk_treectrl_next_visible_callback, &next);
 757
 758   if (next != NULL)
 759     return (long)gtk_object_get_data(GTK_OBJECT(next), "id");
 760
 761   return (-1);
 762 }
 763
 764 bool wxTreeCtrl::GetItem(wxTreeItem& info) const {
 765   GtkTreeItem *p;
 766
 767   p = findGtkTreeItem(info.m_itemId);
 768
 769   if (p == NULL) {
 770     wxLogSysError("TreeCtrl::GetItem failed");
 771     return FALSE;
 772   }
 773
 774   wxConvertFromGtkTreeItem(info, p);
 775
 776   return TRUE;
 777 }
 778
 779 bool wxTreeCtrl::SetItem(wxTreeItem& info) {
 780   GtkTreeItem *p;
 781
 782   p = findGtkTreeItem(info.m_itemId);
 783
 784   if (p == NULL) {
 785     wxLogSysError("TreeCtrl::SetItem failed");
 786     return FALSE;
 787   }
 788
 789   wxConvertToGtkTreeItem(this, info, &p);
 790
 791   return TRUE;
 792 }
 793
 794 int wxTreeCtrl::GetItemState(long item, long stateMask) const {
 795   wxTreeItem info;
 796
 797   info.m_mask = wxTREE_MASK_STATE ;
 798   info.m_stateMask = stateMask;
 799   info.m_itemId = item;
 800
 801   if (!GetItem(info))
 802     return 0;
 803
 804   return info.m_state;
 805 }
 806
 807 bool wxTreeCtrl::SetItemState(long item, long state, long stateMask) {
 808   wxTreeItem info;
 809
 810   info.m_mask = wxTREE_MASK_STATE ;
 811   info.m_state = state;
 812   info.m_stateMask = stateMask;
 813   info.m_itemId = item;
 814
 815   return SetItem(info);
 816 }
 817 */
 818
 819 // Operations
 820 /*
 821 bool wxTreeCtrl::DeleteChildren(long item) {
 822   GtkTreeItem *p;
 823
 824   p = findGtkTreeItem(item);
 825   if (p == NULL)
 826     return FALSE;
 827
 828   gtk_tree_item_remove_subtree(GTK_TREE_ITEM(p));
 829
 830   return TRUE;
 831 }
 832 */
 833
 834 /*
 835 long wxTreeCtrl::InsertItem(long parent, wxTreeItem& info, long insertAfter) {
 836   GtkTreeItem *p;
 837   GtkTreeItem *item = NULL;
 838
 839   info.m_itemId = m_curitemId;
 840   m_curitemId++;
 841
 842   wxConvertToGtkTreeItem(this, info, &item);
 843
 844   if (parent != 0) {
 845     p = findGtkTreeItem(parent);
 846     if (p->subtree == NULL) {
 847       GtkTree *tree = GTK_TREE(gtk_tree_new());
 848       gtk_tree_item_set_subtree(GTK_TREE_ITEM(p), GTK_WIDGET(tree));
 849       gtk_widget_show(GTK_WIDGET(tree));
 850       p->expanded = 1;
 851     }
 852
 853     gtk_container_add(GTK_CONTAINER(p->subtree), GTK_WIDGET(item));
 854   } else {
 855     m_anchor = item;
 856     gtk_container_add(GTK_CONTAINER(m_tree), GTK_WIDGET(item));
 857   }
 858
 859   if ((info.m_mask & wxTREE_MASK_CHILDREN) != 0) {
 860     GtkTree *tree = GTK_TREE(gtk_tree_new());
 861     gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), GTK_WIDGET(tree));
 862     gtk_widget_show(GTK_WIDGET(tree));
 863   }
 864
 865   gtk_widget_show(GTK_WIDGET(item));
 866
 867   gtk_signal_connect(GTK_OBJECT(item), "select",
 868     GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );
 869
 870   gtk_signal_connect(GTK_OBJECT(item), "deselect",
 871     GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );
 872
 873   gtk_signal_connect(GTK_OBJECT(item), "expand",
 874     GTK_SIGNAL_FUNC(gtk_treeitem_expand_callback), (gpointer)this );
 875   gtk_signal_connect(GTK_OBJECT(item), "collapse",
 876     GTK_SIGNAL_FUNC(gtk_treeitem_collapse_callback), (gpointer)this );
 877
 878   return info.m_itemId;
 879 }
 880
 881 long wxTreeCtrl::InsertItem(long parent, const wxString& label, int image,
 882   int selImage, long insertAfter) {
 883
 884   wxTreeItem info;
 885   info.m_text = label;
 886   info.m_mask = wxTREE_MASK_TEXT;
 887   if (image > -1) {
 888     info.m_mask |= wxTREE_MASK_IMAGE | wxTREE_MASK_SELECTED_IMAGE;
 889     info.m_image = image;
 890     if (selImage == -1)
 891       info.m_selectedImage = image;
 892     else
 893       info.m_selectedImage = selImage;
 894   }
 895
 896   return InsertItem(parent, info, insertAfter);
 897 }
 898 */
 899
 900 void wxTreeCtrl::SendMessage(wxEventType command, const wxTreeItemId& item) {
 901   wxTreeEvent event(command, GetId());
 902   event.SetEventObject(this);
 903   event.m_item = item;
 904   ProcessEvent(event);
 905 }
 906
 907 void wxTreeCtrl::SendExpanding(const wxTreeItemId& item) {
 908   SendMessage(wxEVT_COMMAND_TREE_ITEM_EXPANDING, item);
 909 }
 910
 911 void wxTreeCtrl::SendExpanded(const wxTreeItemId& item) {
 912   SendMessage(wxEVT_COMMAND_TREE_ITEM_EXPANDED, item);
 913 }
 914
 915 void wxTreeCtrl::SendCollapsing(const wxTreeItemId& item) {
 916   SendMessage(wxEVT_COMMAND_TREE_ITEM_COLLAPSING, item);
 917 }
 918
 919 void wxTreeCtrl::SendCollapsed(const wxTreeItemId& item) {
 920   SendMessage(wxEVT_COMMAND_TREE_ITEM_COLLAPSED, item);
 921 }
 922
 923 void wxTreeCtrl::SendSelChanging(const wxTreeItemId& item) {
 924   SendMessage(wxEVT_COMMAND_TREE_SEL_CHANGED, item);
 925 }
 926
 927 void wxTreeCtrl::SendSelChanged(const wxTreeItemId& item) {
 928   SendMessage(wxEVT_COMMAND_TREE_SEL_CHANGING, item);
 929 }
 930
 931 // Tree event
 932 IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxCommandEvent)
 933
 934 wxTreeEvent::wxTreeEvent(wxEventType commandType, int id):
 935   wxCommandEvent(commandType, id) {
 936   m_code = 0;
 937   m_itemOld = 0;
 938 }