src/nautilus-connect-server-dialog.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
   2
   3 /*
   4  * Nautilus
   5  *
   6  * Copyright (C) 2003 Red Hat, Inc.
   7  *
   8  * Nautilus is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of the
  11  * License, or (at your option) any later version.
  12  *
  13  * Nautilus 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 GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public
  19  * License along with this program; see the file COPYING.  If not,
  20  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <config.h>
  25 #include "nautilus-connect-server-dialog.h"
  26
  27 #include <string.h>
  28 #include <eel/eel-gtk-macros.h>
  29 #include <eel/eel-stock-dialogs.h>
  30 #include <eel/eel-vfs-extensions.h>
  31 #include <libgnomeui/gnome-help.h>
  32 #include <glib/gi18n.h>
  33 #include <gio/gio.h>
  34 #include <gtk/gtkcelllayout.h>
  35 #include <gtk/gtkcellrenderertext.h>
  36 #include <gtk/gtkcheckbutton.h>
  37 #include <gtk/gtkhbox.h>
  38 #include <gtk/gtkvbox.h>
  39 #include <gtk/gtktable.h>
  40 #include <gtk/gtktreemodel.h>
  41 #include <gtk/gtklabel.h>
  42 #include <gtk/gtkliststore.h>
  43 #include <gtk/gtkstock.h>
  44 #include <gtk/gtkcombobox.h>
  45 #include "nautilus-location-entry.h"
  46 #include <libnautilus-private/nautilus-global-preferences.h>
  47
  48 /* TODO:
  49  * - dns-sd fill out servers
  50  * - pre-fill user?
  51  * - name entry + pre-fill
  52  * - folder browse function
  53  */
  54
  55 /* TODO gio port:
  56  * - see FIXME here
  57  * - see FIXME in nautilus-connect-server-dialog-main.c
  58  */
  59
  60 struct _NautilusConnectServerDialogDetails {
  61         NautilusApplication *application;
  62
  63         GtkWidget *table;
  64
  65         GtkWidget *type_combo;
  66         GtkWidget *uri_entry;
  67         GtkWidget *server_entry;
  68         GtkWidget *share_entry;
  69         GtkWidget *port_entry;
  70         GtkWidget *folder_entry;
  71         GtkWidget *domain_entry;
  72         GtkWidget *user_entry;
  73
  74         GtkWidget *bookmark_check;
  75         GtkWidget *name_entry;
  76 };
  77
  78 static void  nautilus_connect_server_dialog_class_init       (NautilusConnectServerDialogClass *class);
  79 static void  nautilus_connect_server_dialog_init             (NautilusConnectServerDialog      *dialog);
  80
  81 EEL_CLASS_BOILERPLATE (NautilusConnectServerDialog,
  82                        nautilus_connect_server_dialog,
  83                        GTK_TYPE_DIALOG)
  84 enum {
  85         RESPONSE_CONNECT
  86 };
  87
  88 struct MethodInfo {
  89         const char *scheme;
  90         guint flags;
  91 };
  92
  93 /* A collection of flags for MethodInfo.flags */
  94 enum {
  95         DEFAULT_METHOD = 0x00000001,
  96
  97         /* Widgets to display in setup_for_type */
  98         SHOW_SHARE     = 0x00000010,
  99         SHOW_PORT      = 0x00000020,
 100         SHOW_USER      = 0x00000040,
 101         SHOW_DOMAIN    = 0x00000080,
 102
 103         IS_ANONYMOUS   = 0x00001000
 104 };
 105
 106 /* Remember to fill in descriptions below */
 107 static struct MethodInfo methods[] = {
 108         /* FIXME: we need to alias ssh to sftp */
 109         { "sftp",  SHOW_PORT | SHOW_USER },
 110         { "ftp",  SHOW_PORT | SHOW_USER },
 111         { "ftp",  DEFAULT_METHOD | IS_ANONYMOUS | SHOW_PORT},
 112         { "smb",  SHOW_SHARE | SHOW_USER | SHOW_DOMAIN },
 113         { "dav",  SHOW_PORT | SHOW_USER },
 114         /* FIXME: hrm, shouldn't it work? */
 115         { "davs", SHOW_PORT | SHOW_USER },
 116         { NULL,   0 }, /* Custom URI method */
 117 };
 118
 119 /* To get around non constant gettext strings */
 120 static const char*
 121 get_method_description (struct MethodInfo *meth)
 122 {
 123         if (!meth->scheme) {
 124                 return _("Custom Location");
 125         } else if (strcmp (meth->scheme, "sftp") == 0) {
 126                 return _("SSH");
 127         } else if (strcmp (meth->scheme, "ftp") == 0) {
 128                 if (meth->flags & IS_ANONYMOUS) {
 129                         return _("Public FTP");
 130                 } else {
 131                         return _("FTP (with login)");
 132                 }
 133         } else if (strcmp (meth->scheme, "smb") == 0) {
 134                 return _("Windows share");
 135         } else if (strcmp (meth->scheme, "dav") == 0) {
 136                 return _("WebDAV (HTTP)");
 137         } else if (strcmp (meth->scheme, "davs") == 0) {
 138                 return _("Secure WebDAV (HTTPS)");
 139
 140         /* No descriptive text */
 141         } else {
 142                 return meth->scheme;
 143         }
 144 }
 145
 146 static void
 147 nautilus_connect_server_dialog_finalize (GObject *object)
 148 {
 149         NautilusConnectServerDialog *dialog;
 150
 151         dialog = NAUTILUS_CONNECT_SERVER_DIALOG (object);
 152
 153         g_object_unref (dialog->details->uri_entry);
 154         g_object_unref (dialog->details->server_entry);
 155         g_object_unref (dialog->details->share_entry);
 156         g_object_unref (dialog->details->port_entry);
 157         g_object_unref (dialog->details->folder_entry);
 158         g_object_unref (dialog->details->domain_entry);
 159         g_object_unref (dialog->details->user_entry);
 160         g_object_unref (dialog->details->bookmark_check);
 161         g_object_unref (dialog->details->name_entry);
 162
 163         g_free (dialog->details);
 164
 165         EEL_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
 166 }
 167
 168 static void
 169 nautilus_connect_server_dialog_destroy (GtkObject *object)
 170 {
 171         NautilusConnectServerDialog *dialog;
 172
 173         dialog = NAUTILUS_CONNECT_SERVER_DIALOG (object);
 174
 175         EEL_CALL_PARENT (GTK_OBJECT_CLASS, destroy, (object));
 176 }
 177
 178 static void
 179 connect_to_server (NautilusConnectServerDialog *dialog)
 180 {
 181         struct MethodInfo *meth;
 182         char *uri;
 183         GFile *location;
 184         int index;
 185         GtkTreeIter iter;
 186
 187         /* Get our method info */
 188         gtk_combo_box_get_active_iter (GTK_COMBO_BOX (dialog->details->type_combo), &iter);
 189         gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (dialog->details->type_combo)),
 190                             &iter, 0, &index, -1);
 191         g_assert (index < G_N_ELEMENTS (methods) && index >= 0);
 192         meth = &(methods[index]);
 193
 194         if (meth->scheme == NULL) {
 195                 uri = gtk_editable_get_chars (GTK_EDITABLE (dialog->details->uri_entry), 0, -1);
 196                 /* FIXME: we should validate it in some way? */
 197         } else {
 198                 char *user, *port, *initial_path, *server, *folder ,*domain ;
 199                 char *t, *join;
 200                 gboolean free_initial_path, free_user, free_domain, free_port;
 201
 202                 server = gtk_editable_get_chars (GTK_EDITABLE (dialog->details->server_entry), 0, -1);
 203                 if (strlen (server) == 0) {
 204                         eel_show_error_dialog (_("Cannot Connect to Server. You must enter a name for the server."),
 205                                                _("Please enter a name and try again."),
 206                                                GTK_WINDOW (dialog));
 207                         g_free (server);
 208                         return;
 209                 }
 210
 211                 user = "";
 212                 port = "";
 213                 initial_path = "";
 214                 domain = "";
 215                 free_initial_path = FALSE;
 216                 free_user = FALSE;
 217                 free_domain = FALSE;
 218                 free_port = FALSE;
 219
 220                 /* FTP special case */
 221                 if (meth->flags & IS_ANONYMOUS) {
 222                         user = "anonymous";
 223
 224                 /* SMB special case */
 225                 } else if (strcmp (meth->scheme, "smb") == 0) {
 226                         t = gtk_editable_get_chars (GTK_EDITABLE (dialog->details->share_entry), 0, -1);
 227                         initial_path = g_strconcat ("/", t, NULL);
 228                         free_initial_path = TRUE;
 229                         g_free (t);
 230                 }
 231
 232                 if (dialog->details->port_entry->parent != NULL) {
 233                         free_port = TRUE;
 234                         port = gtk_editable_get_chars (GTK_EDITABLE (dialog->details->port_entry), 0, -1);
 235                 }
 236                 folder = gtk_editable_get_chars (GTK_EDITABLE (dialog->details->folder_entry), 0, -1);
 237                 if (dialog->details->user_entry->parent != NULL) {
 238                         free_user = TRUE;
 239
 240                         t = gtk_editable_get_chars (GTK_EDITABLE (dialog->details->user_entry), 0, -1);
 241
 242                         user = g_uri_escape_string (t, G_URI_RESERVED_CHARS_ALLOWED_IN_USERINFO, FALSE);
 243
 244                         g_free (t);
 245                 }
 246                 if (dialog->details->domain_entry->parent != NULL) {
 247                         free_domain = TRUE;
 248
 249                         domain = gtk_editable_get_chars (GTK_EDITABLE (dialog->details->domain_entry), 0, -1);
 250
 251                         if (strlen (domain) != 0) {
 252                                 t = user;
 253
 254                                 user = g_strconcat (domain , ";" , t, NULL);
 255
 256                                 if (free_user) {
 257                                         g_free (t);
 258                                 }
 259
 260                                 free_user = TRUE;
 261                         }
 262                 }
 263
 264                 if (folder[0] != 0 &&
 265                     folder[0] != '/') {
 266                         join = "/";
 267                 } else {
 268                         join = "";
 269                 }
 270
 271                 t = folder;
 272                 folder = g_strconcat (initial_path, join, t, NULL);
 273                 g_free (t);
 274
 275                 t = folder;
 276                 folder = g_uri_escape_string (t, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, FALSE);
 277                 g_free (t);
 278
 279                 uri = g_strdup_printf ("%s://%s%s%s%s%s%s",
 280                                        meth->scheme,
 281                                        user, (user[0] != 0) ? "@" : "",
 282                                        server,
 283                                        (port[0] != 0) ? ":" : "", port,
 284                                        folder);
 285
 286                 if (free_initial_path) {
 287                         g_free (initial_path);
 288                 }
 289                 g_free (server);
 290                 if (free_port) {
 291                         g_free (port);
 292                 }
 293                 g_free (folder);
 294                 if (free_user) {
 295                         g_free (user);
 296                 }
 297                 if (free_domain) {
 298                         g_free (domain);
 299                 }
 300         }
 301
 302         gtk_widget_hide (GTK_WIDGET (dialog));
 303
 304         location = g_file_new_for_uri (uri);
 305         g_free (uri);
 306
 307         /* FIXME: sensitivity */
 308         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->details->bookmark_check))) {
 309                 char *name;
 310                 NautilusBookmark *bookmark;
 311                 NautilusBookmarkList *list;
 312
 313                 name = gtk_editable_get_chars (GTK_EDITABLE (dialog->details->name_entry), 0, -1);
 314                 bookmark = nautilus_bookmark_new (location, strlen (name) ? name : NULL);
 315                 list = nautilus_bookmark_list_new ();
 316                 if (!nautilus_bookmark_list_contains (list, bookmark)) {
 317                         nautilus_bookmark_list_append (list, bookmark);
 318                 }
 319
 320                 g_object_unref (bookmark);
 321                 g_object_unref (list);
 322                 g_free (name);
 323         }
 324
 325         nautilus_connect_server_dialog_present_uri (dialog->details->application,
 326                                                     location,
 327                                                     GTK_WIDGET (dialog));
 328 }
 329
 330 static void
 331 response_callback (NautilusConnectServerDialog *dialog,
 332                    int response_id,
 333                    gpointer data)
 334 {
 335         GError *error;
 336
 337         switch (response_id) {
 338         case RESPONSE_CONNECT:
 339                 connect_to_server (dialog);
 340                 break;
 341         case GTK_RESPONSE_NONE:
 342         case GTK_RESPONSE_DELETE_EVENT:
 343         case GTK_RESPONSE_CANCEL:
 344                 gtk_widget_destroy (GTK_WIDGET (dialog));
 345                 break;
 346         case GTK_RESPONSE_HELP :
 347                 error = NULL;
 348                 gnome_help_display_desktop_on_screen (NULL, "user-guide", "user-guide.xml",
 349                                                       "nautilus-server-connect",
 350                                                       gtk_window_get_screen (GTK_WINDOW (dialog)),
 351                                                       &error);
 352                 if (error) {
 353                         eel_show_error_dialog (_("There was an error displaying help."), error->message,
 354                                                GTK_WINDOW (dialog));
 355                         g_error_free (error);
 356                 }
 357                 break;
 358         default :
 359                 g_assert_not_reached ();
 360         }
 361 }
 362
 363 static void
 364 nautilus_connect_server_dialog_class_init (NautilusConnectServerDialogClass *class)
 365 {
 366         GObjectClass *gobject_class;
 367         GtkObjectClass *object_class;
 368
 369         gobject_class = G_OBJECT_CLASS (class);
 370         gobject_class->finalize = nautilus_connect_server_dialog_finalize;
 371
 372         object_class = GTK_OBJECT_CLASS (class);
 373         object_class->destroy = nautilus_connect_server_dialog_destroy;
 374 }
 375
 376 static void
 377 setup_for_type (NautilusConnectServerDialog *dialog)
 378 {
 379         struct MethodInfo *meth;
 380         int index, i;
 381         GtkWidget *label, *table;
 382         GtkTreeIter iter;
 383
 384         /* Get our method info */
 385         gtk_combo_box_get_active_iter (GTK_COMBO_BOX (dialog->details->type_combo), &iter);
 386         gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (dialog->details->type_combo)),
 387                             &iter, 0, &index, -1);
 388         g_assert (index < G_N_ELEMENTS (methods) && index >= 0);
 389         meth = &(methods[index]);
 390
 391         if (dialog->details->uri_entry->parent != NULL) {
 392                 gtk_container_remove (GTK_CONTAINER (dialog->details->table),
 393                                       dialog->details->uri_entry);
 394         }
 395         if (dialog->details->server_entry->parent != NULL) {
 396                 gtk_container_remove (GTK_CONTAINER (dialog->details->table),
 397                                       dialog->details->server_entry);
 398         }
 399         if (dialog->details->share_entry->parent != NULL) {
 400                 gtk_container_remove (GTK_CONTAINER (dialog->details->table),
 401                                       dialog->details->share_entry);
 402         }
 403         if (dialog->details->port_entry->parent != NULL) {
 404                 gtk_container_remove (GTK_CONTAINER (dialog->details->table),
 405                                       dialog->details->port_entry);
 406         }
 407         if (dialog->details->folder_entry->parent != NULL) {
 408                 gtk_container_remove (GTK_CONTAINER (dialog->details->table),
 409                                       dialog->details->folder_entry);
 410         }
 411         if (dialog->details->user_entry->parent != NULL) {
 412                 gtk_container_remove (GTK_CONTAINER (dialog->details->table),
 413                                       dialog->details->user_entry);
 414         }
 415         if (dialog->details->domain_entry->parent != NULL) {
 416                 gtk_container_remove (GTK_CONTAINER (dialog->details->table),
 417                                       dialog->details->domain_entry);
 418         }
 419         if (dialog->details->bookmark_check->parent != NULL) {
 420                 gtk_container_remove (GTK_CONTAINER (dialog->details->table),
 421                                       dialog->details->bookmark_check);
 422         }
 423         if (dialog->details->name_entry->parent != NULL) {
 424                 gtk_container_remove (GTK_CONTAINER (dialog->details->table),
 425                                       dialog->details->name_entry);
 426         }
 427         /* Destroy all labels */
 428         gtk_container_foreach (GTK_CONTAINER (dialog->details->table),
 429                                (GtkCallback) gtk_widget_destroy, NULL);
 430
 431
 432         i = 1;
 433         table = dialog->details->table;
 434
 435         if (meth->scheme == NULL) {
 436                 label = gtk_label_new_with_mnemonic (_("_Location (URI):"));
 437                 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 438                 gtk_widget_show (label);
 439                 gtk_table_attach (GTK_TABLE (table), label,
 440                                   0, 1,
 441                                   i, i+1,
 442                                   GTK_FILL, GTK_FILL,
 443                                   0, 0);
 444
 445                 gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->details->uri_entry);
 446                 gtk_widget_show (dialog->details->uri_entry);
 447                 gtk_table_attach (GTK_TABLE (table), dialog->details->uri_entry,
 448                                   1, 2,
 449                                   i, i+1,
 450                                   GTK_FILL | GTK_EXPAND, GTK_FILL,
 451                                   0, 0);
 452
 453                 i++;
 454
 455                 goto connection_name;
 456         }
 457
 458         label = gtk_label_new_with_mnemonic (_("_Server:"));
 459         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 460         gtk_widget_show (label);
 461         gtk_table_attach (GTK_TABLE (table), label,
 462                           0, 1,
 463                           i, i+1,
 464                           GTK_FILL, GTK_FILL,
 465                           0, 0);
 466
 467         gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->details->server_entry);
 468         gtk_widget_show (dialog->details->server_entry);
 469         gtk_table_attach (GTK_TABLE (table), dialog->details->server_entry,
 470                           1, 2,
 471                           i, i+1,
 472                           GTK_FILL | GTK_EXPAND, GTK_FILL,
 473                           0, 0);
 474
 475         i++;
 476
 477         label = gtk_label_new (_("Optional information:"));
 478         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 479         gtk_widget_show (label);
 480         gtk_table_attach (GTK_TABLE (table), label,
 481                           0, 2,
 482                           i, i+1,
 483                           GTK_FILL, GTK_FILL,
 484                           0, 0);
 485
 486         i++;
 487
 488         if (meth->flags & SHOW_SHARE) {
 489                 label = gtk_label_new_with_mnemonic (_("_Share:"));
 490                 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 491                 gtk_widget_show (label);
 492                 gtk_table_attach (GTK_TABLE (table), label,
 493                                   0, 1,
 494                                   i, i+1,
 495                                   GTK_FILL, GTK_FILL,
 496                                   0, 0);
 497
 498                 gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->details->share_entry);
 499                 gtk_widget_show (dialog->details->share_entry);
 500                 gtk_table_attach (GTK_TABLE (table), dialog->details->share_entry,
 501                                   1, 2,
 502                                   i, i+1,
 503                                   GTK_FILL | GTK_EXPAND, GTK_FILL,
 504                                   0, 0);
 505
 506                 i++;
 507         }
 508
 509         if (meth->flags & SHOW_PORT) {
 510                 label = gtk_label_new_with_mnemonic (_("_Port:"));
 511                 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 512                 gtk_widget_show (label);
 513                 gtk_table_attach (GTK_TABLE (table), label,
 514                                   0, 1,
 515                                   i, i+1,
 516                                   GTK_FILL, GTK_FILL,
 517                                   0, 0);
 518
 519                 gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->details->port_entry);
 520                 gtk_widget_show (dialog->details->port_entry);
 521                 gtk_table_attach (GTK_TABLE (table), dialog->details->port_entry,
 522                                   1, 2,
 523                                   i, i+1,
 524                                   GTK_FILL | GTK_EXPAND, GTK_FILL,
 525                                   0, 0);
 526
 527                 i++;
 528         }
 529
 530         label = gtk_label_new_with_mnemonic (_("_Folder:"));
 531         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 532         gtk_widget_show (label);
 533         gtk_table_attach (GTK_TABLE (table), label,
 534                           0, 1,
 535                           i, i+1,
 536                           GTK_FILL, GTK_FILL,
 537                           0, 0);
 538
 539         gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->details->folder_entry);
 540         gtk_widget_show (dialog->details->folder_entry);
 541         gtk_table_attach (GTK_TABLE (table), dialog->details->folder_entry,
 542                           1, 2,
 543                           i, i+1,
 544                           GTK_FILL | GTK_EXPAND, GTK_FILL,
 545                           0, 0);
 546
 547         i++;
 548
 549         if (meth->flags & SHOW_USER) {
 550                 label = gtk_label_new_with_mnemonic (_("_User Name:"));
 551                 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 552                 gtk_widget_show (label);
 553                 gtk_table_attach (GTK_TABLE (table), label,
 554                                   0, 1,
 555                                   i, i+1,
 556                                   GTK_FILL, GTK_FILL,
 557                                   0, 0);
 558
 559                 gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->details->user_entry);
 560                 gtk_widget_show (dialog->details->user_entry);
 561                 gtk_table_attach (GTK_TABLE (table), dialog->details->user_entry,
 562                                   1, 2,
 563                                   i, i+1,
 564                                   GTK_FILL | GTK_EXPAND, GTK_FILL,
 565                                   0, 0);
 566
 567                 i++;
 568         }
 569
 570         if (meth->flags & SHOW_DOMAIN) {
 571                 label = gtk_label_new_with_mnemonic (_("_Domain Name:"));
 572                 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 573                 gtk_widget_show (label);
 574                 gtk_table_attach (GTK_TABLE (table), label,
 575                                   0, 1,
 576                                   i, i+1,
 577                                   GTK_FILL, GTK_FILL,
 578                                   0, 0);
 579
 580                 gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->details->domain_entry);
 581                 gtk_widget_show (dialog->details->domain_entry);
 582                 gtk_table_attach (GTK_TABLE (table), dialog->details->domain_entry,
 583                                   1, 2,
 584                                   i, i+1,
 585                                   GTK_FILL | GTK_EXPAND, GTK_FILL,
 586                                   0, 0);
 587
 588                 i++;
 589         }
 590
 591
 592
 593  connection_name:
 594
 595         gtk_widget_show (dialog->details->bookmark_check);
 596         gtk_table_attach (GTK_TABLE (table), dialog->details->bookmark_check,
 597                           0, 1,
 598                           i, i+1,
 599                           GTK_FILL, GTK_FILL,
 600                           0, 0);
 601         i++;
 602
 603         label = gtk_label_new_with_mnemonic (_("Bookmark _name:"));
 604         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 605         gtk_widget_show (label);
 606         gtk_table_attach (GTK_TABLE (table), label,
 607                           0, 1,
 608                           i, i+1,
 609                           GTK_FILL, GTK_FILL,
 610                           0, 0);
 611
 612         gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->details->name_entry);
 613         gtk_widget_show (dialog->details->name_entry);
 614         gtk_table_attach (GTK_TABLE (table), dialog->details->name_entry,
 615                           1, 2,
 616                           i, i+1,
 617                           GTK_FILL | GTK_EXPAND, GTK_FILL,
 618                           0, 0);
 619
 620         i++;
 621
 622 }
 623
 624 static void
 625 display_server_location (NautilusConnectServerDialog *dialog, GFile *location)
 626 {
 627 #if 0 /*FIXME */
 628         struct MethodInfo *meth = NULL;
 629         char *scheme;
 630         int i, index = 0;
 631         char *folder;
 632         const char *t;
 633
 634         /* Find an appropriate method */
 635         scheme = g_file_get_uri_scheme (location);
 636         g_return_if_fail (scheme != NULL);
 637
 638         for (i = 0; i < G_N_ELEMENTS (methods); i++) {
 639
 640                 /* The default is 'Custom URI' */
 641                 if (methods[i].scheme == NULL) {
 642                         meth = &(methods[i]);
 643                         index = i;
 644
 645                 } else if (strcmp (methods[i].scheme, scheme) == 0) {
 646
 647                         /* FTP Special case: If no user keep searching for public ftp */
 648                         if (strcmp (scheme, "ftp") == 0) {
 649                                 t = gnome_vfs_uri_get_user_name (uri);
 650                                 if ((!t || !t[0] || strcmp (t, "anonymous") == 0) &&
 651                                     (!(methods[i].flags & IS_ANONYMOUS))) {
 652                                         continue;
 653                                 }
 654                         }
 655
 656                         meth = &(methods[i]);
 657                         index = i;
 658                         break;
 659                 }
 660         }
 661
 662         g_free (scheme);
 663         g_assert (meth);
 664
 665         gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->details->type_combo), index);
 666         setup_for_type (dialog);
 667
 668         /* Custom URI */
 669         if (meth->scheme == NULL) {
 670                 gchar *uri;
 671
 672                 /* FIXME: with gnome-vfs, we had GNOME_VFS_URI_HIDE_PASSWORD |
 673                  * GNOME_VFS_URI_HIDE_FRAGMENT_IDENTIFIER */
 674                 uri = g_file_get_uri (location)
 675                 gtk_entry_set_text (GTK_ENTRY (dialog->details->uri_entry), uri);
 676                 g_free (uri);
 677
 678         } else {
 679
 680                 folder = g_file_get_path (location);
 681                 if (!folder) {
 682                         folder = "";
 683                 } else if (folder[0] == '/') {
 684                         folder++;
 685                 }
 686
 687                 /* Server */
 688                 t = gnome_vfs_uri_get_host_name (uri);
 689                 gtk_entry_set_text (GTK_ENTRY (dialog->details->server_entry),
 690                                     t ? t : "");
 691
 692                 /* Share */
 693                 if (meth->flags & SHOW_SHARE) {
 694                         t = strchr (folder, '/');
 695                         if (t) {
 696                                 char *share = g_strndup (folder, t - folder);
 697                                 gtk_entry_set_text (GTK_ENTRY (dialog->details->share_entry), share);
 698                                 g_free (share);
 699                                 folder = t + 1;
 700                         }
 701
 702                 }
 703
 704                 /* Port */
 705                 if (meth->flags & SHOW_PORT) {
 706                         guint port = gnome_vfs_uri_get_host_port (uri);
 707                         if (port != 0) {
 708                                 char sport[32];
 709                                 g_snprintf (sport, sizeof (sport), "%d", port);
 710                                 gtk_entry_set_text (GTK_ENTRY (dialog->details->port_entry), sport);
 711                         }
 712                 }
 713
 714                 /* Folder */
 715                 gtk_entry_set_text (GTK_ENTRY (dialog->details->folder_entry), folder);
 716                 g_free (folder);
 717
 718                 /* User */
 719                 if (meth->flags & SHOW_USER) {
 720                         const char *user = gnome_vfs_uri_get_user_name (uri);
 721                         if (user) {
 722                                 t = strchr (user, ';');
 723                                 if (t) {
 724                                         user = t + 1;
 725                                 }
 726                                 gtk_entry_set_text (GTK_ENTRY (dialog->details->user_entry), user);
 727                         }
 728                 }
 729
 730                 /* Domain */
 731                 if (meth->flags & SHOW_DOMAIN) {
 732                         const char *user = gnome_vfs_uri_get_user_name (uri);
 733                         if (user) {
 734                                 t = strchr (user, ';');
 735                                 if (t) {
 736                                         char *domain = g_strndup (user, t - user);
 737                                         gtk_entry_set_text (GTK_ENTRY (dialog->details->domain_entry), domain);
 738                                         g_free (domain);
 739                                 }
 740                         }
 741                 }
 742         }
 743 #endif
 744 }
 745
 746 static void
 747 combo_changed_callback (GtkComboBox *combo_box,
 748                         NautilusConnectServerDialog *dialog)
 749 {
 750         setup_for_type (dialog);
 751 }
 752
 753 static void
 754 port_insert_text (GtkEditable *editable,
 755                   const gchar *new_text,
 756                   gint         new_text_length,
 757                   gint        *position)
 758 {
 759         int pos;
 760
 761         if (new_text_length < 0) {
 762                 new_text_length = strlen (new_text);
 763         }
 764
 765         /* Only allow digits to be inserted as port number */
 766         for (pos = 0; pos < new_text_length; pos++) {
 767                 if (!g_ascii_isdigit (new_text[pos])) {
 768                         GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (editable));
 769                         if (toplevel != NULL) {
 770                                 gdk_window_beep (toplevel->window);
 771                         }
 772                     g_signal_stop_emission_by_name (editable, "insert_text");
 773                     return;
 774                 }
 775         }
 776 }
 777
 778 static void
 779 bookmark_checkmark_toggled (GtkToggleButton *toggle, NautilusConnectServerDialog *dialog)
 780 {
 781         gtk_widget_set_sensitive (GTK_WIDGET(dialog->details->name_entry),
 782                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (toggle)));
 783 }
 784
 785 static void
 786 nautilus_connect_server_dialog_init (NautilusConnectServerDialog *dialog)
 787 {
 788         GtkWidget *label;
 789         GtkWidget *table;
 790         GtkWidget *combo;
 791         GtkWidget *hbox;
 792         GtkWidget *vbox;
 793         GtkListStore *store;
 794         GtkCellRenderer *renderer;
 795         int i;
 796
 797         dialog->details = g_new0 (NautilusConnectServerDialogDetails, 1);
 798
 799         gtk_window_set_title (GTK_WINDOW (dialog), _("Connect to Server"));
 800         gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
 801         gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
 802         gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 2);
 803         gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
 804
 805         vbox = gtk_vbox_new (FALSE, 6);
 806         gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
 807         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
 808                             vbox, FALSE, TRUE, 0);
 809         gtk_widget_show (vbox);
 810
 811         hbox = gtk_hbox_new (FALSE, 6);
 812         gtk_box_pack_start (GTK_BOX (vbox),
 813                             hbox, FALSE, TRUE, 0);
 814         gtk_widget_show (hbox);
 815
 816         label = gtk_label_new_with_mnemonic (_("Service _type:"));
 817         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 818         gtk_widget_show (label);
 819         gtk_box_pack_start (GTK_BOX (hbox),
 820                             label, FALSE, FALSE, 0);
 821
 822         dialog->details->type_combo = combo = gtk_combo_box_new ();
 823
 824         /* each row contains: method index, textual description */
 825         store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
 826         gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (store));
 827         g_object_unref (G_OBJECT (store));
 828
 829         renderer = gtk_cell_renderer_text_new ();
 830         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
 831         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", 1);
 832
 833         for (i = 0; i < G_N_ELEMENTS (methods); i++) {
 834                 GtkTreeIter iter;
 835                 const gchar * const *supported;
 836                 int j;
 837
 838                 /* skip methods that don't have corresponding GnomeVFSMethods */
 839                 supported = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
 840
 841                 if (methods[i].scheme != NULL) {
 842                         gboolean found;
 843
 844                         found = FALSE;
 845                         for (j = 0; supported[j] != NULL; j++) {
 846                                 if (strcmp (methods[i].scheme, supported[j]) == 0) {
 847                                         found = TRUE;
 848                                         break;
 849                                 }
 850                         }
 851
 852                         if (!found) {
 853                                 continue;
 854                         }
 855                 }
 856
 857                 gtk_list_store_append (store, &iter);
 858                 gtk_list_store_set (store, &iter,
 859                                     0, i,
 860                                     1, get_method_description (&(methods[i])),
 861                                     -1);
 862
 863
 864                 if (methods[i].flags & DEFAULT_METHOD) {
 865                         gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &iter);
 866                 }
 867         }
 868
 869         if (gtk_combo_box_get_active (GTK_COMBO_BOX (combo)) < 0) {
 870                 /* default method not available, use any other */
 871                 gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
 872         }
 873
 874         gtk_widget_show (combo);
 875         gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
 876         gtk_box_pack_start (GTK_BOX (hbox),
 877                             combo, TRUE, TRUE, 0);
 878         g_signal_connect (combo, "changed",
 879                           G_CALLBACK (combo_changed_callback),
 880                           dialog);
 881
 882
 883         hbox = gtk_hbox_new (FALSE, 6);
 884         gtk_box_pack_start (GTK_BOX (vbox),
 885                             hbox, FALSE, TRUE, 0);
 886         gtk_widget_show (hbox);
 887
 888         label = gtk_label_new_with_mnemonic ("    ");
 889         gtk_widget_show (label);
 890         gtk_box_pack_start (GTK_BOX (hbox),
 891                             label, FALSE, FALSE, 0);
 892
 893
 894         dialog->details->table = table = gtk_table_new (5, 2, FALSE);
 895         gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 896         gtk_table_set_col_spacings (GTK_TABLE (table), 12);
 897         gtk_widget_show (table);
 898         gtk_box_pack_start (GTK_BOX (hbox),
 899                             table, TRUE, TRUE, 0);
 900
 901         dialog->details->uri_entry = nautilus_location_entry_new ();
 902         dialog->details->server_entry = gtk_entry_new ();
 903         dialog->details->share_entry = gtk_entry_new ();
 904         dialog->details->port_entry = gtk_entry_new ();
 905         g_signal_connect (dialog->details->port_entry, "insert_text", G_CALLBACK (port_insert_text),
 906                           NULL);
 907         dialog->details->folder_entry = gtk_entry_new ();
 908         dialog->details->domain_entry = gtk_entry_new ();
 909         dialog->details->user_entry = gtk_entry_new ();
 910         dialog->details->bookmark_check = gtk_check_button_new_with_mnemonic (_("Add _bookmark"));
 911         dialog->details->name_entry = gtk_entry_new ();
 912
 913         g_signal_connect (dialog->details->bookmark_check, "toggled",
 914                           G_CALLBACK (bookmark_checkmark_toggled), dialog);
 915
 916         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->details->bookmark_check), FALSE);
 917         gtk_widget_set_sensitive (GTK_WIDGET(dialog->details->name_entry), FALSE);
 918
 919         gtk_entry_set_activates_default (GTK_ENTRY (dialog->details->uri_entry), TRUE);
 920         gtk_entry_set_activates_default (GTK_ENTRY (dialog->details->server_entry), TRUE);
 921         gtk_entry_set_activates_default (GTK_ENTRY (dialog->details->share_entry), TRUE);
 922         gtk_entry_set_activates_default (GTK_ENTRY (dialog->details->port_entry), TRUE);
 923         gtk_entry_set_activates_default (GTK_ENTRY (dialog->details->folder_entry), TRUE);
 924         gtk_entry_set_activates_default (GTK_ENTRY (dialog->details->domain_entry), TRUE);
 925         gtk_entry_set_activates_default (GTK_ENTRY (dialog->details->user_entry), TRUE);
 926         gtk_entry_set_activates_default (GTK_ENTRY (dialog->details->name_entry), TRUE);
 927
 928         /* We need an extra ref so we can remove them from the table */
 929         g_object_ref (dialog->details->uri_entry);
 930         g_object_ref (dialog->details->server_entry);
 931         g_object_ref (dialog->details->share_entry);
 932         g_object_ref (dialog->details->port_entry);
 933         g_object_ref (dialog->details->folder_entry);
 934         g_object_ref (dialog->details->domain_entry);
 935         g_object_ref (dialog->details->user_entry);
 936         g_object_ref (dialog->details->bookmark_check);
 937         g_object_ref (dialog->details->name_entry);
 938
 939         setup_for_type (dialog);
 940
 941         gtk_dialog_add_button (GTK_DIALOG (dialog),
 942                                GTK_STOCK_HELP,
 943                                GTK_RESPONSE_HELP);
 944         gtk_dialog_add_button (GTK_DIALOG (dialog),
 945                                GTK_STOCK_CANCEL,
 946                                GTK_RESPONSE_CANCEL);
 947         gtk_dialog_add_button (GTK_DIALOG (dialog),
 948                                _("C_onnect"),
 949                                RESPONSE_CONNECT);
 950         gtk_dialog_set_default_response (GTK_DIALOG (dialog),
 951                                          RESPONSE_CONNECT);
 952
 953         g_signal_connect (dialog, "response",
 954                           G_CALLBACK (response_callback),
 955                           dialog);
 956
 957
 958 }
 959
 960 GtkWidget *
 961 nautilus_connect_server_dialog_new (NautilusWindow *window, GFile *location)
 962 {
 963         NautilusConnectServerDialog *conndlg;
 964         GtkWidget *dialog;
 965
 966         dialog = gtk_widget_new (NAUTILUS_TYPE_CONNECT_SERVER_DIALOG, NULL);
 967         conndlg = NAUTILUS_CONNECT_SERVER_DIALOG (dialog);
 968
 969         if (window) {
 970                 gtk_window_set_screen (GTK_WINDOW (dialog),
 971                                        gtk_window_get_screen (GTK_WINDOW (window)));
 972                 conndlg->details->application = window->application;
 973         }
 974
 975         if (location) {
 976                 /* If it's a remote URI, then load as the default */
 977                 if (!g_file_is_native (location)) {
 978                         display_server_location (conndlg, location);
 979                 }
 980         }
 981
 982         return dialog;
 983 }