src/gtk1/treegtk.cpp

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