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 /* for all the GtkItem:: and GtkTreeItem:: signals */
  32 static void cb_itemsignal( GtkWidget *item,
  33                            gchar     *signame )
  34 {
  35   GtkWidget *real_tree, *aitem, *subtree;
  36   gchar *name;
  37   GtkLabel *label;
  38   gint dh, err, dirlen;
  39   char dirbuf[512];
  40   struct smbc_dirent *dirp;
  41
  42   /* It's a Bin, so it has one child, which we know to be a
  43      label, so get that */
  44   label = GTK_LABEL (GTK_BIN (item)->child);
  45   /* Get the text of the label */
  46   gtk_label_get (label, &name);
  47   /* Get the level of the tree which the item is in */
  48   g_print ("%s called for item %s->%p, level %d\n", signame, name,
  49            item, GTK_TREE (item->parent)->level);
  50
  51   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
  52
  53     char server[128];
  54
  55     slprintf(server, 128, "smb://%s", name);
  56
  57     if ((dh = smbc_opendir(server)) < 0) { /* Handle error */
  58
  59       g_print("cb_wholenet: Could not open dir %s, %s\n", server,
  60               strerror(errno));
  61
  62       gtk_main_quit();
  63
  64       return;
  65
  66     }
  67
  68     real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
  69
  70     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
  71                                 sizeof(dirbuf))) != 0) {
  72
  73       if (err < 0) { /* An error, report it */
  74
  75         g_print("cb_wholenet: Could not read dir smbc://, %s\n",
  76                 strerror(errno));
  77
  78         gtk_main_quit();
  79
  80         return;
  81
  82       }
  83
  84       dirp = (struct smbc_dirent *)dirbuf;
  85
  86       while (err > 0) {
  87
  88         dirlen = sizeof(struct smbc_dirent) + dirp->namelen +
  89           dirp->commentlen + 1;
  90
  91         aitem = gtk_tree_item_new_with_label(dirp->name);
  92
  93         /* Connect all GtkItem:: and GtkTreeItem:: signals */
  94         gtk_signal_connect (GTK_OBJECT(aitem), "select",
  95                             GTK_SIGNAL_FUNC(cb_itemsignal), "select");
  96         gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
  97                             GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
  98         gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
  99                             GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 100         gtk_signal_connect (GTK_OBJECT(aitem), "expand",
 101                             GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
 102         gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
 103                             GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
 104         /* Add it to the parent tree */
 105         gtk_tree_append (GTK_TREE(real_tree), aitem);
 106         /* Show it - this can be done at any time */
 107         gtk_widget_show (aitem);
 108
 109         fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 110
 111         subtree = gtk_tree_new();
 112
 113         gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
 114
 115         (char *)dirp += dirlen;
 116         err -= dirlen;
 117
 118       }
 119
 120     }
 121
 122     smbc_closedir(dh);
 123
 124   }
 125
 126 }
 127
 128 /* Note that this is never called */
 129 static void cb_unselect_child( GtkWidget *root_tree,
 130                                GtkWidget *child,
 131                                GtkWidget *subtree )
 132 {
 133   g_print ("unselect_child called for root tree %p, subtree %p, child %p\n",
 134            root_tree, subtree, child);
 135 }
 136
 137 /* Note that this is called every time the user clicks on an item,
 138    whether it is already selected or not. */
 139 static void cb_select_child (GtkWidget *root_tree, GtkWidget *child,
 140                              GtkWidget *subtree)
 141 {
 142   g_print ("select_child called for root tree %p, subtree %p, child %p\n",
 143            root_tree, subtree, child);
 144 }
 145
 146 static void cb_selection_changed( GtkWidget *tree )
 147 {
 148   GList *i;
 149
 150   g_print ("selection_change called for tree %p\n", tree);
 151   g_print ("selected objects are:\n");
 152
 153   i = GTK_TREE_SELECTION(tree);
 154   while (i){
 155     gchar *name;
 156     GtkLabel *label;
 157     GtkWidget *item;
 158
 159     /* Get a GtkWidget pointer from the list node */
 160     item = GTK_WIDGET (i->data);
 161     label = GTK_LABEL (GTK_BIN (item)->child);
 162     gtk_label_get (label, &name);
 163     g_print ("\t%s on level %d\n", name, GTK_TREE
 164              (item->parent)->level);
 165     i = i->next;
 166   }
 167 }
 168
 169 /*
 170  * Expand or collapse the whole network ...
 171  */
 172 static void cb_wholenet(GtkWidget *item, gchar *signame)
 173 {
 174   GtkWidget *real_tree, *aitem, *subtree;
 175   gchar *name;
 176   GtkLabel *label;
 177   gint dh, err, dirlen;
 178   char dirbuf[512];
 179   struct smbc_dirent *dirp;
 180
 181   label = GTK_LABEL (GTK_BIN (item)->child);
 182   gtk_label_get (label, &name);
 183   g_print ("%s called for item %s->%p, level %d\n", signame, name,
 184            item, GTK_TREE (item->parent)->level);
 185
 186   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
 187
 188     if ((dh = smbc_opendir("smb://")) < 0) { /* Handle error */
 189
 190       g_print("cb_wholenet: Could not open dir smbc://, %s\n",
 191               strerror(errno));
 192
 193       gtk_main_quit();
 194
 195       return;
 196
 197     }
 198
 199     real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
 200
 201     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 202                                 sizeof(dirbuf))) != 0) {
 203
 204       if (err < 0) { /* An error, report it */
 205
 206         g_print("cb_wholenet: Could not read dir smbc://, %s\n",
 207                 strerror(errno));
 208
 209         gtk_main_quit();
 210
 211         return;
 212
 213       }
 214
 215       dirp = (struct smbc_dirent *)dirbuf;
 216
 217       while (err > 0) {
 218
 219         dirlen = sizeof(struct smbc_dirent) + dirp->namelen +
 220           dirp->commentlen + 1;
 221
 222         aitem = gtk_tree_item_new_with_label(dirp->name);
 223
 224         /* Connect all GtkItem:: and GtkTreeItem:: signals */
 225         gtk_signal_connect (GTK_OBJECT(aitem), "select",
 226                             GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 227         gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
 228                             GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 229         gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
 230                             GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 231         gtk_signal_connect (GTK_OBJECT(aitem), "expand",
 232                             GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
 233         gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
 234                             GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
 235         /* Add it to the parent tree */
 236         gtk_tree_append (GTK_TREE(real_tree), aitem);
 237         /* Show it - this can be done at any time */
 238         gtk_widget_show (aitem);
 239
 240         fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 241
 242         subtree = gtk_tree_new();
 243
 244         gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
 245
 246         (char *)dirp += dirlen;
 247         err -= dirlen;
 248
 249       }
 250
 251     }
 252
 253     smbc_closedir(dh);
 254
 255   }
 256
 257   /* Create this item's subtree */
 258   /*  subtree = gtk_tree_new();
 259   g_print ("-> item %s->%p, subtree %p\n", "Whole Network", item,
 260            subtree);
 261
 262   /* This is still necessary if you want these signals to be called
 263      for the subtree's children.  Note that selection_change will be
 264      signalled for the root tree regardless. */
 265   /*  gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
 266                       GTK_SIGNAL_FUNC(cb_select_child), subtree);
 267     gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
 268                         GTK_SIGNAL_FUNC(cb_unselect_child), subtree);
 269     /* This has absolutely no effect, because it is completely ignored
 270        in subtrees */
 271   /*    gtk_tree_set_selection_mode (GTK_TREE(subtree),
 272                                  GTK_SELECTION_SINGLE);
 273     /* Neither does this, but for a rather different reason - the
 274        view_mode and view_line values of a tree are propagated to
 275        subtrees when they are mapped.  So, setting it later on would
 276        actually have a (somewhat unpredictable) effect */
 277   /*    gtk_tree_set_view_mode (GTK_TREE(subtree), GTK_TREE_VIEW_ITEM);
 278     /* Set this item's subtree - note that you cannot do this until
 279        AFTER the item has been added to its parent tree! */
 280   /*    gtk_tree_item_set_subtree (GTK_TREE_ITEM(item), subtree);
 281
 282     for (j = 0; j < 5; j++){
 283       GtkWidget *subitem;
 284
 285       /* Create a subtree item, in much the same way */
 286   /*      subitem = gtk_tree_item_new_with_label (itemnames[j]);
 287       /* Connect all GtkItem:: and GtkTreeItem:: signals */
 288   /*      gtk_signal_connect (GTK_OBJECT(subitem), "select",
 289                           GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 290       gtk_signal_connect (GTK_OBJECT(subitem), "deselect",
 291                           GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 292       gtk_signal_connect (GTK_OBJECT(subitem), "toggle",
 293                           GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 294       gtk_signal_connect (GTK_OBJECT(subitem), "expand",
 295                           GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
 296       gtk_signal_connect (GTK_OBJECT(subitem), "collapse",
 297                           GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
 298       g_print ("-> -> item %s->%p\n", itemnames[j], subitem);
 299       /* Add it to its parent tree */
 300   /*      gtk_tree_append (GTK_TREE(subtree), subitem);
 301       /* Show it */
 302   /*      gtk_widget_show (subitem);
 303     }
 304   */
 305 }
 306
 307 static void
 308 auth_fn(char *server, char *share,
 309              char **workgroup, char **username, char **password)
 310 {
 311
 312   /* Do nothing for now ... */
 313
 314 }
 315
 316 int main( int   argc,
 317           char *argv[] )
 318 {
 319   GtkWidget *window, *scrolled_win, *tree;
 320   GtkWidget *subtree, *item;
 321   gint err, dh;
 322   gint i;
 323   char dirbuf[512];
 324   struct smbc_dirent *dirp;
 325
 326   gtk_init (&argc, &argv);
 327
 328   /* Init the smbclient library */
 329
 330   err = smbc_init(auth_fn, "", 10);
 331
 332   /* a generic toplevel window */
 333   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 334   gtk_signal_connect (GTK_OBJECT(window), "delete_event",
 335                       GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
 336   gtk_container_set_border_width (GTK_CONTAINER(window), 5);
 337
 338   /* A generic scrolled window */
 339   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
 340   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
 341                                   GTK_POLICY_AUTOMATIC,
 342                                   GTK_POLICY_AUTOMATIC);
 343   gtk_widget_set_usize (scrolled_win, 150, 200);
 344   gtk_container_add (GTK_CONTAINER(window), scrolled_win);
 345   gtk_widget_show (scrolled_win);
 346
 347   /* Create the root tree */
 348   tree = gtk_tree_new();
 349   g_print ("root tree is %p\n", tree);
 350   /* connect all GtkTree:: signals */
 351   gtk_signal_connect (GTK_OBJECT(tree), "select_child",
 352                       GTK_SIGNAL_FUNC(cb_select_child), tree);
 353   gtk_signal_connect (GTK_OBJECT(tree), "unselect_child",
 354                       GTK_SIGNAL_FUNC(cb_unselect_child), tree);
 355   gtk_signal_connect (GTK_OBJECT(tree), "selection_changed",
 356                       GTK_SIGNAL_FUNC(cb_selection_changed), tree);
 357   /* Add it to the scrolled window */
 358   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled_win),
 359                                          tree);
 360   /* Set the selection mode */
 361   gtk_tree_set_selection_mode (GTK_TREE(tree),
 362                                GTK_SELECTION_MULTIPLE);
 363   /* Show it */
 364   gtk_widget_show (tree);
 365
 366   /* Now, build the top level display ... */
 367
 368   if ((dh = smbc_opendir("smb:///")) < 0) {
 369
 370     fprintf(stderr, "Could not list default workgroup: smb:///: %s\n",
 371             strerror(errno));
 372
 373     exit(1);
 374
 375   }
 376
 377   /* Create a tree item for Whole Network */
 378
 379   item = gtk_tree_item_new_with_label ("Whole Network");
 380   /* Connect all GtkItem:: and GtkTreeItem:: signals */
 381   gtk_signal_connect (GTK_OBJECT(item), "select",
 382                       GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 383   gtk_signal_connect (GTK_OBJECT(item), "deselect",
 384                       GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 385   gtk_signal_connect (GTK_OBJECT(item), "toggle",
 386                       GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 387   gtk_signal_connect (GTK_OBJECT(item), "expand",
 388                       GTK_SIGNAL_FUNC(cb_wholenet), "expand");
 389   gtk_signal_connect (GTK_OBJECT(item), "collapse",
 390                       GTK_SIGNAL_FUNC(cb_wholenet), "collapse");
 391   /* Add it to the parent tree */
 392   gtk_tree_append (GTK_TREE(tree), item);
 393   /* Show it - this can be done at any time */
 394   gtk_widget_show (item);
 395
 396   subtree = gtk_tree_new();  /* A subtree for Whole Network */
 397
 398   gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
 399
 400   /* Now, get the items in smb:/// and add them to the tree */
 401
 402   dirp = (struct smbc_dirent *)dirbuf;
 403
 404   while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
 405                               sizeof(dirbuf))) != 0) {
 406
 407     if (err < 0) { /* Handle the error */
 408
 409       fprintf(stderr, "Could not read directory for smbc:///: %s\n",
 410               strerror(errno));
 411
 412       exit(1);
 413
 414     }
 415
 416     fprintf(stdout, "Dir len: %u\n", err);
 417
 418     while (err > 0) { /* Extract each entry and make a sub-tree */
 419
 420       int dirlen = sizeof(struct smbc_dirent) + dirp->namelen +
 421         dirp->commentlen + 1;
 422
 423       item = gtk_tree_item_new_with_label(dirp->name);
 424       /* Connect all GtkItem:: and GtkTreeItem:: signals */
 425       gtk_signal_connect (GTK_OBJECT(item), "select",
 426                           GTK_SIGNAL_FUNC(cb_itemsignal), "select");
 427       gtk_signal_connect (GTK_OBJECT(item), "deselect",
 428                           GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
 429       gtk_signal_connect (GTK_OBJECT(item), "toggle",
 430                           GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
 431       gtk_signal_connect (GTK_OBJECT(item), "expand",
 432                           GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
 433       gtk_signal_connect (GTK_OBJECT(item), "collapse",
 434                           GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
 435       /* Add it to the parent tree */
 436       gtk_tree_append (GTK_TREE(tree), item);
 437       /* Show it - this can be done at any time */
 438       gtk_widget_show (item);
 439
 440       fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 441
 442       subtree = gtk_tree_new();
 443
 444       gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
 445
 446       (char *)dirp += dirlen;
 447       err -= dirlen;
 448
 449     }
 450
 451   }
 452
 453   smbc_closedir(dh); /* FIXME, check for error :-) */
 454
 455   /* Show the window and loop endlessly */
 456   gtk_widget_show (window);
 457   gtk_main();
 458   return 0;
 459 }
 460 /* example-end */