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