source: vendor/3.5.10/source4/client/tree.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

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