s3-param: Rename loadparm_s3_context -> loadparm_s3_helpers
[kai/samba.git] / source3 / client / tree.c
index 77f882f1935b29f1647ff4a00551b23a63b37afd..e0b8c91949ad6a1af14f2d5b8c684672fccb4992 100644 (file)
@@ -1,6 +1,5 @@
 /* 
-   Unix SMB/Netbios implementation.
-   Version 2.0
+   Unix SMB/CIFS implementation.
    SMB client GTK+ tree-based application
    Copyright (C) Andrew Tridgell 1998
    Copyright (C) Richard Sharpe 2001
@@ -8,7 +7,7 @@
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
@@ -17,8 +16,7 @@
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 /* example-gtk+ application, ripped off from the gtk+ tree.c sample */
 #include <gtk/gtk.h>
 #include "libsmbclient.h"
 
+static GtkWidget *clist;
+
+struct tree_data {
+
+  guint32 type;    /* Type of tree item, an SMBC_TYPE */
+  char name[256];  /* May need to change this later   */
+
+};
+
+static void tree_error_message(gchar *message) {
+
+  GtkWidget *dialog, *label, *okay_button;
+     
+  /* Create the widgets */
+     
+  dialog = gtk_dialog_new();
+  gtk_window_set_modal(GTK_WINDOW(dialog), True);
+  label = gtk_label_new (message);
+  okay_button = gtk_button_new_with_label("Okay");
+     
+  /* Ensure that the dialog box is destroyed when the user clicks ok. */
+     
+  gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
+                            GTK_SIGNAL_FUNC (gtk_widget_destroy), dialog);
+  gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
+                    okay_button);
+
+  /* Add the label, and show everything we've added to the dialog. */
+
+  gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
+                    label);
+  gtk_widget_show_all (dialog);
+}
+
+/*
+ * We are given a widget, and we want to retrieve its URL so we 
+ * can do a directory listing.
+ *
+ * We walk back up the tree, picking up pieces until we hit a server or
+ * workgroup type and return a path from there
+ */
+
+static char *path_string;
+
+char *get_path(TALLOC_CTX *ctx, GtkWidget *item)
+{
+  GtkWidget *p = item;
+  struct tree_data *pd;
+  char *comps[1024];  /* We keep pointers to the components here */
+  int i = 0, j, level,type;
+
+  /* Walk back up the tree, getting the private data */
+
+  level = GTK_TREE(item->parent)->level;
+
+  /* Pick up this item's component info */
+
+  pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(item));
+
+  comps[i++] = pd->name;
+  type = pd->type;
+
+  while (level > 0 && type != SMBC_SERVER && type != SMBC_WORKGROUP) {
+
+    /* Find the parent and extract the data etc ... */
+
+    p = GTK_WIDGET(p->parent);
+    p = GTK_WIDGET(GTK_TREE(p)->tree_owner);
+
+    pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(p));
+
+    level = GTK_TREE(item->parent)->level;
+
+    comps[i++] = pd->name;
+    type = pd->type;
+
+  }
+
+  /*
+   * Got a list of comps now, should check that we did not hit a workgroup
+   * when we got other things as well ... Later
+   *
+   * Now, build the path
+   */
+
+  TALLOC_FREE(path_string);
+  path_string = talloc_strdup(ctx, "smb:/");
+
+  if (path_string) {
+    for (j = i - 1; j >= 0; j--) {
+      path_string = talloc_asprintf_append(path_string, "/%s", comps[j]);
+    }
+  }
+
+  if (path_string) {
+    fprintf(stdout, "Path string = %s\n", path_string);
+  }
+
+  return path_string;
+
+}
+
+struct tree_data *make_tree_data(guint32 type, const char *name)
+{
+  struct tree_data *p = SMB_MALLOC_P(struct tree_data);
+
+  if (p) {
+
+    p->type = type;
+    strncpy(p->name, name, sizeof(p->name));
+
+  }
+
+  return p;
+
+}
+
+/* Note that this is called every time the user clicks on an item,
+   whether it is already selected or not. */
+static void cb_select_child (GtkWidget *root_tree, GtkWidget *child,
+                            GtkWidget *subtree)
+{
+  gint dh, err, dirlen;
+  char dirbuf[512];
+  struct smbc_dirent *dirp;
+  struct stat st1;
+  char *path;
+  TALLOC_CTX *ctx = talloc_stackframe();
+
+  g_print ("select_child called for root tree %p, subtree %p, child %p\n",
+          root_tree, subtree, child);
+
+  /* Now, figure out what it is, and display it in the clist ... */
+
+  gtk_clist_clear(GTK_CLIST(clist));  /* Clear the CLIST */
+
+  /* Now, get the private data for the subtree */
+
+  path = get_path(ctx, child);
+  if (!path) {
+    gtk_main_quit();
+    TALLOC_FREE(ctx);
+    return;
+  }
+
+  if ((dh = smbc_opendir(path)) < 0) { /* Handle error */
+    g_print("cb_select_child: Could not open dir %s, %s\n", path,
+           strerror(errno));
+    gtk_main_quit();
+    TALLOC_FREE(ctx);
+    return;
+  }
+
+  while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
+                             sizeof(dirbuf))) != 0) {
+    if (err < 0) {
+      g_print("cb_select_child: Could not read dir %s, %s\n", path,
+             strerror(errno));
+      gtk_main_quit();
+      TALLOC_FREE(ctx);
+      return;
+    }
+
+    dirp = (struct smbc_dirent *)dirbuf;
+
+    while (err > 0) {
+      gchar col1[128], col2[128], col3[128], col4[128];
+      gchar *rowdata[4] = {col1, col2, col3, col4};
+
+      dirlen = dirp->dirlen;
+
+      /* Format each of the items ... */
+
+      strncpy(col1, dirp->name, 128);
+
+      col2[0] = col3[0] = col4[0] = (char)0;
+
+      switch (dirp->smbc_type) {
+
+      case SMBC_WORKGROUP:
+
+       break;
+
+      case SMBC_SERVER:
+
+       strncpy(col2, (dirp->comment?dirp->comment:""), 128);
+
+       break;
+
+      case SMBC_FILE_SHARE:
+
+       strncpy(col2, (dirp->comment?dirp->comment:""), 128);
+
+       break;
+
+      case SMBC_PRINTER_SHARE:
+
+       strncpy(col2, (dirp->comment?dirp->comment:""), 128);
+       break;
+
+      case SMBC_COMMS_SHARE:
+
+       break;
+
+      case SMBC_IPC_SHARE:
+
+       break;
+
+      case SMBC_DIR:
+      case SMBC_FILE:
+
+       /* Get stats on the file/dir and see what we have */
+
+       if ((strcmp(dirp->name, ".") != 0) &&
+           (strcmp(dirp->name, "..") != 0)) {
+          char *path1;
+
+         path1 = talloc_asprintf(ctx,
+                             "%s/%s",
+                            path,
+                            dirp->name);
+          if (!path1) {
+             gtk_main_quit();
+              TALLOC_FREE(ctx);
+             return;
+         }
+
+         if (smbc_stat(path1, &st1) < 0) {
+           if (errno != EBUSY) {
+             g_print("cb_select_child: Could not stat file %s, %s\n", path1,
+                     strerror(errno));
+             gtk_main_quit();
+              TALLOC_FREE(ctx);
+             return;
+           } else {
+             strncpy(col2, "Device or resource busy", sizeof(col2));
+           }
+         }
+         else {
+           /* Now format each of the relevant things ... */
+
+           snprintf(col2, sizeof(col2), "%c%c%c%c%c%c%c%c%c(%0X)",
+                    (st1.st_mode&S_IRUSR?'r':'-'),
+                    (st1.st_mode&S_IWUSR?'w':'-'),
+                    (st1.st_mode&S_IXUSR?'x':'-'),
+                    (st1.st_mode&S_IRGRP?'r':'-'),
+                    (st1.st_mode&S_IWGRP?'w':'-'),
+                    (st1.st_mode&S_IXGRP?'x':'-'),
+                    (st1.st_mode&S_IROTH?'r':'-'),
+                    (st1.st_mode&S_IWOTH?'w':'-'),
+                    (st1.st_mode&S_IXOTH?'x':'-'),
+                    st1.st_mode);
+           snprintf(col3, sizeof(col3), "%u", st1.st_size);
+           snprintf(col4, sizeof(col4), "%s", ctime(&st1.st_mtime));
+         }
+       }
+
+       break;
+
+      default:
+
+       break;
+      }
+
+      gtk_clist_append(GTK_CLIST(clist), rowdata);
+
+      (char *)dirp += dirlen;
+      err -= dirlen;
+
+    }
+  }
+  TALLOC_FREE(ctx);
+}
+
+/* Note that this is never called */
+static void cb_unselect_child( GtkWidget *root_tree,
+                               GtkWidget *child,
+                               GtkWidget *subtree )
+{
+  g_print ("unselect_child called for root tree %p, subtree %p, child %p\n",
+          root_tree, subtree, child);
+}
+
 /* for all the GtkItem:: and GtkTreeItem:: signals */
 static void cb_itemsignal( GtkWidget *item,
                            gchar     *signame )
@@ -39,8 +320,6 @@ static void cb_itemsignal( GtkWidget *item,
   char dirbuf[512];
   struct smbc_dirent *dirp;
   
-  /* It's a Bin, so it has one child, which we know to be a
-     label, so get that */
   label = GTK_LABEL (GTK_BIN (item)->child);
   /* Get the text of the label */
   gtk_label_get (label, &name);
@@ -51,47 +330,41 @@ static void cb_itemsignal( GtkWidget *item,
   g_print ("%s called for item %s->%p, level %d\n", signame, name,
           item, GTK_TREE (item->parent)->level);
 
+  real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
+
   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
     char server[128];
 
-    if (level>0) {
-      gchar *sname;
-      GtkLabel *l2;
-      GtkWidget *p = GTK_WIDGET(item->parent);
-
-      p = GTK_TREE(p)->tree_owner;
-
-      l2 = GTK_LABEL(GTK_BIN(p)->child);
-
-      gtk_label_get(l2, &sname);
-      slprintf(server, 128, "smb://%s/%s", sname, name);
+    if ((dh = smbc_opendir(get_path(item))) < 0) { /* Handle error */
+      gchar errmsg[256];
 
-    }
-    else
-      slprintf(server, 128, "smb://%s", name);
+      g_print("cb_itemsignal: Could not open dir %s, %s\n", get_path(item), 
+             strerror(errno));
 
-    if ((dh = smbc_opendir(server)) < 0) { /* Handle error */
+      slprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not open dir %s, %s\n", get_path(item), strerror(errno));
 
-      g_print("cb_wholenet: Could not open dir %s, %s\n", server, 
-             strerror(errno));
+      tree_error_message(errmsg);
 
-      gtk_main_quit();
+      /*      gtk_main_quit();*/
 
       return;
 
     }
 
-    real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
-
     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
                                sizeof(dirbuf))) != 0) {
 
       if (err < 0) { /* An error, report it */
+       gchar errmsg[256];
 
-       g_print("cb_wholenet: Could not read dir smbc://, %s\n",
+       g_print("cb_itemsignal: Could not read dir smbc://, %s\n",
                strerror(errno));
 
-       gtk_main_quit();
+       slprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not read dir smbc://, %s\n", strerror(errno));
+
+       tree_error_message(errmsg);
+
+       /*      gtk_main_quit();*/
 
        return;
 
@@ -100,9 +373,21 @@ static void cb_itemsignal( GtkWidget *item,
       dirp = (struct smbc_dirent *)dirbuf;
 
       while (err > 0) {
+       struct tree_data *my_data;
+
+       dirlen = dirp->dirlen;
+
+       my_data = make_tree_data(dirp->smbc_type, dirp->name);
+
+       if (!my_data) {
+
+         g_print("Could not allocate space for tree_data: %s\n",
+                 dirp->name);
 
-       dirlen = sizeof(struct smbc_dirent) + dirp->namelen +
-         dirp->commentlen + 1;
+         gtk_main_quit();
+         return;
+
+       }
 
        aitem = gtk_tree_item_new_with_label(dirp->name);
 
@@ -119,14 +404,27 @@ static void cb_itemsignal( GtkWidget *item,
                            GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
        /* Add it to the parent tree */
        gtk_tree_append (GTK_TREE(real_tree), aitem);
-       /* Show it - this can be done at any time */
+
        gtk_widget_show (aitem);
 
+       gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
+
        fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 
-       subtree = gtk_tree_new();
+       if (dirp->smbc_type != SMBC_FILE &&
+           dirp->smbc_type != SMBC_IPC_SHARE &&
+           (strcmp(dirp->name, ".") != 0) && 
+           (strcmp(dirp->name, "..") !=0)){
+         
+         subtree = gtk_tree_new();
+         gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
 
-       gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
+         gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
+                            GTK_SIGNAL_FUNC(cb_select_child), real_tree);
+         gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
+                            GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
+
+       }
 
        (char *)dirp += dirlen;
        err -= dirlen;
@@ -138,25 +436,20 @@ static void cb_itemsignal( GtkWidget *item,
     smbc_closedir(dh);   
 
   }
+  else if (strncmp(signame, "collapse", 8) == 0) {
+    GtkWidget *subtree = gtk_tree_new();
 
-}
+    gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
 
-/* Note that this is never called */
-static void cb_unselect_child( GtkWidget *root_tree,
-                               GtkWidget *child,
-                               GtkWidget *subtree )
-{
-  g_print ("unselect_child called for root tree %p, subtree %p, child %p\n",
-          root_tree, subtree, child);
-}
+    gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
+
+    gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
+                       GTK_SIGNAL_FUNC(cb_select_child), real_tree);
+    gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
+                       GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
+
+  }
 
-/* Note that this is called every time the user clicks on an item,
-   whether it is already selected or not. */
-static void cb_select_child (GtkWidget *root_tree, GtkWidget *child,
-                            GtkWidget *subtree)
-{
-  g_print ("select_child called for root tree %p, subtree %p, child %p\n",
-          root_tree, subtree, child);
 }
 
 static void cb_selection_changed( GtkWidget *tree )
@@ -199,6 +492,8 @@ static void cb_wholenet(GtkWidget *item, gchar *signame)
   g_print ("%s called for item %s->%p, level %d\n", signame, name,
           item, GTK_TREE (item->parent)->level);
 
+  real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
+
   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
 
     if ((dh = smbc_opendir("smb://")) < 0) { /* Handle error */
@@ -212,8 +507,6 @@ static void cb_wholenet(GtkWidget *item, gchar *signame)
 
     }
 
-    real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
-
     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
                                sizeof(dirbuf))) != 0) {
 
@@ -231,9 +524,11 @@ static void cb_wholenet(GtkWidget *item, gchar *signame)
       dirp = (struct smbc_dirent *)dirbuf;
 
       while (err > 0) {
+       struct tree_data *my_data;
 
-       dirlen = sizeof(struct smbc_dirent) + dirp->namelen +
-         dirp->commentlen + 1;
+       dirlen = dirp->dirlen;
+
+       my_data = make_tree_data(dirp->smbc_type, dirp->name);
 
        aitem = gtk_tree_item_new_with_label(dirp->name);
 
@@ -253,12 +548,19 @@ static void cb_wholenet(GtkWidget *item, gchar *signame)
        /* Show it - this can be done at any time */
        gtk_widget_show (aitem);
 
+       gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
+
        fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 
        subtree = gtk_tree_new();
 
        gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
 
+       gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
+                          GTK_SIGNAL_FUNC(cb_select_child), real_tree);
+       gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
+                          GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
+
        (char *)dirp += dirlen;
        err -= dirlen;
 
@@ -269,98 +571,109 @@ static void cb_wholenet(GtkWidget *item, gchar *signame)
     smbc_closedir(dh);   
 
   }
+  else { /* Must be collapse ... FIXME ... */
+    GtkWidget *subtree = gtk_tree_new();
 
-  /* Create this item's subtree */
-  /*  subtree = gtk_tree_new();
-  g_print ("-> item %s->%p, subtree %p\n", "Whole Network", item,
-          subtree);
+    gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
 
-  /* This is still necessary if you want these signals to be called
-     for the subtree's children.  Note that selection_change will be 
-     signalled for the root tree regardless. */
-  /*  gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
-                     GTK_SIGNAL_FUNC(cb_select_child), subtree);
+    gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
+
+    gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
+                       GTK_SIGNAL_FUNC(cb_select_child), real_tree);
     gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
-                       GTK_SIGNAL_FUNC(cb_unselect_child), subtree);
-    /* This has absolutely no effect, because it is completely ignored 
-       in subtrees */
-  /*    gtk_tree_set_selection_mode (GTK_TREE(subtree),
-                                GTK_SELECTION_SINGLE);
-    /* Neither does this, but for a rather different reason - the
-       view_mode and view_line values of a tree are propagated to
-       subtrees when they are mapped.  So, setting it later on would
-       actually have a (somewhat unpredictable) effect */
-  /*    gtk_tree_set_view_mode (GTK_TREE(subtree), GTK_TREE_VIEW_ITEM);
-    /* Set this item's subtree - note that you cannot do this until
-       AFTER the item has been added to its parent tree! */
-  /*    gtk_tree_item_set_subtree (GTK_TREE_ITEM(item), subtree);
-
-    for (j = 0; j < 5; j++){
-      GtkWidget *subitem;
-
-      /* Create a subtree item, in much the same way */
-  /*      subitem = gtk_tree_item_new_with_label (itemnames[j]);
-      /* Connect all GtkItem:: and GtkTreeItem:: signals */
-  /*      gtk_signal_connect (GTK_OBJECT(subitem), "select",
-                         GTK_SIGNAL_FUNC(cb_itemsignal), "select");
-      gtk_signal_connect (GTK_OBJECT(subitem), "deselect",
-                         GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
-      gtk_signal_connect (GTK_OBJECT(subitem), "toggle",
-                         GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
-      gtk_signal_connect (GTK_OBJECT(subitem), "expand",
-                         GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
-      gtk_signal_connect (GTK_OBJECT(subitem), "collapse",
-                         GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
-      g_print ("-> -> item %s->%p\n", itemnames[j], subitem);
-      /* Add it to its parent tree */
-  /*      gtk_tree_append (GTK_TREE(subtree), subitem);
-      /* Show it */
-  /*      gtk_widget_show (subitem);
-    }
-  */
+                       GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
+
+
+  }
+
 }
 
+/* Should put up a dialog box to ask the user for username and password */
+
 static void 
-auth_fn(char *server, char *share,
-            char **workgroup, char **username, char **password)
+auth_fn(const char *server, const char *share,
+       char *workgroup, int wgmaxlen, char *username, int unmaxlen,
+       char *password, int pwmaxlen)
 {
 
-  *workgroup = "";
-  *username = "test";
-  *password = "test";
+   strncpy(username, "test", unmaxlen);
+   strncpy(password, "test", pwmaxlen);
 
 }
 
+static char *col_titles[] = {
+  "Name", "Attributes", "Size", "Modification Date",
+};
+
 int main( int   argc,
           char *argv[] )
 {
-  GtkWidget *window, *scrolled_win, *tree;
-  GtkWidget *subtree, *item;
+  GtkWidget *window, *scrolled_win, *scrolled_win2, *tree;
+  GtkWidget *subtree, *item, *main_hbox, *r_pane, *l_pane;
   gint err, dh;
   gint i;
   char dirbuf[512];
   struct smbc_dirent *dirp;
+  TALLOC_CTX *frame = talloc_stackframe();
 
   gtk_init (&argc, &argv);
 
   /* Init the smbclient library */
 
-  err = smbc_init(auth_fn, "", 10);
+  err = smbc_init(auth_fn, 10);
+
+  /* Print an error response ... */
+
+  if (err < 0) {
+
+    fprintf(stderr, "smbc_init returned %s (%i)\nDo you have a ~/.smb/smb.conf file?\n", strerror(errno), errno);
+    exit(1);
+
+  }
 
   /* a generic toplevel window */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_widget_set_name(window, "main browser window");
   gtk_signal_connect (GTK_OBJECT(window), "delete_event",
                      GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
+  gtk_window_set_title(GTK_WINDOW(window), "The Linux Windows Network Browser");
+  gtk_widget_set_usize(GTK_WIDGET(window), 750, -1);
   gtk_container_set_border_width (GTK_CONTAINER(window), 5);
 
+  gtk_widget_show (window);
+
+  /* A container for the two panes ... */
+
+  main_hbox = gtk_hbox_new(FALSE, 1);
+  gtk_container_border_width(GTK_CONTAINER(main_hbox), 1);
+  gtk_container_add(GTK_CONTAINER(window), main_hbox);
+
+  gtk_widget_show(main_hbox);
+
+  l_pane = gtk_hpaned_new();
+  gtk_paned_gutter_size(GTK_PANED(l_pane), (GTK_PANED(l_pane))->handle_size);
+  r_pane = gtk_hpaned_new();
+  gtk_paned_gutter_size(GTK_PANED(r_pane), (GTK_PANED(r_pane))->handle_size);
+  gtk_container_add(GTK_CONTAINER(main_hbox), l_pane);
+  gtk_widget_show(l_pane);
+
   /* A generic scrolled window */
   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
                                  GTK_POLICY_AUTOMATIC,
                                  GTK_POLICY_AUTOMATIC);
   gtk_widget_set_usize (scrolled_win, 150, 200);
-  gtk_container_add (GTK_CONTAINER(window), scrolled_win);
+  gtk_container_add (GTK_CONTAINER(l_pane), scrolled_win);
   gtk_widget_show (scrolled_win);
+
+  /* Another generic scrolled window */
+  scrolled_win2 = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win2),
+                                 GTK_POLICY_AUTOMATIC,
+                                 GTK_POLICY_AUTOMATIC);
+  gtk_widget_set_usize (scrolled_win2, 150, 200);
+  gtk_paned_add2 (GTK_PANED(l_pane), scrolled_win2);
+  gtk_widget_show (scrolled_win2);
   
   /* Create the root tree */
   tree = gtk_tree_new();
@@ -381,6 +694,14 @@ int main( int   argc,
   /* Show it */
   gtk_widget_show (tree);
 
+  /* Now, create a clist and attach it to the second pane */
+
+  clist = gtk_clist_new_with_titles(4, col_titles);
+
+  gtk_container_add (GTK_CONTAINER(scrolled_win2), clist);
+
+  gtk_widget_show(clist);
+
   /* Now, build the top level display ... */
 
   if ((dh = smbc_opendir("smb:///")) < 0) {
@@ -415,6 +736,11 @@ int main( int   argc,
 
   gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
 
+  gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
+                     GTK_SIGNAL_FUNC(cb_select_child), tree);
+  gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
+                     GTK_SIGNAL_FUNC(cb_unselect_child), tree);
+
   /* Now, get the items in smb:/// and add them to the tree */
 
   dirp = (struct smbc_dirent *)dirbuf;
@@ -434,9 +760,10 @@ int main( int   argc,
     fprintf(stdout, "Dir len: %u\n", err);
 
     while (err > 0) { /* Extract each entry and make a sub-tree */
+      struct tree_data *my_data;
+      int dirlen = dirp->dirlen;
 
-      int dirlen = sizeof(struct smbc_dirent) + dirp->namelen + 
-       dirp->commentlen + 1;
+      my_data = make_tree_data(dirp->smbc_type, dirp->name);
 
       item = gtk_tree_item_new_with_label(dirp->name);
       /* Connect all GtkItem:: and GtkTreeItem:: signals */
@@ -455,12 +782,19 @@ int main( int   argc,
       /* Show it - this can be done at any time */
       gtk_widget_show (item);
 
+      gtk_object_set_user_data(GTK_OBJECT(item), (gpointer)my_data);
+
       fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
 
       subtree = gtk_tree_new();
 
       gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
 
+      gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
+                         GTK_SIGNAL_FUNC(cb_select_child), tree);
+      gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
+                         GTK_SIGNAL_FUNC(cb_unselect_child), tree);
+
       (char *)dirp += dirlen;
       err -= dirlen;
 
@@ -471,8 +805,8 @@ int main( int   argc,
   smbc_closedir(dh); /* FIXME, check for error :-) */
 
   /* Show the window and loop endlessly */
-  gtk_widget_show (window);
   gtk_main();
+  TALLOC_FREE(frame);
   return 0;
 }
 /* example-end */