source4/gtk/tools/gregedit.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    GTK+ registry frontend
   4
   5    Copyright (C) Jelmer Vernooij 2004
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23 #include "dynconfig.h"
  24 #include "registry.h"
  25 #include "lib/cmdline/popt_common.h"
  26 #include "gtk/common/select.h"
  27 #include "gtk/common/gtk-smb.h"
  28
  29 GtkWidget *openfilewin;
  30 GtkWidget *savefilewin;
  31 GtkTreeStore *store_keys;
  32 GtkListStore *store_vals;
  33 GtkWidget *tree_keys;
  34 GtkWidget *mainwin;
  35 GtkWidget *mnu_add_key, *mnu_add_value, *mnu_del_key, *mnu_del_value, *mnu_find;
  36 TALLOC_CTX *mem_ctx; /* FIXME: Split up */
  37
  38 GtkWidget *save;
  39 GtkWidget *save_as;
  40 static GtkWidget* create_openfilewin (void);
  41 static GtkWidget* create_savefilewin (void);
  42 struct registry_context *registry = NULL;
  43
  44 static GtkWidget* create_FindDialog (void)
  45 {
  46   GtkWidget *FindDialog;
  47   GtkWidget *dialog_vbox2;
  48   GtkWidget *vbox1;
  49   GtkWidget *hbox1;
  50   GtkWidget *label6;
  51   GtkWidget *entry_pattern;
  52   GtkWidget *frame3;
  53   GtkWidget *alignment3;
  54   GtkWidget *vbox2;
  55   GtkWidget *checkbutton1;
  56   GtkWidget *checkbutton2;
  57   GtkWidget *checkbutton3;
  58   GtkWidget *label7;
  59   GtkWidget *dialog_action_area2;
  60   GtkWidget *cancelbutton2;
  61   GtkWidget *okbutton2;
  62
  63   FindDialog = gtk_dialog_new ();
  64   gtk_window_set_title (GTK_WINDOW (FindDialog), "Find Key or Value");
  65   gtk_window_set_type_hint (GTK_WINDOW (FindDialog), GDK_WINDOW_TYPE_HINT_DIALOG);
  66
  67   dialog_vbox2 = GTK_DIALOG (FindDialog)->vbox;
  68
  69   vbox1 = gtk_vbox_new (FALSE, 0);
  70   gtk_box_pack_start (GTK_BOX (dialog_vbox2), vbox1, TRUE, TRUE, 0);
  71
  72   hbox1 = gtk_hbox_new (FALSE, 0);
  73   gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
  74
  75   label6 = gtk_label_new ("Find String");
  76   gtk_box_pack_start (GTK_BOX (hbox1), label6, FALSE, FALSE, 0);
  77
  78   entry_pattern = gtk_entry_new ();
  79   gtk_box_pack_start (GTK_BOX (hbox1), entry_pattern, TRUE, TRUE, 0);
  80
  81   frame3 = gtk_frame_new (NULL);
  82   gtk_box_pack_start (GTK_BOX (vbox1), frame3, TRUE, TRUE, 0);
  83   gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_NONE);
  84
  85   alignment3 = gtk_alignment_new (0.5, 0.5, 1, 1);
  86   gtk_container_add (GTK_CONTAINER (frame3), alignment3);
  87   gtk_alignment_set_padding (GTK_ALIGNMENT (alignment3), 0, 0, 12, 0);
  88
  89   vbox2 = gtk_vbox_new (FALSE, 0);
  90   gtk_container_add (GTK_CONTAINER (alignment3), vbox2);
  91
  92   checkbutton1 = gtk_check_button_new_with_mnemonic ("_Key Names");
  93   gtk_box_pack_start (GTK_BOX (vbox2), checkbutton1, FALSE, FALSE, 0);
  94
  95   checkbutton2 = gtk_check_button_new_with_mnemonic ("_Value Names");
  96   gtk_box_pack_start (GTK_BOX (vbox2), checkbutton2, FALSE, FALSE, 0);
  97
  98   checkbutton3 = gtk_check_button_new_with_mnemonic ("Value _Data");
  99   gtk_box_pack_start (GTK_BOX (vbox2), checkbutton3, FALSE, FALSE, 0);
 100
 101   label7 = gtk_label_new ("<b>Search in</b>");
 102   gtk_frame_set_label_widget (GTK_FRAME (frame3), label7);
 103   gtk_label_set_use_markup (GTK_LABEL (label7), TRUE);
 104
 105   dialog_action_area2 = GTK_DIALOG (FindDialog)->action_area;
 106   gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area2), GTK_BUTTONBOX_END);
 107
 108   cancelbutton2 = gtk_button_new_from_stock ("gtk-cancel");
 109   gtk_dialog_add_action_widget (GTK_DIALOG (FindDialog), cancelbutton2, GTK_RESPONSE_CANCEL);
 110   GTK_WIDGET_SET_FLAGS (cancelbutton2, GTK_CAN_DEFAULT);
 111
 112   okbutton2 = gtk_button_new_from_stock ("gtk-ok");
 113   gtk_dialog_add_action_widget (GTK_DIALOG (FindDialog), okbutton2, GTK_RESPONSE_OK);
 114   GTK_WIDGET_SET_FLAGS (okbutton2, GTK_CAN_DEFAULT);
 115
 116   gtk_widget_show_all (dialog_vbox2);
 117
 118   return FindDialog;
 119 }
 120
 121 static GtkWidget* create_SetValueDialog (void)
 122 {
 123   GtkWidget *SetValueDialog;
 124   GtkWidget *dialog_vbox1;
 125   GtkWidget *table1;
 126   GtkWidget *label3;
 127   GtkWidget *label4;
 128   GtkWidget *label5;
 129   GtkWidget *entry_value_name;
 130   GtkWidget *value_data;
 131   GtkWidget *combo_data_type;
 132   GtkWidget *dialog_action_area1;
 133   GtkWidget *cancelbutton1;
 134   GtkWidget *okbutton1;
 135
 136   SetValueDialog = gtk_dialog_new ();
 137   gtk_window_set_title (GTK_WINDOW (SetValueDialog), "Set Registry Value");
 138   GTK_WINDOW (SetValueDialog)->type = GTK_WINDOW_POPUP;
 139   gtk_window_set_position (GTK_WINDOW (SetValueDialog), GTK_WIN_POS_CENTER);
 140   gtk_window_set_resizable (GTK_WINDOW (SetValueDialog), FALSE);
 141   gtk_window_set_type_hint (GTK_WINDOW (SetValueDialog), GDK_WINDOW_TYPE_HINT_DIALOG);
 142
 143   dialog_vbox1 = GTK_DIALOG (SetValueDialog)->vbox;
 144
 145   table1 = gtk_table_new (3, 2, FALSE);
 146   gtk_box_pack_start (GTK_BOX (dialog_vbox1), table1, TRUE, TRUE, 0);
 147
 148   label3 = gtk_label_new ("Value name:");
 149   gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 0, 1,
 150                     (GtkAttachOptions) (GTK_FILL),
 151                     (GtkAttachOptions) (0), 0, 0);
 152   gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
 153
 154   label4 = gtk_label_new ("Data Type:");
 155   gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 1, 2,
 156                     (GtkAttachOptions) (GTK_FILL),
 157                     (GtkAttachOptions) (0), 0, 0);
 158   gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
 159
 160   label5 = gtk_label_new ("Data:");
 161   gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 2, 3,
 162                     (GtkAttachOptions) (GTK_FILL),
 163                     (GtkAttachOptions) (0), 0, 0);
 164   gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
 165
 166   entry_value_name = gtk_entry_new ();
 167   gtk_table_attach (GTK_TABLE (table1), entry_value_name, 1, 2, 0, 1,
 168                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 169                     (GtkAttachOptions) (0), 0, 0);
 170
 171   value_data = gtk_entry_new ();
 172   gtk_table_attach (GTK_TABLE (table1), value_data, 1, 2, 2, 3,
 173                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 174                     (GtkAttachOptions) (0), 0, 0);
 175
 176   combo_data_type = gtk_combo_box_entry_new_text ();
 177   gtk_table_attach (GTK_TABLE (table1), combo_data_type, 1, 2, 1, 2,
 178                     (GtkAttachOptions) (GTK_FILL),
 179                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 180
 181   dialog_action_area1 = GTK_DIALOG (SetValueDialog)->action_area;
 182   gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
 183
 184   cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
 185   gtk_dialog_add_action_widget (GTK_DIALOG (SetValueDialog), cancelbutton1, GTK_RESPONSE_CANCEL);
 186   GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
 187
 188   okbutton1 = gtk_button_new_from_stock ("gtk-ok");
 189   gtk_dialog_add_action_widget (GTK_DIALOG (SetValueDialog), okbutton1, GTK_RESPONSE_OK);
 190   GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
 191
 192   gtk_widget_show_all (dialog_vbox1);
 193
 194   return SetValueDialog;
 195 }
 196
 197 static GtkWidget* create_NewKeyDialog (void)
 198 {
 199   GtkWidget *NewKeyDialog;
 200   GtkWidget *dialog_vbox2;
 201   GtkWidget *hbox1;
 202   GtkWidget *label6;
 203   GtkWidget *entry_key_name;
 204   GtkWidget *dialog_action_area2;
 205   GtkWidget *cancelbutton2;
 206   GtkWidget *okbutton2;
 207
 208   NewKeyDialog = gtk_dialog_new ();
 209   gtk_window_set_title (GTK_WINDOW (NewKeyDialog), "New Registry Key");
 210   GTK_WINDOW (NewKeyDialog)->type = GTK_WINDOW_POPUP;
 211   gtk_window_set_position (GTK_WINDOW (NewKeyDialog), GTK_WIN_POS_CENTER);
 212   gtk_window_set_resizable (GTK_WINDOW (NewKeyDialog), FALSE);
 213   gtk_window_set_type_hint (GTK_WINDOW (NewKeyDialog), GDK_WINDOW_TYPE_HINT_DIALOG);
 214
 215   dialog_vbox2 = GTK_DIALOG (NewKeyDialog)->vbox;
 216
 217   hbox1 = gtk_hbox_new (FALSE, 0);
 218   gtk_box_pack_start (GTK_BOX (dialog_vbox2), hbox1, TRUE, TRUE, 0);
 219
 220   label6 = gtk_label_new ("Name:");
 221   gtk_box_pack_start (GTK_BOX (hbox1), label6, FALSE, FALSE, 0);
 222
 223   entry_key_name = gtk_entry_new ();
 224   gtk_box_pack_start (GTK_BOX (hbox1), entry_key_name, TRUE, TRUE, 0);
 225
 226   dialog_action_area2 = GTK_DIALOG (NewKeyDialog)->action_area;
 227   gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area2), GTK_BUTTONBOX_END);
 228
 229   cancelbutton2 = gtk_button_new_from_stock ("gtk-cancel");
 230   gtk_dialog_add_action_widget (GTK_DIALOG (NewKeyDialog), cancelbutton2, GTK_RESPONSE_CANCEL);
 231   GTK_WIDGET_SET_FLAGS (cancelbutton2, GTK_CAN_DEFAULT);
 232
 233   okbutton2 = gtk_button_new_from_stock ("gtk-ok");
 234   gtk_dialog_add_action_widget (GTK_DIALOG (NewKeyDialog), okbutton2, GTK_RESPONSE_OK);
 235   GTK_WIDGET_SET_FLAGS (okbutton2, GTK_CAN_DEFAULT);
 236
 237   gtk_widget_show_all (dialog_vbox2);
 238
 239   return NewKeyDialog;
 240 }
 241
 242
 243 static void expand_key(GtkTreeView *treeview, GtkTreeIter *parent, GtkTreePath *arg2)
 244 {
 245         GtkTreeIter firstiter, iter, tmpiter;
 246         struct registry_key *k, *sub;
 247         char *name;
 248         WERROR error;
 249         int i;
 250
 251     gtk_tree_model_iter_children(GTK_TREE_MODEL(store_keys), &firstiter, parent);
 252
 253     /* See if this row has ever had a name gtk_tree_store_set()'ed to it.
 254        If not, read the directory contents */
 255     gtk_tree_model_get(GTK_TREE_MODEL(store_keys), &firstiter, 0, &name, -1);
 256
 257         if(name) return;
 258
 259         gtk_tree_model_get(GTK_TREE_MODEL(store_keys), parent, 1, &k, -1);
 260
 261         g_assert(k);
 262
 263         for(i = 0; W_ERROR_IS_OK(error = reg_key_get_subkey_by_index(mem_ctx, k, i, &sub)); i++) {
 264                 int count;
 265                 /* Replace the blank child with the first directory entry
 266            You may be tempted to remove the blank child node and then
 267            append a new one.  Don't.  If you remove the blank child
 268            node GTK gets confused and won't expand the parent row. */
 269
 270                 if(i == 0) {
 271                         iter = firstiter;
 272                 } else {
 273                         gtk_tree_store_append(store_keys, &iter, parent);
 274                 }
 275                 gtk_tree_store_set (store_keys,
 276                                             &iter,
 277                                                 0,
 278                                                 sub->name,
 279                                                 1,
 280                                                 sub,
 281                                                 -1);
 282
 283                 if(W_ERROR_IS_OK(reg_key_num_subkeys(sub, &count)) && count > 0)
 284                         gtk_tree_store_append(store_keys, &tmpiter, &iter);
 285         }
 286
 287         if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) gtk_show_werror(mainwin, error);
 288 }
 289
 290 static void registry_load_root(void)
 291 {
 292         struct registry_key *root;
 293         GtkTreeIter iter, tmpiter;
 294         int i = 0;
 295         if(!registry) return;
 296
 297         gtk_tree_store_clear(store_keys);
 298
 299         for(i = 0; i < registry->num_hives; i++)
 300         {
 301                 root = registry->hives[i]->root;
 302
 303                 /* Add the root */
 304                 gtk_tree_store_append(store_keys, &iter, NULL);
 305                 gtk_tree_store_set (store_keys,
 306                                             &iter,
 307                                                 0,
 308                                                 root->hive->name?root->hive->name:"",
 309                                                 1,
 310                                                 root,
 311                                                 -1);
 312
 313                 gtk_tree_store_append(store_keys, &tmpiter, &iter);
 314         }
 315
 316         gtk_widget_set_sensitive( save, True );
 317         gtk_widget_set_sensitive( save_as, True );
 318 }
 319
 320 static void on_open_file_activate (GtkMenuItem *menuitem, gpointer user_data)
 321 {
 322         gint result = gtk_dialog_run(GTK_DIALOG(create_openfilewin()));
 323         char *filename, *tmp;
 324         WERROR error;
 325         switch(result) {
 326         case GTK_RESPONSE_OK:
 327                 filename = strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION(openfilewin)));
 328                 error = reg_open(&registry, user_data, filename, NULL);
 329                 if(!W_ERROR_IS_OK(error)) {
 330                         gtk_show_werror(mainwin, error);
 331                         break;
 332                 }
 333
 334                 tmp = g_strdup_printf("Registry Editor - %s", filename);
 335                 gtk_window_set_title (GTK_WINDOW (mainwin), tmp);
 336                 g_free(tmp);
 337                 registry_load_root();
 338                 break;
 339         default:
 340                 break;
 341         }
 342
 343         gtk_widget_destroy(openfilewin);
 344 }
 345
 346 static void on_open_gconf_activate                       (GtkMenuItem     *menuitem,
 347                                                       gpointer         user_data)
 348 {
 349         WERROR error = reg_open(&registry, "gconf", NULL, NULL);
 350         if(!W_ERROR_IS_OK(error)) {
 351                 gtk_show_werror(mainwin, error);
 352                 return;
 353         }
 354
 355         gtk_window_set_title (GTK_WINDOW (mainwin), "Registry Editor - GConf");
 356
 357         registry_load_root();
 358 }
 359
 360 static void on_open_remote_activate(GtkMenuItem *menuitem, gpointer user_data)
 361 {
 362         char *credentials;
 363         const char *location;
 364         char *tmp;
 365         GtkWidget *rpcwin = GTK_WIDGET(gtk_rpc_binding_dialog_new(FALSE, NULL));
 366         gint result = gtk_dialog_run(GTK_DIALOG(rpcwin));
 367         WERROR error;
 368
 369         if(result != GTK_RESPONSE_ACCEPT)
 370         {
 371                 gtk_widget_destroy(rpcwin);
 372                 return;
 373         }
 374
 375         location = gtk_rpc_binding_dialog_get_binding_string(GTK_RPC_BINDING_DIALOG(rpcwin), mem_ctx);
 376         asprintf(&credentials, "%s%%%s", gtk_rpc_binding_dialog_get_username(GTK_RPC_BINDING_DIALOG(rpcwin)), gtk_rpc_binding_dialog_get_password(GTK_RPC_BINDING_DIALOG(rpcwin)));
 377         error = reg_open(&registry, "rpc", location, credentials);
 378
 379         if(!W_ERROR_IS_OK(error)) {
 380                 gtk_show_werror(mainwin, error);
 381                 gtk_widget_destroy(rpcwin);
 382                 return;
 383         }
 384         free(credentials);
 385
 386         tmp = g_strdup_printf("Registry Editor - Remote Registry at %s", gtk_rpc_binding_dialog_get_host(GTK_RPC_BINDING_DIALOG(rpcwin)));
 387         gtk_window_set_title (GTK_WINDOW (mainwin), tmp);
 388         g_free(tmp);
 389
 390         registry_load_root();
 391
 392
 393         gtk_widget_destroy(rpcwin);
 394 }
 395
 396
 397 static void on_save_activate                       (GtkMenuItem     *menuitem,
 398                                                                                                         gpointer         user_data)
 399 {
 400         WERROR error = reg_save(registry, NULL);
 401         if(!W_ERROR_IS_OK(error)) {
 402                 gtk_show_werror(mainwin, error);
 403         }
 404 }
 405
 406
 407 static void on_save_as_activate                    (GtkMenuItem     *menuitem,
 408                                                                                 gpointer         user_data)
 409 {
 410         gint result;
 411         WERROR error;
 412         create_savefilewin();
 413         result = gtk_dialog_run(GTK_DIALOG(savefilewin));
 414         switch(result) {
 415         case GTK_RESPONSE_OK:
 416                 error = reg_save(registry, gtk_file_selection_get_filename(GTK_FILE_SELECTION(savefilewin)));
 417                 if(!W_ERROR_IS_OK(error)) {
 418                         gtk_show_werror(mainwin, error);
 419                 }
 420                 break;
 421
 422         default:
 423                 break;
 424
 425         }
 426         gtk_widget_destroy(savefilewin);
 427 }
 428
 429
 430 static void on_quit_activate                       (GtkMenuItem     *menuitem,
 431                                                                                 gpointer         user_data)
 432 {
 433         gtk_main_quit();
 434 }
 435
 436
 437 static void on_delete_activate                     (GtkMenuItem     *menuitem,
 438                                                                                 gpointer         user_data)
 439 {
 440         /* FIXME */
 441 }
 442
 443 static void on_add_key_activate                     (GtkMenuItem     *menuitem,
 444                                                                                 gpointer         user_data)
 445 {
 446         GtkDialog *addwin = GTK_DIALOG(create_NewKeyDialog());
 447         gtk_dialog_run(addwin);
 448         /* FIXME */
 449         gtk_widget_destroy(GTK_WIDGET(addwin));
 450 }
 451
 452 static void on_add_value_activate                     (GtkMenuItem     *menuitem,
 453                                                                                 gpointer         user_data)
 454 {
 455         GtkDialog *addwin = GTK_DIALOG(create_SetValueDialog());
 456         gtk_dialog_run(addwin);
 457         /* FIXME */
 458         gtk_widget_destroy(GTK_WIDGET(addwin));
 459 }
 460
 461 static void on_find_activate                     (GtkMenuItem     *menuitem,
 462                                                                                 gpointer         user_data)
 463 {
 464         GtkDialog *findwin = GTK_DIALOG(create_FindDialog());
 465         gtk_dialog_run(findwin);
 466         /* FIXME */
 467         gtk_widget_destroy(GTK_WIDGET(findwin));
 468 }
 469
 470 static void on_about_activate                      (GtkMenuItem     *menuitem,
 471                                                                                 gpointer         user_data)
 472 {
 473         GtkDialog *aboutwin = GTK_DIALOG(create_gtk_samba_about_dialog("gregedit"));
 474         gtk_dialog_run(aboutwin);
 475         gtk_widget_destroy(GTK_WIDGET(aboutwin));
 476 }
 477
 478 gboolean on_key_activate(GtkTreeSelection *selection,
 479                                              GtkTreeModel *model,
 480                                              GtkTreePath *path,
 481                                              gboolean path_currently_selected,
 482                                              gpointer data)
 483 {
 484         int i;
 485         struct registry_key *k;
 486         struct registry_value *val;
 487         WERROR error;
 488         GtkTreeIter parent;
 489
 490         gtk_widget_set_sensitive(mnu_add_key, !path_currently_selected);
 491         gtk_widget_set_sensitive(mnu_add_value, !path_currently_selected);
 492         gtk_widget_set_sensitive(mnu_del_key, !path_currently_selected);
 493         gtk_widget_set_sensitive(mnu_del_value, !path_currently_selected);
 494         gtk_widget_set_sensitive(mnu_find, !path_currently_selected);
 495
 496         if(path_currently_selected) { return TRUE; }
 497
 498         gtk_tree_model_get_iter(GTK_TREE_MODEL(store_keys), &parent, path);
 499         gtk_tree_model_get(GTK_TREE_MODEL(store_keys), &parent, 1, &k, -1);
 500
 501         g_assert(k);
 502
 503         gtk_list_store_clear(store_vals);
 504
 505         for(i = 0; W_ERROR_IS_OK(error = reg_key_get_value_by_index(mem_ctx, k, i, &val)); i++) {
 506                 GtkTreeIter iter;
 507                 gtk_list_store_append(store_vals, &iter);
 508                 gtk_list_store_set (store_vals,
 509                                             &iter,
 510                                                 0,
 511                                                 val->name,
 512                                                 1,
 513                                                 str_regtype(val->data_type),
 514                                                 2,
 515                                                 reg_val_data_string(mem_ctx, val),
 516                                                 3,
 517                                                 val,
 518                                                 -1);
 519         }
 520
 521         if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
 522                  gtk_show_werror(mainwin, error);
 523                  return FALSE;
 524         }
 525         return TRUE;
 526 }
 527
 528 static GtkWidget* create_mainwin (void)
 529 {
 530         GtkWidget *vbox1;
 531         GtkWidget *menubar;
 532         GtkWidget *menu_file;
 533         GtkWidget *menu_file_menu;
 534         GtkWidget *open_nt4;
 535         GtkWidget *open_ldb;
 536         GtkWidget *open_w95;
 537         GtkWidget *open_gconf;
 538         GtkWidget *open_remote;
 539         GtkWidget *separatormenuitem1;
 540         GtkWidget *quit;
 541         GtkWidget *men_key;
 542         GtkWidget *men_key_menu;
 543         GtkCellRenderer *renderer;
 544         GtkTreeViewColumn *curcol;
 545         GtkWidget *help;
 546         GtkWidget *help_menu;
 547         GtkWidget *about;
 548         GtkWidget *hbox1;
 549         GtkWidget *scrolledwindow1;
 550         GtkWidget *scrolledwindow2;
 551         GtkWidget *tree_vals;
 552         GtkWidget *statusbar;
 553         GtkAccelGroup *accel_group;
 554
 555         accel_group = gtk_accel_group_new ();
 556
 557         mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 558         gtk_window_set_title (GTK_WINDOW (mainwin), "Registry editor");
 559         gtk_window_set_default_size (GTK_WINDOW (mainwin), 642, 562);
 560
 561         vbox1 = gtk_vbox_new (FALSE, 0);
 562         gtk_container_add (GTK_CONTAINER (mainwin), vbox1);
 563
 564         menubar = gtk_menu_bar_new ();
 565         gtk_box_pack_start (GTK_BOX (vbox1), menubar, FALSE, FALSE, 0);
 566
 567         menu_file = gtk_menu_item_new_with_mnemonic ("_File");
 568         gtk_container_add (GTK_CONTAINER (menubar), menu_file);
 569
 570         menu_file_menu = gtk_menu_new ();
 571         gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_file), menu_file_menu);
 572
 573         if(reg_has_backend("nt4")) {
 574                 open_nt4 = gtk_image_menu_item_new_with_mnemonic("Open _NT4 file");
 575                 gtk_container_add (GTK_CONTAINER (menu_file_menu), open_nt4);
 576
 577                 g_signal_connect ((gpointer) open_nt4, "activate",
 578                                                   G_CALLBACK (on_open_file_activate),
 579                                                   (gconstpointer)"nt4");
 580         }
 581
 582         if(reg_has_backend("w95")) {
 583                 open_w95 = gtk_image_menu_item_new_with_mnemonic("Open Win_9x file");
 584                 gtk_container_add (GTK_CONTAINER (menu_file_menu), open_w95);
 585
 586                 g_signal_connect ((gpointer) open_w95, "activate",
 587                                                   G_CALLBACK (on_open_file_activate),
 588                                                   (gconstpointer)"w95");
 589         }
 590
 591         if(reg_has_backend("gconf")) {
 592                 open_gconf = gtk_image_menu_item_new_with_mnemonic ("Open _GConf");
 593                 gtk_container_add (GTK_CONTAINER (menu_file_menu), open_gconf);
 594
 595                 g_signal_connect ((gpointer) open_gconf, "activate",
 596                                                   G_CALLBACK (on_open_gconf_activate),
 597                                                   NULL);
 598         }
 599
 600         if(reg_has_backend("rpc")) {
 601                 open_remote = gtk_menu_item_new_with_mnemonic ("Open _Remote");
 602                 gtk_container_add (GTK_CONTAINER (menu_file_menu), open_remote);
 603
 604                 g_signal_connect ((gpointer) open_remote, "activate",
 605                                                   G_CALLBACK (on_open_remote_activate),
 606                                                   NULL);
 607         }
 608
 609         if(reg_has_backend("ldb")) {
 610                 open_ldb = gtk_image_menu_item_new_with_mnemonic("Open _LDB file");
 611                 gtk_container_add (GTK_CONTAINER (menu_file_menu), open_ldb);
 612
 613                 g_signal_connect ((gpointer) open_ldb, "activate",
 614                                                   G_CALLBACK (on_open_file_activate),
 615                                                   (gconstpointer)"ldb");
 616         }
 617
 618         save = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group);
 619         gtk_widget_set_sensitive( save, False );
 620         gtk_container_add (GTK_CONTAINER (menu_file_menu), save);
 621
 622         save_as = gtk_image_menu_item_new_from_stock ("gtk-save-as", accel_group);
 623         gtk_widget_set_sensitive( save_as, False );
 624         gtk_container_add (GTK_CONTAINER (menu_file_menu), save_as);
 625
 626         separatormenuitem1 = gtk_menu_item_new ();
 627         gtk_container_add (GTK_CONTAINER (menu_file_menu), separatormenuitem1);
 628         gtk_widget_set_sensitive (separatormenuitem1, FALSE);
 629
 630         quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
 631         gtk_container_add (GTK_CONTAINER (menu_file_menu), quit);
 632
 633         men_key = gtk_menu_item_new_with_mnemonic ("_Key");
 634         gtk_container_add (GTK_CONTAINER (menubar), men_key);
 635
 636         men_key_menu = gtk_menu_new ();
 637         gtk_menu_item_set_submenu (GTK_MENU_ITEM (men_key), men_key_menu);
 638
 639         mnu_add_key = gtk_image_menu_item_new_with_mnemonic("Add _Subkey");
 640         gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mnu_add_key), gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_MENU));
 641
 642         gtk_widget_set_sensitive(mnu_add_key, False);
 643         gtk_container_add (GTK_CONTAINER (men_key_menu), mnu_add_key);
 644
 645         mnu_add_value = gtk_image_menu_item_new_with_mnemonic("Add _Value");
 646         gtk_widget_set_sensitive(mnu_add_value, False);
 647         gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mnu_add_value), gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_MENU));
 648         gtk_container_add (GTK_CONTAINER (men_key_menu), mnu_add_value);
 649
 650         mnu_find = gtk_image_menu_item_new_from_stock ("gtk-find", accel_group);
 651         gtk_widget_set_sensitive(mnu_find, False);
 652         gtk_container_add (GTK_CONTAINER (men_key_menu), mnu_find);
 653
 654         mnu_del_key = gtk_image_menu_item_new_with_mnemonic ("Delete Key");
 655         gtk_widget_set_sensitive(mnu_del_key, False);
 656         gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mnu_del_value), gtk_image_new_from_stock ("gtk-delete", GTK_ICON_SIZE_MENU));
 657         gtk_container_add (GTK_CONTAINER (men_key_menu), mnu_del_key);
 658
 659         mnu_del_value = gtk_image_menu_item_new_with_mnemonic ("Delete Value");
 660         gtk_widget_set_sensitive(mnu_del_value, False);
 661         gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mnu_del_value), gtk_image_new_from_stock ("gtk-delete", GTK_ICON_SIZE_MENU));
 662         gtk_container_add (GTK_CONTAINER (men_key_menu), mnu_del_value);
 663
 664
 665         help = gtk_menu_item_new_with_mnemonic ("_Help");
 666         gtk_container_add (GTK_CONTAINER (menubar), help);
 667
 668         help_menu = gtk_menu_new ();
 669         gtk_menu_item_set_submenu (GTK_MENU_ITEM (help), help_menu);
 670
 671         about = gtk_menu_item_new_with_mnemonic ("_About");
 672         gtk_container_add (GTK_CONTAINER (help_menu), about);
 673
 674         hbox1 = gtk_hbox_new (FALSE, 0);
 675         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
 676
 677         scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
 678         gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow1, TRUE, TRUE, 0);
 679
 680         tree_keys = gtk_tree_view_new ();
 681
 682         /* Column names */
 683         curcol = gtk_tree_view_column_new ();
 684         gtk_tree_view_column_set_title(curcol, "Name");
 685         renderer = gtk_cell_renderer_text_new();
 686         gtk_tree_view_column_pack_start(curcol, renderer, True);
 687
 688         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_keys), curcol);
 689
 690         gtk_tree_view_column_add_attribute(curcol, renderer, "text", 0);
 691         gtk_container_add (GTK_CONTAINER (scrolledwindow1), tree_keys);
 692         store_keys = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
 693         gtk_tree_view_set_model(GTK_TREE_VIEW(tree_keys), GTK_TREE_MODEL(store_keys));
 694         g_object_unref(store_keys);
 695
 696         gtk_tree_selection_set_select_function (gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_keys)), on_key_activate, NULL, NULL);
 697
 698         g_signal_connect ((gpointer) tree_keys, "row-expanded",
 699                                           G_CALLBACK (expand_key),
 700                                           NULL);
 701
 702
 703         scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
 704         gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0);
 705
 706         tree_vals = gtk_tree_view_new ();
 707         /* Column names */
 708
 709         curcol = gtk_tree_view_column_new ();
 710         gtk_tree_view_column_set_title(curcol, "Name");
 711         renderer = gtk_cell_renderer_text_new();
 712         gtk_tree_view_column_pack_start(curcol, renderer, True);
 713         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_vals), curcol);
 714         gtk_tree_view_column_add_attribute(curcol, renderer, "text", 0);
 715
 716         curcol = gtk_tree_view_column_new ();
 717         gtk_tree_view_column_set_title(curcol, "Type");
 718         renderer = gtk_cell_renderer_text_new();
 719         gtk_tree_view_column_pack_start(curcol, renderer, True);
 720         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_vals), curcol);
 721         gtk_tree_view_column_add_attribute(curcol, renderer, "text", 1);
 722
 723         curcol = gtk_tree_view_column_new ();
 724         gtk_tree_view_column_set_title(curcol, "Value");
 725         renderer = gtk_cell_renderer_text_new();
 726         gtk_tree_view_column_pack_start(curcol, renderer, True);
 727         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_vals), curcol);
 728         gtk_tree_view_column_add_attribute(curcol, renderer, "text", 2);
 729
 730
 731         gtk_container_add (GTK_CONTAINER (scrolledwindow2), tree_vals);
 732
 733         store_vals = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
 734         gtk_tree_view_set_model(GTK_TREE_VIEW(tree_vals), GTK_TREE_MODEL(store_vals));
 735         g_object_unref(store_vals);
 736
 737         statusbar = gtk_statusbar_new ();
 738         gtk_box_pack_start (GTK_BOX (vbox1), statusbar, FALSE, FALSE, 0);
 739         gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (statusbar), FALSE);
 740
 741         g_signal_connect ((gpointer) save, "activate",
 742                                           G_CALLBACK (on_save_activate),
 743                                           NULL);
 744         g_signal_connect ((gpointer) save_as, "activate",
 745                                           G_CALLBACK (on_save_as_activate),
 746                                           NULL);
 747         g_signal_connect ((gpointer) quit, "activate",
 748                                           G_CALLBACK (on_quit_activate),
 749                                           NULL);
 750         g_signal_connect ((gpointer) mnu_add_key, "activate",
 751                                           G_CALLBACK (on_add_key_activate),
 752                                           NULL);
 753         g_signal_connect ((gpointer) mnu_add_value, "activate",
 754                                           G_CALLBACK (on_add_value_activate),
 755                                           NULL);
 756         g_signal_connect ((gpointer) mnu_find, "activate",
 757                                           G_CALLBACK (on_find_activate),
 758                                           NULL);
 759         g_signal_connect ((gpointer) mnu_del_key, "activate",
 760                                           G_CALLBACK (on_delete_activate),
 761                                           NULL);
 762         g_signal_connect ((gpointer) about, "activate",
 763                                           G_CALLBACK (on_about_activate),
 764                                           NULL);
 765
 766         gtk_window_add_accel_group (GTK_WINDOW (mainwin), accel_group);
 767
 768         return mainwin;
 769 }
 770
 771 static GtkWidget* create_openfilewin (void)
 772 {
 773         GtkWidget *ok_button;
 774         GtkWidget *cancel_button;
 775
 776         openfilewin = gtk_file_selection_new ("Select File");
 777         gtk_container_set_border_width (GTK_CONTAINER (openfilewin), 10);
 778
 779         ok_button = GTK_FILE_SELECTION (openfilewin)->ok_button;
 780         GTK_WIDGET_SET_FLAGS (ok_button, GTK_CAN_DEFAULT);
 781
 782         cancel_button = GTK_FILE_SELECTION (openfilewin)->cancel_button;
 783         GTK_WIDGET_SET_FLAGS (cancel_button, GTK_CAN_DEFAULT);
 784
 785         return openfilewin;
 786 }
 787
 788 static GtkWidget* create_savefilewin (void)
 789 {
 790         GtkWidget *ok_button;
 791         GtkWidget *cancel_button;
 792
 793         savefilewin = gtk_file_selection_new ("Select File");
 794         gtk_container_set_border_width (GTK_CONTAINER (savefilewin), 10);
 795
 796         ok_button = GTK_FILE_SELECTION (savefilewin)->ok_button;
 797         GTK_WIDGET_SET_FLAGS (ok_button, GTK_CAN_DEFAULT);
 798
 799         cancel_button = GTK_FILE_SELECTION (savefilewin)->cancel_button;
 800         GTK_WIDGET_SET_FLAGS (cancel_button, GTK_CAN_DEFAULT);
 801
 802         return savefilewin;
 803 }
 804
 805  int main(int argc, char *argv[])
 806 {
 807         poptContext pc;
 808         const char *backend = NULL;
 809         const char *credentials = NULL;
 810         const char *location;
 811         int opt;
 812         struct poptOption long_options[] = {
 813                 POPT_AUTOHELP
 814                 {"backend", 'b', POPT_ARG_STRING, &backend, 0, "backend to use", NULL},
 815                 {"credentials", 'c', POPT_ARG_STRING, &credentials, 0, "credentials (user%%password)", NULL},
 816                 POPT_TABLEEND
 817         };
 818
 819         lp_load(dyn_CONFIGFILE,True,False,False);
 820         load_interfaces();
 821
 822         gtk_init (&argc, &argv);
 823         mem_ctx = talloc_init("gregedit");
 824
 825         pc = poptGetContext(argv[0], argc, (const char **) argv, long_options,0);
 826
 827         while((opt = poptGetNextOpt(pc)) != -1) {
 828         }
 829
 830         location = poptGetArg(pc);
 831
 832         if(location) {
 833                 WERROR error;
 834
 835                 if(!backend) {
 836                         if(credentials)backend = "rpc";
 837                         else backend = "nt4";
 838                 }
 839
 840                 error = reg_open(&registry, backend, location, credentials);
 841                 if(!W_ERROR_IS_OK(error)) {
 842                         gtk_show_werror(mainwin, error);
 843                         return -1;
 844                 }
 845                 mainwin = create_mainwin ();
 846                 registry_load_root();
 847         } else {
 848                 mainwin = create_mainwin ();
 849         }
 850
 851         gtk_widget_show_all (mainwin);
 852
 853         gtk_main ();
 854
 855         if(registry)talloc_destroy(registry->mem_ctx);
 856         talloc_destroy(mem_ctx);
 857         return 0;
 858 }
 859
 860