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