source3/client/tree.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 2.0
   4    SMB client GTK+ tree-based application
   5    Copyright (C) Andrew Tridgell 1998
   6    Copyright (C) Richard Sharpe 2001
   7    Copyright (C) John Terpstra 2001
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 /* example-gtk+ application, ripped off from the gtk+ tree.c sample */
  25
  26 #include <stdio.h>
  27 #include <errno.h>
  28 #include <gtk/gtk.h>
  29 #include "libsmbclient.h"
  30
  31 static GtkWidget *clist;
  32
  33 struct tree_data {
  34
  35   guint32 type;    /* Type of tree item, an SMBC_TYPE */
  36   char name[256];  /* May need to change this later   */
  37
  38 };
  39
  40 /*
  41  * We are given a widget, and we want to retrieve its URL so we
  42  * can do a directory listing.
  43  *
  44  * We walk back up the tree, picking up pieces until we hit a server or
  45  * workgroup type and return a path from there
  46  */
  47
  48 static char path_string[1024];
  49
  50 char *get_path(GtkWidget *item)
  51 {
  52   GtkWidget *p = item;
  53   struct tree_data *pd;
  54   char *comps[1024];  /* We keep pointers to the components here */
  55   int i = 0, j, level,type;
  56
  57   /* Walk back up the tree, getting the private data */
  58
  59   level = GTK_TREE(item->parent)->level;
  60
  61   /* Pick up this item's component info */
  62
  63   pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(item));
  64
  65   comps[i++] = pd->name;
  66   type = pd->type;
  67
  68   while (level > 0 && type != SMBC_SERVER && type != SMBC_WORKGROUP) {
  69
  70     /* Find the parent and extract the data etc ... */
  71
  72     p = GTK_WIDGET(p->parent);
  73     p = GTK_WIDGET(GTK_TREE(p)->tree_owner);
  74
  75     pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(p));
  76
  77     level = GTK_TREE(item->parent)->level;
  78
  79     comps[i++] = pd->name;
  80     type = pd->type;
  81
  82   }
  83
  84   /*
  85    * Got a list of comps now, should check that we did not hit a workgroup
  86    * when we got other things as well ... Later
  87    *
  88    * Now, build the path
  89    */
  90
  91   snprintf(path_string, sizeof(path_string), "smb:/");
  92
  93   for (j = i - 1; j >= 0; j--) {
  94
  95     strncat(path_string, "/", sizeof(path_string) - strlen(path_string));
  96     strncat(path_string, comps[j], sizeof(path_string) - strlen(path_string));
  97
  98   }
  99
 100   fprintf(stdout, "Path string = %s\n", path_string);
 101
 102   return path_string;
 103
 104 }
 105
 106 struct tree_data *make_tree_data(guint32 type, const char *name)
 107 {
 108   struct tree_data *p = (struct tree_data *)malloc(sizeof(struct tree_data));
 109
 110   if (p) {
 111
 112     p->type = type;
 113     strncpy(p->name, name, sizeof(p->name));
 114
 115   }
 116
 117   return p;
 118
 119 }
 120
 121 /* for all the GtkItem:: and GtkTreeItem:: signals */
 122 static void cb_itemsignal( GtkWidget *item,
 123                            gchar     *signame )
 124 {
 125   GtkWidget *real_tree, *aitem, *subtree;
 126   gchar *name;
 127   GtkLabel *label;
 128   gint dh, err, dirlen, level;
 129   char dirbuf[512];
 130   struct smbc_dirent *dirp;
 131
 132   label = GTK_LABEL (GTK_BIN (item)->child);
 133   /* Get the text of the label */
 134   gtk_label_get (label, &name);
 135
 136   level = GTK_TREE(item->parent)->level;
 137
 138   /* Get the level of the tree which the item is in */
 139   g_print ("%s called for item %s->%p, level %d\n", signame, name,
 140            item, GTK_TREE (item->parent)->level);
 141
 142   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
 143     char server[128];
 144
 145     if ((dh = smbc_opendir(get_path(item))) < 0) { /* Handle error */
 146
 147       g_print("cb_wholenet: Could not open dir %s, %s\n", get_path(item),
 148               strerror(errno));
 149
 150       gtk_main_quit();
 151
 152       return;
 153
 154     }
 155
 156     real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
 157
 158     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 159                                 sizeof(dirbuf))) != 0) {
 160
 161       if (err < 0) { /* An error, report it */
 162
 163         g_print("cb_wholenet: Could not read dir smbc://, %s\n",
 164                 strerror(errno));
 165
 166         gtk_main_quit();
 167
 168         return;
 169
 170       }
 171
 172       dirp = (struct smbc_dirent *)dirbuf;
 173
 174       while (err > 0) {
 175         struct tree_data *my_data;
 176
 177         dirlen = dirp->dirlen;
 178
 179         my_data = make_tree_data(dirp->smbc_type, dirp->name);
 180
 181         if (!my_data) {
 182
 183           g_print("Could not allocate space for tree_data: %s\n",
 184                   dirp->name);
 185
 186           gtk_main_quit();
 187           return;
 188
 189         }
 190
 191         aitem = gtk_tree_item_new_with_label(dirp->name);
 192
 193         /* Connect all GtkItem:: and GtkTreeItem:: signals */
 194         gtk_signal_connect (GTK_OBJECT(aitem), "select",
 195                             GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 196         gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
 197                             GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 198         gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
 199                             GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 200         gtk_signal_connect (GTK_OBJECT(aitem), "expand",
 201                             GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
 202         gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
 203                             GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
 204         /* Add it to the parent tree */
 205         gtk_tree_append (GTK_TREE(real_tree), aitem);
 206
 207         gtk_widget_show (aitem);
 208
 209         gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
 210
 211         fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 212
 213         if (dirp->smbc_type != SMBC_FILE &&
 214             dirp->smbc_type != SMBC_IPC_SHARE &&
 215             (strcmp(dirp->name, ".") != 0) &&
 216             (strcmp(dirp->name, "..") !=0)){
 217
 218           subtree = gtk_tree_new();
 219           gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
 220
 221         }
 222
 223         (char *)dirp += dirlen;
 224         err -= dirlen;
 225
 226       }
 227
 228     }
 229
 230     smbc_closedir(dh);
 231
 232   }
 233
 234 }
 235
 236 /* Note that this is never called */
 237 static void cb_unselect_child( GtkWidget *root_tree,
 238                                GtkWidget *child,
 239                                GtkWidget *subtree )
 240 {
 241   g_print ("unselect_child called for root tree %p, subtree %p, child %p\n",
 242            root_tree, subtree, child);
 243 }
 244
 245 /* Note that this is called every time the user clicks on an item,
 246    whether it is already selected or not. */
 247 static void cb_select_child (GtkWidget *root_tree, GtkWidget *child,
 248                              GtkWidget *subtree)
 249 {
 250   gint dh, err, dirlen;
 251   char dirbuf[512];
 252   struct smbc_dirent *dirp;
 253   struct stat st1;
 254   char path[1024], path1[1024];
 255
 256   g_print ("select_child called for root tree %p, subtree %p, child %p\n",
 257            root_tree, subtree, child);
 258
 259   /* Now, figure out what it is, and display it in the clist ... */
 260
 261   gtk_clist_clear(GTK_CLIST(clist));  /* Clear the CLIST */
 262
 263   /* Now, get the private data for the subtree */
 264
 265   strncpy(path, get_path(child), 1024);
 266
 267   if ((dh = smbc_opendir(path)) < 0) { /* Handle error */
 268
 269     g_print("cb_select_child: Could not open dir %s, %s\n", path,
 270             strerror(errno));
 271
 272     gtk_main_quit();
 273
 274     return;
 275
 276   }
 277
 278   while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 279                               sizeof(dirbuf))) != 0) {
 280
 281     if (err < 0) {
 282
 283       g_print("cb_select_child: Could not read dir %s, %s\n", path,
 284               strerror(errno));
 285
 286       gtk_main_quit();
 287
 288       return;
 289
 290     }
 291
 292     dirp = (struct smbc_dirent *)dirbuf;
 293
 294     while (err > 0) {
 295       gchar col1[128], col2[128], col3[128], col4[128];
 296       gchar *rowdata[4] = {col1, col2, col3, col4};
 297
 298       dirlen = dirp->dirlen;
 299
 300       /* Format each of the items ... */
 301
 302       strncpy(col1, dirp->name, 128);
 303
 304       col2[0] = col3[0] = col4[0] = (char)0;
 305
 306       switch (dirp->smbc_type) {
 307
 308       case SMBC_WORKGROUP:
 309
 310         break;
 311
 312       case SMBC_SERVER:
 313
 314         strncpy(col2, (dirp->comment?dirp->comment:""), 128);
 315
 316         break;
 317
 318       case SMBC_FILE_SHARE:
 319
 320         strncpy(col2, (dirp->comment?dirp->comment:""), 128);
 321
 322         break;
 323
 324       case SMBC_PRINTER_SHARE:
 325
 326         strncpy(col2, (dirp->comment?dirp->comment:""), 128);
 327         break;
 328
 329       case SMBC_COMMS_SHARE:
 330
 331         break;
 332
 333       case SMBC_IPC_SHARE:
 334
 335         break;
 336
 337       case SMBC_DIR:
 338       case SMBC_FILE:
 339
 340         /* Get stats on the file/dir and see what we have */
 341
 342         if ((strcmp(dirp->name, ".") != 0) &&
 343             (strcmp(dirp->name, "..") != 0)) {
 344
 345           strncpy(path1, path, sizeof(path1));
 346           strncat(path1, "/", sizeof(path) - strlen(path));
 347           strncat(path1, dirp->name, sizeof(path) - strlen(path));
 348
 349           if (smbc_stat(path1, &st1) < 0) {
 350
 351             if (errno != EBUSY) {
 352
 353               g_print("cb_select_child: Could not stat file %s, %s\n", path1,
 354                       strerror(errno));
 355
 356               gtk_main_quit();
 357
 358               return;
 359
 360             }
 361             else {
 362
 363               strncpy(col2, "Device or resource busy", sizeof(col2));
 364
 365             }
 366           }
 367           else {
 368             /* Now format each of the relevant things ... */
 369
 370             snprintf(col2, sizeof(col2), "%s%s%s%s%s%s(%0X)",
 371                      (st1.st_mode&0x20?"A":""),
 372                      (st1.st_mode&0x10?"D":""),
 373                      (st1.st_mode&0x08?"V":""),
 374                      (st1.st_mode&0x04?"S":""),
 375                      (st1.st_mode&0x02?"H":""),
 376                      (st1.st_mode&0x01?"R":""),
 377                      st1.st_mode);
 378             snprintf(col3, sizeof(col3), "%u", st1.st_size);
 379             snprintf(col4, sizeof(col4), "%s", ctime(&st1.st_ctime));
 380           }
 381         }
 382
 383         break;
 384
 385       default:
 386
 387         break;
 388       }
 389
 390       gtk_clist_append(GTK_CLIST(clist), rowdata);
 391
 392       (char *)dirp += dirlen;
 393       err -= dirlen;
 394
 395     }
 396
 397   }
 398
 399 }
 400
 401 static void cb_selection_changed( GtkWidget *tree )
 402 {
 403   GList *i;
 404
 405   g_print ("selection_change called for tree %p\n", tree);
 406   g_print ("selected objects are:\n");
 407
 408   i = GTK_TREE_SELECTION(tree);
 409   while (i){
 410     gchar *name;
 411     GtkLabel *label;
 412     GtkWidget *item;
 413
 414     /* Get a GtkWidget pointer from the list node */
 415     item = GTK_WIDGET (i->data);
 416     label = GTK_LABEL (GTK_BIN (item)->child);
 417     gtk_label_get (label, &name);
 418     g_print ("\t%s on level %d\n", name, GTK_TREE
 419              (item->parent)->level);
 420     i = i->next;
 421   }
 422 }
 423
 424 /*
 425  * Expand or collapse the whole network ...
 426  */
 427 static void cb_wholenet(GtkWidget *item, gchar *signame)
 428 {
 429   GtkWidget *real_tree, *aitem, *subtree;
 430   gchar *name;
 431   GtkLabel *label;
 432   gint dh, err, dirlen;
 433   char dirbuf[512];
 434   struct smbc_dirent *dirp;
 435
 436   label = GTK_LABEL (GTK_BIN (item)->child);
 437   gtk_label_get (label, &name);
 438   g_print ("%s called for item %s->%p, level %d\n", signame, name,
 439            item, GTK_TREE (item->parent)->level);
 440
 441   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
 442
 443     if ((dh = smbc_opendir("smb://")) < 0) { /* Handle error */
 444
 445       g_print("cb_wholenet: Could not open dir smbc://, %s\n",
 446               strerror(errno));
 447
 448       gtk_main_quit();
 449
 450       return;
 451
 452     }
 453
 454     real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
 455
 456     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 457                                 sizeof(dirbuf))) != 0) {
 458
 459       if (err < 0) { /* An error, report it */
 460
 461         g_print("cb_wholenet: Could not read dir smbc://, %s\n",
 462                 strerror(errno));
 463
 464         gtk_main_quit();
 465
 466         return;
 467
 468       }
 469
 470       dirp = (struct smbc_dirent *)dirbuf;
 471
 472       while (err > 0) {
 473         struct tree_data *my_data;
 474
 475         dirlen = dirp->dirlen;
 476
 477         my_data = make_tree_data(dirp->smbc_type, dirp->name);
 478
 479         aitem = gtk_tree_item_new_with_label(dirp->name);
 480
 481         /* Connect all GtkItem:: and GtkTreeItem:: signals */
 482         gtk_signal_connect (GTK_OBJECT(aitem), "select",
 483                             GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 484         gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
 485                             GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 486         gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
 487                             GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 488         gtk_signal_connect (GTK_OBJECT(aitem), "expand",
 489                             GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
 490         gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
 491                             GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
 492
 493         gtk_tree_append (GTK_TREE(real_tree), aitem);
 494         /* Show it - this can be done at any time */
 495         gtk_widget_show (aitem);
 496
 497         gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
 498
 499         fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 500
 501         subtree = gtk_tree_new();
 502
 503         gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
 504
 505         (char *)dirp += dirlen;
 506         err -= dirlen;
 507
 508       }
 509
 510     }
 511
 512     smbc_closedir(dh);
 513
 514   }
 515
 516 }
 517
 518 /* Should put up a dialog box to ask the user for username and password */
 519
 520 static void
 521 auth_fn(const char *server, const char *share,
 522         char *workgroup, int wgmaxlen, char *username, int unmaxlen,
 523         char *password, int pwmaxlen)
 524 {
 525
 526    strncpy(username, "test", unmaxlen);
 527    strncpy(password, "test", pwmaxlen);
 528
 529 }
 530
 531 static char *col_titles[] = {
 532   "Name", "Attributes", "Size", "Creation Date",
 533 };
 534
 535 int main( int   argc,
 536           char *argv[] )
 537 {
 538   GtkWidget *window, *scrolled_win, *scrolled_win2, *tree;
 539   GtkWidget *subtree, *item, *main_hbox, *r_pane, *l_pane;
 540   gint err, dh;
 541   gint i;
 542   char dirbuf[512];
 543   struct smbc_dirent *dirp;
 544
 545   gtk_init (&argc, &argv);
 546
 547   /* Init the smbclient library */
 548
 549   err = smbc_init(auth_fn, 10);
 550
 551   /* a generic toplevel window */
 552   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 553   gtk_widget_set_name(window, "main browser window");
 554   gtk_signal_connect (GTK_OBJECT(window), "delete_event",
 555                       GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
 556   gtk_window_set_title(GTK_WINDOW(window), "The Linux Windows Network Browser");
 557   gtk_widget_set_usize(GTK_WIDGET(window), 750, -1);
 558   gtk_container_set_border_width (GTK_CONTAINER(window), 5);
 559
 560   gtk_widget_show (window);
 561
 562   /* A container for the two panes ... */
 563
 564   main_hbox = gtk_hbox_new(FALSE, 1);
 565   gtk_container_border_width(GTK_CONTAINER(main_hbox), 1);
 566   gtk_container_add(GTK_CONTAINER(window), main_hbox);
 567
 568   gtk_widget_show(main_hbox);
 569
 570   l_pane = gtk_hpaned_new();
 571   gtk_paned_gutter_size(GTK_PANED(l_pane), (GTK_PANED(l_pane))->handle_size);
 572   r_pane = gtk_hpaned_new();
 573   gtk_paned_gutter_size(GTK_PANED(r_pane), (GTK_PANED(r_pane))->handle_size);
 574   gtk_container_add(GTK_CONTAINER(main_hbox), l_pane);
 575   gtk_widget_show(l_pane);
 576   /*gtk_container_add(GTK_CONTAINER(main_hbox), r_pane);
 577     gtk_widget_show(r_pane); */
 578
 579
 580   /* A generic scrolled window */
 581   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
 582   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
 583                                   GTK_POLICY_AUTOMATIC,
 584                                   GTK_POLICY_AUTOMATIC);
 585   gtk_widget_set_usize (scrolled_win, 150, 200);
 586   gtk_container_add (GTK_CONTAINER(l_pane), scrolled_win);
 587   gtk_widget_show (scrolled_win);
 588
 589   /* Another generic scrolled window */
 590   scrolled_win2 = gtk_scrolled_window_new (NULL, NULL);
 591   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win2),
 592                                   GTK_POLICY_AUTOMATIC,
 593                                   GTK_POLICY_AUTOMATIC);
 594   gtk_widget_set_usize (scrolled_win2, 150, 200);
 595   gtk_paned_add2 (GTK_PANED(l_pane), scrolled_win2);
 596   gtk_widget_show (scrolled_win2);
 597
 598   /* Create the root tree */
 599   tree = gtk_tree_new();
 600   g_print ("root tree is %p\n", tree);
 601   /* connect all GtkTree:: signals */
 602   gtk_signal_connect (GTK_OBJECT(tree), "select_child",
 603                       GTK_SIGNAL_FUNC(cb_select_child), tree);
 604   gtk_signal_connect (GTK_OBJECT(tree), "unselect_child",
 605                       GTK_SIGNAL_FUNC(cb_unselect_child), tree);
 606   gtk_signal_connect (GTK_OBJECT(tree), "selection_changed",
 607                       GTK_SIGNAL_FUNC(cb_selection_changed), tree);
 608   /* Add it to the scrolled window */
 609   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled_win),
 610                                          tree);
 611   /* Set the selection mode */
 612   gtk_tree_set_selection_mode (GTK_TREE(tree),
 613                                GTK_SELECTION_MULTIPLE);
 614   /* Show it */
 615   gtk_widget_show (tree);
 616
 617   /* Now, create a clist and attach it to the second pane */
 618
 619   clist = gtk_clist_new_with_titles(4, col_titles);
 620
 621   gtk_container_add (GTK_CONTAINER(scrolled_win2), clist);
 622
 623   gtk_widget_show(clist);
 624
 625   /* Now, build the top level display ... */
 626
 627   if ((dh = smbc_opendir("smb:///")) < 0) {
 628
 629     fprintf(stderr, "Could not list default workgroup: smb:///: %s\n",
 630             strerror(errno));
 631
 632     exit(1);
 633
 634   }
 635
 636   /* Create a tree item for Whole Network */
 637
 638   item = gtk_tree_item_new_with_label ("Whole Network");
 639   /* Connect all GtkItem:: and GtkTreeItem:: signals */
 640   gtk_signal_connect (GTK_OBJECT(item), "select",
 641                       GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 642   gtk_signal_connect (GTK_OBJECT(item), "deselect",
 643                       GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 644   gtk_signal_connect (GTK_OBJECT(item), "toggle",
 645                       GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 646   gtk_signal_connect (GTK_OBJECT(item), "expand",
 647                       GTK_SIGNAL_FUNC(cb_wholenet), "expand");
 648   gtk_signal_connect (GTK_OBJECT(item), "collapse",
 649                       GTK_SIGNAL_FUNC(cb_wholenet), "collapse");
 650   /* Add it to the parent tree */
 651   gtk_tree_append (GTK_TREE(tree), item);
 652   /* Show it - this can be done at any time */
 653   gtk_widget_show (item);
 654
 655   subtree = gtk_tree_new();  /* A subtree for Whole Network */
 656
 657   gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
 658
 659   gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
 660                       GTK_SIGNAL_FUNC(cb_select_child), tree);
 661   gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
 662                       GTK_SIGNAL_FUNC(cb_unselect_child), tree);
 663
 664   /* Now, get the items in smb:/// and add them to the tree */
 665
 666   dirp = (struct smbc_dirent *)dirbuf;
 667
 668   while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 669                               sizeof(dirbuf))) != 0) {
 670
 671     if (err < 0) { /* Handle the error */
 672
 673       fprintf(stderr, "Could not read directory for smbc:///: %s\n",
 674               strerror(errno));
 675
 676       exit(1);
 677
 678     }
 679
 680     fprintf(stdout, "Dir len: %u\n", err);
 681
 682     while (err > 0) { /* Extract each entry and make a sub-tree */
 683       struct tree_data *my_data;
 684       int dirlen = dirp->dirlen;
 685
 686       my_data = make_tree_data(dirp->smbc_type, dirp->name);
 687
 688       item = gtk_tree_item_new_with_label(dirp->name);
 689       /* Connect all GtkItem:: and GtkTreeItem:: signals */
 690       gtk_signal_connect (GTK_OBJECT(item), "select",
 691                           GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 692       gtk_signal_connect (GTK_OBJECT(item), "deselect",
 693                           GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 694       gtk_signal_connect (GTK_OBJECT(item), "toggle",
 695                           GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 696       gtk_signal_connect (GTK_OBJECT(item), "expand",
 697                           GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
 698       gtk_signal_connect (GTK_OBJECT(item), "collapse",
 699                           GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
 700       /* Add it to the parent tree */
 701       gtk_tree_append (GTK_TREE(tree), item);
 702       /* Show it - this can be done at any time */
 703       gtk_widget_show (item);
 704
 705       gtk_object_set_user_data(GTK_OBJECT(item), (gpointer)my_data);
 706
 707       fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 708
 709       subtree = gtk_tree_new();
 710
 711       gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
 712
 713       gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
 714                           GTK_SIGNAL_FUNC(cb_select_child), tree);
 715       gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
 716                           GTK_SIGNAL_FUNC(cb_unselect_child), tree);
 717
 718       (char *)dirp += dirlen;
 719       err -= dirlen;
 720
 721     }
 722
 723   }
 724
 725   smbc_closedir(dh); /* FIXME, check for error :-) */
 726
 727   /* Show the window and loop endlessly */
 728   gtk_main();
 729   return 0;
 730 }
 731 /* example-end */