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 3 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, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 /* example-gtk+ application, ripped off from the gtk+ tree.c sample */
  24
  25 #include <stdio.h>
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <gtk/gtk.h>
  30 #include "libsmbclient.h"
  31
  32 static GtkWidget *clist;
  33
  34 struct tree_data {
  35
  36         guint32 type;    /* Type of tree item, an SMBC_TYPE */
  37         char name[256];  /* May need to change this later   */
  38
  39 };
  40
  41 void error_message(gchar *message) {
  42
  43         GtkWidget *dialog, *label, *okay_button;
  44
  45         /* Create the widgets */
  46
  47         dialog = gtk_dialog_new();
  48         gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
  49         label = gtk_label_new (message);
  50         okay_button = gtk_button_new_with_label("Okay");
  51
  52         /* Ensure that the dialog box is destroyed when the user clicks ok. */
  53
  54         gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
  55                                    GTK_SIGNAL_FUNC (gtk_widget_destroy),
  56                                    GTK_OBJECT(dialog));
  57         gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
  58                            okay_button);
  59
  60         /* Add the label, and show everything we've added to the dialog. */
  61
  62         gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
  63                            label);
  64         gtk_widget_show_all (dialog);
  65 }
  66
  67 /*
  68  * We are given a widget, and we want to retrieve its URL so we
  69  * can do a directory listing.
  70  *
  71  * We walk back up the tree, picking up pieces until we hit a server or
  72  * workgroup type and return a path from there
  73  */
  74
  75 static char path_string[1024];
  76
  77 char *get_path(GtkWidget *item)
  78 {
  79         GtkWidget *p = item;
  80         struct tree_data *pd;
  81         char *comps[1024];  /* We keep pointers to the components here */
  82         int i = 0, j, level,type;
  83
  84         /* Walk back up the tree, getting the private data */
  85
  86         level = GTK_TREE(item->parent)->level;
  87
  88         /* Pick up this item's component info */
  89
  90         pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(item));
  91
  92         comps[i++] = pd->name;
  93         type = pd->type;
  94
  95         while (level > 0 && type != SMBC_SERVER && type != SMBC_WORKGROUP) {
  96
  97                 /* Find the parent and extract the data etc ... */
  98
  99                 p = GTK_WIDGET(p->parent);
 100                 p = GTK_WIDGET(GTK_TREE(p)->tree_owner);
 101
 102                 pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(p));
 103
 104                 level = GTK_TREE(item->parent)->level;
 105
 106                 comps[i++] = pd->name;
 107                 type = pd->type;
 108
 109         }
 110
 111         /*
 112          * Got a list of comps now, should check that we did not hit a workgroup
 113          * when we got other things as well ... Later
 114          *
 115          * Now, build the path
 116          */
 117
 118         snprintf(path_string, sizeof(path_string), "smb:/");
 119
 120         for (j = i - 1; j >= 0; j--) {
 121
 122                 strncat(path_string, "/", sizeof(path_string) - strlen(path_string));
 123                 strncat(path_string, comps[j], sizeof(path_string) - strlen(path_string));
 124
 125         }
 126
 127         fprintf(stdout, "Path string = %s\n", path_string);
 128
 129         return path_string;
 130
 131 }
 132
 133 struct tree_data *make_tree_data(guint32 type, const char *name)
 134 {
 135         struct tree_data *p = (struct tree_data *)malloc(sizeof(struct tree_data));
 136
 137         if (p) {
 138
 139                 p->type = type;
 140                 strncpy(p->name, name, sizeof(p->name));
 141
 142         }
 143
 144         return p;
 145
 146 }
 147
 148 /* Note that this is called every time the user clicks on an item,
 149    whether it is already selected or not. */
 150 static void cb_select_child (GtkWidget *root_tree, GtkWidget *child,
 151                              GtkWidget *subtree)
 152 {
 153         gint dh, err, dirlen;
 154         char dirbuf[512];
 155         struct smbc_dirent *dirp;
 156         struct stat st1;
 157         char path[1024], path1[1024];
 158
 159         g_print ("select_child called for root tree %p, subtree %p, child %p\n",
 160                  root_tree, subtree, child);
 161
 162         /* Now, figure out what it is, and display it in the clist ... */
 163
 164         gtk_clist_clear(GTK_CLIST(clist));  /* Clear the CLIST */
 165
 166         /* Now, get the private data for the subtree */
 167
 168         strncpy(path, get_path(child), 1024);
 169
 170         if ((dh = smbc_opendir(path)) < 0) { /* Handle error */
 171
 172                 g_print("cb_select_child: Could not open dir %s, %s\n", path,
 173                         strerror(errno));
 174
 175                 gtk_main_quit();
 176
 177                 return;
 178
 179         }
 180
 181         while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 182                                     sizeof(dirbuf))) != 0) {
 183
 184                 if (err < 0) {
 185
 186                         g_print("cb_select_child: Could not read dir %s, %s\n", path,
 187                                 strerror(errno));
 188
 189                         gtk_main_quit();
 190
 191                         return;
 192
 193                 }
 194
 195                 dirp = (struct smbc_dirent *)dirbuf;
 196
 197                 while (err > 0) {
 198                         gchar col1[128], col2[128], col3[128], col4[128];
 199                         gchar *rowdata[4] = {col1, col2, col3, col4};
 200
 201                         dirlen = dirp->dirlen;
 202
 203                         /* Format each of the items ... */
 204
 205                         strncpy(col1, dirp->name, 128);
 206
 207                         col2[0] = col3[0] = col4[0] = (char)0;
 208
 209                         switch (dirp->smbc_type) {
 210
 211                         case SMBC_WORKGROUP:
 212
 213                                 break;
 214
 215                         case SMBC_SERVER:
 216
 217                                 strncpy(col2, (dirp->comment?dirp->comment:""), 128);
 218
 219                                 break;
 220
 221                         case SMBC_FILE_SHARE:
 222
 223                                 strncpy(col2, (dirp->comment?dirp->comment:""), 128);
 224
 225                                 break;
 226
 227                         case SMBC_PRINTER_SHARE:
 228
 229                                 strncpy(col2, (dirp->comment?dirp->comment:""), 128);
 230                                 break;
 231
 232                         case SMBC_COMMS_SHARE:
 233
 234                                 break;
 235
 236                         case SMBC_IPC_SHARE:
 237
 238                                 break;
 239
 240                         case SMBC_DIR:
 241                         case SMBC_FILE:
 242
 243                                 /* Get stats on the file/dir and see what we have */
 244
 245                                 if ((strcmp(dirp->name, ".") != 0) &&
 246                                     (strcmp(dirp->name, "..") != 0)) {
 247
 248                                         strncpy(path1, path, sizeof(path1));
 249                                         strncat(path1, "/", sizeof(path) - strlen(path));
 250                                         strncat(path1, dirp->name, sizeof(path) - strlen(path));
 251
 252                                         if (smbc_stat(path1, &st1) < 0) {
 253
 254                                                 if (errno != EBUSY) {
 255
 256                                                         g_print("cb_select_child: Could not stat file %s, %s\n", path1,
 257                                                                 strerror(errno));
 258
 259                                                         gtk_main_quit();
 260
 261                                                         return;
 262
 263                                                 }
 264                                                 else {
 265
 266                                                         strncpy(col2, "Device or resource busy", sizeof(col2));
 267
 268                                                 }
 269                                         }
 270                                         else {
 271                                                 /* Now format each of the relevant things ... */
 272
 273                                                 snprintf(col2, sizeof(col2), "%c%c%c%c%c%c%c%c%c(%0X)",
 274                                                          (st1.st_mode&S_IRUSR?'r':'-'),
 275                                                          (st1.st_mode&S_IWUSR?'w':'-'),
 276                                                          (st1.st_mode&S_IXUSR?'x':'-'),
 277                                                          (st1.st_mode&S_IRGRP?'r':'-'),
 278                                                          (st1.st_mode&S_IWGRP?'w':'-'),
 279                                                          (st1.st_mode&S_IXGRP?'x':'-'),
 280                                                          (st1.st_mode&S_IROTH?'r':'-'),
 281                                                          (st1.st_mode&S_IWOTH?'w':'-'),
 282                                                          (st1.st_mode&S_IXOTH?'x':'-'),
 283                                                          st1.st_mode);
 284                                                 snprintf(col3, sizeof(col3), "%u", st1.st_size);
 285                                                 snprintf(col4, sizeof(col4), "%s", ctime(&st1.st_mtime));
 286                                         }
 287                                 }
 288
 289                                 break;
 290
 291                         default:
 292
 293                                 break;
 294                         }
 295
 296                         gtk_clist_append(GTK_CLIST(clist), rowdata);
 297
 298                         dirp = (struct smbc_dirent *) ((char *) dirp + dirlen);
 299                         err -= dirlen;
 300
 301                 }
 302
 303         }
 304
 305 }
 306
 307 /* Note that this is never called */
 308 static void cb_unselect_child( GtkWidget *root_tree,
 309                                GtkWidget *child,
 310                                GtkWidget *subtree )
 311 {
 312         g_print ("unselect_child called for root tree %p, subtree %p, child %p\n",
 313                  root_tree, subtree, child);
 314 }
 315
 316 /* for all the GtkItem:: and GtkTreeItem:: signals */
 317 static void cb_itemsignal( GtkWidget *item,
 318                            gchar     *signame )
 319 {
 320         GtkWidget *real_tree, *aitem, *subtree;
 321         gchar *name;
 322         GtkLabel *label;
 323         gint dh, err, dirlen, level;
 324         char dirbuf[512];
 325         struct smbc_dirent *dirp;
 326
 327         label = GTK_LABEL (GTK_BIN (item)->child);
 328         /* Get the text of the label */
 329         gtk_label_get (label, &name);
 330
 331         level = GTK_TREE(item->parent)->level;
 332
 333         /* Get the level of the tree which the item is in */
 334         g_print ("%s called for item %s->%p, level %d\n", signame, name,
 335                  item, GTK_TREE (item->parent)->level);
 336
 337         real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
 338
 339         if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
 340                 char server[128];
 341
 342                 if ((dh = smbc_opendir(get_path(item))) < 0) { /* Handle error */
 343                         gchar errmsg[256];
 344
 345                         g_print("cb_itemsignal: Could not open dir %s, %s\n", get_path(item),
 346                                 strerror(errno));
 347
 348                         snprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not open dir %s, %s\n", get_path(item), strerror(errno));
 349
 350                         error_message(errmsg);
 351
 352                         /*      gtk_main_quit();*/
 353
 354                         return;
 355
 356                 }
 357
 358                 while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 359                                             sizeof(dirbuf))) != 0) {
 360
 361                         if (err < 0) { /* An error, report it */
 362                                 gchar errmsg[256];
 363
 364                                 g_print("cb_itemsignal: Could not read dir smbc://, %s\n",
 365                                         strerror(errno));
 366
 367                                 snprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not read dir smbc://, %s\n", strerror(errno));
 368
 369                                 error_message(errmsg);
 370
 371                                 /*      gtk_main_quit();*/
 372
 373                                 return;
 374
 375                         }
 376
 377                         dirp = (struct smbc_dirent *)dirbuf;
 378
 379                         while (err > 0) {
 380                                 struct tree_data *my_data;
 381
 382                                 dirlen = dirp->dirlen;
 383
 384                                 my_data = make_tree_data(dirp->smbc_type, dirp->name);
 385
 386                                 if (!my_data) {
 387
 388                                         g_print("Could not allocate space for tree_data: %s\n",
 389                                                 dirp->name);
 390
 391                                         gtk_main_quit();
 392                                         return;
 393
 394                                 }
 395
 396                                 aitem = gtk_tree_item_new_with_label(dirp->name);
 397
 398                                 /* Connect all GtkItem:: and GtkTreeItem:: signals */
 399                                 gtk_signal_connect (GTK_OBJECT(aitem), "select",
 400                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 401                                 gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
 402                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 403                                 gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
 404                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 405                                 gtk_signal_connect (GTK_OBJECT(aitem), "expand",
 406                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
 407                                 gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
 408                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
 409                                 /* Add it to the parent tree */
 410                                 gtk_tree_append (GTK_TREE(real_tree), aitem);
 411
 412                                 gtk_widget_show (aitem);
 413
 414                                 gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
 415
 416                                 fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 417
 418                                 if (dirp->smbc_type != SMBC_FILE &&
 419                                     dirp->smbc_type != SMBC_IPC_SHARE &&
 420                                     (strcmp(dirp->name, ".") != 0) &&
 421                                     (strcmp(dirp->name, "..") !=0)){
 422
 423                                         subtree = gtk_tree_new();
 424                                         gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
 425
 426                                         gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
 427                                                            GTK_SIGNAL_FUNC(cb_select_child), real_tree);
 428                                         gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
 429                                                            GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
 430
 431                                 }
 432
 433                                 dirp = (struct smbc_dirent *) ((char *) dirp + dirlen);
 434                                 err -= dirlen;
 435
 436                         }
 437
 438                 }
 439
 440                 smbc_closedir(dh);
 441
 442         }
 443         else if (strncmp(signame, "collapse", 8) == 0) {
 444                 GtkWidget *subtree = gtk_tree_new();
 445
 446                 gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
 447
 448                 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
 449
 450                 gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
 451                                     GTK_SIGNAL_FUNC(cb_select_child), real_tree);
 452                 gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
 453                                     GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
 454
 455         }
 456
 457 }
 458
 459 static void cb_selection_changed( GtkWidget *tree )
 460 {
 461         GList *i;
 462
 463         g_print ("selection_change called for tree %p\n", tree);
 464         g_print ("selected objects are:\n");
 465
 466         i = GTK_TREE_SELECTION(tree);
 467         while (i){
 468                 gchar *name;
 469                 GtkLabel *label;
 470                 GtkWidget *item;
 471
 472                 /* Get a GtkWidget pointer from the list node */
 473                 item = GTK_WIDGET (i->data);
 474                 label = GTK_LABEL (GTK_BIN (item)->child);
 475                 gtk_label_get (label, &name);
 476                 g_print ("\t%s on level %d\n", name, GTK_TREE
 477                          (item->parent)->level);
 478                 i = i->next;
 479         }
 480 }
 481
 482 /*
 483  * Expand or collapse the whole network ...
 484  */
 485 static void cb_wholenet(GtkWidget *item, gchar *signame)
 486 {
 487         GtkWidget *real_tree, *aitem, *subtree;
 488         gchar *name;
 489         GtkLabel *label;
 490         gint dh, err, dirlen;
 491         char dirbuf[512];
 492         struct smbc_dirent *dirp;
 493
 494         label = GTK_LABEL (GTK_BIN (item)->child);
 495         gtk_label_get (label, &name);
 496         g_print ("%s called for item %s->%p, level %d\n", signame, name,
 497                  item, GTK_TREE (item->parent)->level);
 498
 499         real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
 500
 501         if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
 502
 503                 if ((dh = smbc_opendir("smb://")) < 0) { /* Handle error */
 504
 505                         g_print("cb_wholenet: Could not open dir smbc://, %s\n",
 506                                 strerror(errno));
 507
 508                         gtk_main_quit();
 509
 510                         return;
 511
 512                 }
 513
 514                 while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 515                                             sizeof(dirbuf))) != 0) {
 516
 517                         if (err < 0) { /* An error, report it */
 518
 519                                 g_print("cb_wholenet: Could not read dir smbc://, %s\n",
 520                                         strerror(errno));
 521
 522                                 gtk_main_quit();
 523
 524                                 return;
 525
 526                         }
 527
 528                         dirp = (struct smbc_dirent *)dirbuf;
 529
 530                         while (err > 0) {
 531                                 struct tree_data *my_data;
 532
 533                                 dirlen = dirp->dirlen;
 534
 535                                 my_data = make_tree_data(dirp->smbc_type, dirp->name);
 536
 537                                 aitem = gtk_tree_item_new_with_label(dirp->name);
 538
 539                                 /* Connect all GtkItem:: and GtkTreeItem:: signals */
 540                                 gtk_signal_connect (GTK_OBJECT(aitem), "select",
 541                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 542                                 gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
 543                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 544                                 gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
 545                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 546                                 gtk_signal_connect (GTK_OBJECT(aitem), "expand",
 547                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
 548                                 gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
 549                                                     GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
 550
 551                                 gtk_tree_append (GTK_TREE(real_tree), aitem);
 552                                 /* Show it - this can be done at any time */
 553                                 gtk_widget_show (aitem);
 554
 555                                 gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
 556
 557                                 fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 558
 559                                 subtree = gtk_tree_new();
 560
 561                                 gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
 562
 563                                 gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
 564                                                    GTK_SIGNAL_FUNC(cb_select_child), real_tree);
 565                                 gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
 566                                                    GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
 567
 568                                 dirp = (struct smbc_dirent *) ((char *) dirp + dirlen);
 569                                 err -= dirlen;
 570
 571                         }
 572
 573                 }
 574
 575                 smbc_closedir(dh);
 576
 577         }
 578         else { /* Must be collapse ... FIXME ... */
 579                 GtkWidget *subtree = gtk_tree_new();
 580
 581                 gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
 582
 583                 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
 584
 585                 gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
 586                                     GTK_SIGNAL_FUNC(cb_select_child), real_tree);
 587                 gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
 588                                     GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
 589
 590
 591         }
 592
 593 }
 594
 595 /* Should put up a dialog box to ask the user for username and password */
 596
 597 static void
 598 auth_fn(const char *server, const char *share,
 599         char *workgroup, int wgmaxlen, char *username, int unmaxlen,
 600         char *password, int pwmaxlen)
 601 {
 602         strncpy(username, "test", unmaxlen);
 603         strncpy(password, "test", pwmaxlen);
 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 workgroups: 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         while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 748                                     sizeof(dirbuf))) != 0) {
 749
 750                 if (err < 0) { /* Handle the error */
 751
 752                         fprintf(stderr, "Could not read directory for smbc:///: %s\n",
 753                                 strerror(errno));
 754
 755                         exit(1);
 756
 757                 }
 758
 759                 dirp = (struct smbc_dirent *)dirbuf;
 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                         dirp = (struct smbc_dirent *) ((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 */