src/gpet.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
   2 /*
   3  * Gui Policy Editor for TOMOYO Linux
   4  *
   5  * gpet.c
   6  * Copyright (C) Yoshihiro Kusuno 2010,2011 <yocto@users.sourceforge.jp>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor Boston, MA 02110-1301,  USA
  21  */
  22
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28
  29 #ifdef HAVE_CONFIG_H
  30 #  include <config.h>
  31 #endif
  32
  33 #include <gtk/gtk.h>
  34 #include <glib/gi18n.h>
  35
  36 #include "gpet.h"
  37
  38 /*---------------------------------------------------------------------------*/
  39 /* from util.c (ccs-patch-1.8.1-20110505) */
  40 static gboolean is_octal_char(const char *str)
  41 {
  42         return *str >= '0' && *str++ <= '3' &&
  43                 *str >= '0' && *str++ <= '7' &&
  44                 *str >= '0' && *str <= '7';
  45 }
  46 /* from util.c (ccs-patch-1.8.1-20110505) */
  47 static gchar octal_char_to_binary(const char *str)
  48 {
  49         return ((str[0] - '0') << 6) + ((str[1] - '0') << 3) + (str[2] - '0');
  50 }
  51
  52 gchar *decode_from_octal_str(const char *name)
  53 {
  54         gchar   *tmp, buff[strlen(name)+1];
  55
  56         if (!name)
  57                 return NULL;
  58
  59         tmp = buff;
  60         for( ; *name; name++, tmp++) {
  61                 if (*name == '\\' && is_octal_char(name + 1)) {
  62                         name++;
  63                         *tmp = octal_char_to_binary(name);
  64                         name += 2;
  65                 } else {
  66                         *tmp = *name;
  67                 }
  68         }
  69         *tmp = *name;
  70
  71         return g_strdup(buff);
  72 }
  73
  74 /*---------------------------------------------------------------------------*/
  75 static gboolean is_jump_source(
  76                         struct ccs_domain_policy3 *dp, const int index)
  77 {
  78         return dp->list[index].target != NULL;
  79 }
  80 /*---------------------------------------------------------------------------*/
  81 enum tree_column_pos {
  82         COLUMN_INDEX,                   // data index (invisible)
  83         COLUMN_NUMBER,                  // n
  84         COLUMN_COLON,                   // :
  85         COLUMN_PROFILE,                 // profile
  86         COLUMN_KEEPER_DOMAIN,           // #
  87         COLUMN_INITIALIZER_TARGET,      // *
  88         COLUMN_DOMAIN_UNREACHABLE,      // !
  89         COLUMN_DOMAIN_NAME,             // domain name
  90         COLUMN_COLOR,                   // text color
  91         COLUMN_REDIRECT,                // redirect index (invisible)
  92         N_COLUMNS_TREE
  93 };
  94 /*---------------------------------------------------------------------------*/
  95 static int add_tree_store(GtkTreeStore *store, GtkTreeIter *parent_iter,
  96                         struct ccs_domain_policy3 *dp, int *index, int nest)
  97 {
  98         GtkTreeIter     iter;
  99         gchar           *color = "black";
 100         gchar           *str_num, *str_prof, *name;
 101         gchar           *line = NULL, *is_dis = NULL, *domain;
 102         const char      *sp;
 103         const struct ccs_transition_control_entry *transition_control;
 104         int             n, number, redirect_index = -1;
 105
 106 //g_print("add_tree_store index[%3d] nest[%2d]\n", *index, nest);
 107
 108         sp = get_domain_name(dp, *index);
 109         for (n = 0; ; n++) {
 110                 const char *cp = strchr(sp, ' ');
 111                 if (!cp)
 112                         break;
 113                 sp = cp + 1;
 114         }
 115         name = decode_from_octal_str(sp);
 116
 117         gtk_tree_store_append(store, &iter, parent_iter);
 118         number = dp->list[*index].number;
 119         if (number >= 0) {
 120                 str_num = g_strdup_printf("%4d", number);
 121                 str_prof = g_strdup_printf("%3u", dp->list[*index].profile);
 122         } else {
 123                 str_num = g_strdup("");
 124                 str_prof = g_strdup("");
 125         }
 126
 127         gtk_tree_store_set(store, &iter,
 128                 COLUMN_INDEX,           *index,
 129                 COLUMN_NUMBER,          str_num,
 130                 COLUMN_COLON,           number >= 0 ? ":" : "",
 131                 COLUMN_PROFILE,         str_prof,
 132                 COLUMN_KEEPER_DOMAIN,   dp->list[*index].is_dk ? "#" : " ",
 133                 COLUMN_INITIALIZER_TARGET, dp->list[*index].is_djt ? "*" : " ",
 134                 COLUMN_DOMAIN_UNREACHABLE, dp->list[*index].is_du ? "!" : " ",
 135                 -1);
 136         g_free(str_num);
 137         g_free(str_prof);
 138
 139         transition_control = dp->list[*index].d_t;
 140         if (transition_control && !is_jump_source(dp, *index)) {
 141                 line = g_strdup_printf(" ( %s%s from %s )",
 142                         get_transition_name(transition_control->type),
 143                         transition_control->program ?
 144                                 transition_control->program->name : "any",
 145                         transition_control->domainname ?
 146                                 transition_control->domainname->name : "any");
 147                 color =
 148                   transition_control->type == CCS_TRANSITION_CONTROL_KEEP ?
 149                   "green" : "cyan";
 150         } else if (is_jump_source(dp, *index)) {        /* initialize_domain */
 151                 g_free(name);
 152                 name = g_strdup(dp->list[*index].target->name);
 153                 redirect_index = get_find_target_domain(*index);
 154                 color = "blue";
 155                 if (redirect_index >= 0)
 156                         is_dis = g_strdup_printf(" ( -> %d )",
 157                                         dp->list[redirect_index].number);
 158                 else if (redirect_index == EOF)
 159                         is_dis = g_strdup_printf(" ( -> Not Found )");
 160                 else
 161                         is_dis = g_strdup_printf(" ( -> Namespace jump )");
 162         } else if (dp->list[*index].is_dd) {    /* delete_domain */
 163                 color = "gray";
 164         }
 165         domain = g_strdup_printf("%s%s%s%s%s%s",
 166                         dp->list[*index].is_dd ? "( " : "",
 167                         is_jump_source(dp, *index) ? "=> " : "",
 168                         name,
 169                         dp->list[*index].is_dd ? " )" : "",
 170                         line ? line : "",
 171                         is_dis ? is_dis : ""
 172                         );
 173         gtk_tree_store_set(store, &iter, COLUMN_DOMAIN_NAME, domain,
 174                                          COLUMN_COLOR, color,
 175                                          COLUMN_REDIRECT, redirect_index, -1);
 176         g_free(name);
 177         g_free(line);
 178         g_free(is_dis);
 179         g_free(domain);
 180
 181         (*index)++;
 182
 183         while (*index < dp->list_len) {
 184                 sp = get_domain_name(dp, *index);
 185                 for (n = 0; ; n++) {
 186                         const char *cp = strchr(sp, ' ');
 187                         if (!cp)
 188                                 break;
 189                         sp = cp + 1;
 190                 }
 191
 192                 if (n > nest)
 193                         n = add_tree_store(store, &iter, dp, index, n);
 194                 else
 195                         break;
 196         }
 197
 198         return n;
 199 }
 200
 201 void add_tree_data(GtkTreeView *treeview, struct ccs_domain_policy3 *dp)
 202 {
 203         GtkTreeStore    *store;
 204         GtkTreeIter     *iter = NULL;
 205         int             index = 0, nest = -1;
 206
 207         store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
 208         gtk_tree_store_clear(store);    // TODO 遅い
 209         if (dp->list_len > 0)
 210                 add_tree_store(store, iter, dp, &index, nest);
 211 }
 212 /*---------------------------------------------------------------------------*/
 213 static GtkTreeViewColumn *column_add(
 214                 GtkCellRenderer *renderer,
 215                 const GtkWidget *treeview,
 216                 const gchar *title,
 217                 enum tree_column_pos pos,
 218                 const gchar *attribute,
 219                 const gfloat xalign
 220                 )
 221 {
 222         GtkTreeViewColumn       *column;
 223
 224         g_object_set(renderer, "xalign", xalign, "ypad", 0, NULL);
 225         column = gtk_tree_view_column_new_with_attributes(
 226                                 title, renderer, attribute, pos, NULL);
 227         gtk_tree_view_column_add_attribute(column, renderer,
 228                                         "foreground", COLUMN_COLOR);
 229 //      gtk_tree_view_column_set_alignment(column, xalign);
 230         gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 231
 232         return column;
 233 }
 234 /*---------------------------------------------------------------------------*/
 235 /*
 236 static void cb_status_toggled(GtkCellRendererToggle     *renderer,
 237                                gchar                    *path_string,
 238                                gpointer                 user_data)
 239 {
 240         GtkTreeModel    *model;
 241         GtkTreeIter     iter;
 242         GtkTreePath     *path;
 243         gboolean        status;
 244
 245         model = gtk_tree_view_get_model(GTK_TREE_VIEW(user_data));
 246         path  = gtk_tree_path_new_from_string(path_string);
 247
 248         gtk_tree_model_get_iter(model, &iter, path);
 249         gtk_tree_model_get(model, &iter, COLUMN_INDEX, &status, -1);
 250         gtk_tree_store_set(GTK_TREE_STORE(model), &iter,
 251                       COLUMN_INDEX, !status, -1);
 252         gtk_tree_path_free(path);
 253 }
 254 */
 255 /*---------------------------------------------------------------------------*/
 256 static GtkWidget *create_tree_model(void)
 257 {
 258         GtkWidget               *treeview;
 259         GtkTreeStore            *store;
 260 //      GtkCellRenderer *renderer;
 261         GtkTreeViewColumn       *column;
 262
 263         store = gtk_tree_store_new(N_COLUMNS_TREE,
 264                                 G_TYPE_INT,
 265                                 G_TYPE_STRING,
 266                                 G_TYPE_STRING,
 267                                 G_TYPE_STRING,
 268                                 G_TYPE_STRING,
 269                                 G_TYPE_STRING,
 270                                 G_TYPE_STRING,
 271                                 G_TYPE_STRING,
 272                                 G_TYPE_STRING,
 273                                 G_TYPE_INT);
 274         treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 275         g_object_unref(store);
 276
 277 // TODO refactoring
 278 //      renderer = gtk_cell_renderer_toggle_new();
 279 //      g_signal_connect(renderer, "toggled",
 280 //                  G_CALLBACK(cb_status_toggled), treeview);
 281 /*
 282         renderer = gtk_cell_renderer_text_new();
 283         g_object_set(renderer, "visible", FALSE, NULL);
 284         column = column_add(renderer, treeview,
 285                         "", COLUMN_INDEX, "text", 0.0);
 286 */
 287         column = column_add(gtk_cell_renderer_text_new(), treeview,
 288                         "No.", COLUMN_NUMBER, "text", 1.0);
 289         column = column_add(gtk_cell_renderer_text_new(), treeview,
 290                         " ", COLUMN_COLON, "text", 0.5);
 291         column = column_add(gtk_cell_renderer_text_new(), treeview,
 292                         "prof", COLUMN_PROFILE, "text", 1.0);
 293         column = column_add(gtk_cell_renderer_text_new(), treeview,
 294                         "#", COLUMN_KEEPER_DOMAIN, "text", 0.5);
 295         column = column_add(gtk_cell_renderer_text_new(), treeview,
 296                         "*", COLUMN_INITIALIZER_TARGET, "text", 0.5);
 297         column = column_add(gtk_cell_renderer_text_new(), treeview,
 298                         "!", COLUMN_DOMAIN_UNREACHABLE, "text", 0.5);
 299         column = column_add(gtk_cell_renderer_text_new(), treeview,
 300                         "Domain Name", COLUMN_DOMAIN_NAME, "text", 0.0);
 301         // 開く位置
 302         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(treeview), column);
 303 //      gtk_tree_view_column_set_spacing(column, 1);
 304         // ヘッダ非表示
 305         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
 306
 307         return treeview;
 308 }
 309 /*---------------------------------------------------------------------------*/
 310 enum list_column_pos {
 311         LIST_NUMBER,            // n
 312         LIST_COLON,             // :
 313         LIST_ALIAS,             //
 314         LIST_OPERAND,           //
 315         N_COLUMNS_LIST
 316 };
 317
 318 void add_list_data(generic_list_t *generic,
 319                         enum ccs_screen_type current_page)
 320 {
 321         GtkListStore    *store;
 322         GtkTreeIter     iter;
 323         int             i;
 324         gchar           *str_num, *ope, *profile, *alias;
 325
 326         store = GTK_LIST_STORE(gtk_tree_view_get_model(
 327                                 GTK_TREE_VIEW(generic->listview)));
 328
 329         gtk_list_store_clear(store);
 330         for(i = 0; i < generic->count; i++){
 331                 str_num = g_strdup_printf("%4d", i);
 332                 gtk_list_store_append(store, &iter);
 333
 334                 switch((int)current_page) {
 335                 case CCS_SCREEN_EXCEPTION_LIST :
 336                 case CCS_SCREEN_ACL_LIST :
 337                         ope = decode_from_octal_str(generic->list[i].operand);
 338                         alias = (gchar *)
 339                           ccs_directives[generic->list[i].directive].alias;
 340                         gtk_list_store_set(store, &iter,
 341                                         LIST_NUMBER, str_num,
 342                                         LIST_COLON,  ":",
 343                                         LIST_ALIAS, alias,
 344                                         LIST_OPERAND, ope,
 345                                         -1);
 346                         g_free(ope);
 347                         break;
 348                 case CCS_SCREEN_PROFILE_LIST :
 349                         profile = g_strdup_printf("%3u-",
 350                                         generic->list[i].directive);
 351                         alias = g_strdup_printf("%s%s",
 352                                         generic->list[i].directive < 256 ?
 353                                         profile : "",
 354                                         generic->list[i].operand);
 355                         gtk_list_store_set(store, &iter,
 356                                         LIST_NUMBER, str_num,
 357                                         LIST_COLON,  ":",
 358                                         LIST_OPERAND, alias,
 359                                         -1);
 360                         g_free(profile);
 361                         g_free(alias);
 362                         break;
 363                 case CCS_SCREEN_NS_LIST :
 364                         gtk_list_store_set(store, &iter,
 365                                         LIST_NUMBER, str_num,
 366                                         LIST_COLON,  ":",
 367                                         LIST_OPERAND, generic->list[i].operand,
 368                                         -1);
 369                         break;
 370                 }
 371                 g_free(str_num);
 372         }
 373 }
 374
 375 static void disable_header_focus(GtkTreeViewColumn *column, const gchar *str)
 376 {
 377         GtkWidget               *label, *dummy;
 378         GtkButton               *button = GTK_BUTTON(gtk_button_new());
 379
 380         label = gtk_label_new(str);
 381         gtk_tree_view_column_set_widget(column, label);
 382         gtk_widget_show(label);
 383         dummy = gtk_tree_view_column_get_widget(column);
 384         while (dummy)    {
 385 //              g_print("<%s:%p> ", g_type_name(G_OBJECT_TYPE(dummy)), dummy);
 386
 387                 g_object_set(G_OBJECT(dummy), "can-focus", FALSE, NULL);
 388 //              gtk_widget_set_can_focus(dummy, FALSE); // 2.18
 389                 if (G_OBJECT_TYPE(dummy) == G_OBJECT_TYPE(button))
 390                         break;
 391                 dummy = gtk_widget_get_parent(dummy);
 392         }
 393 //      g_print("\n");
 394 }
 395
 396 static GtkWidget *create_list_model(gboolean alias_flag)
 397 {
 398         GtkWidget               *treeview;
 399         GtkListStore            *liststore;
 400         GtkCellRenderer *renderer;
 401         GtkTreeViewColumn       *column;
 402
 403         liststore = gtk_list_store_new(N_COLUMNS_LIST,
 404                                   G_TYPE_STRING, G_TYPE_STRING,
 405                                   G_TYPE_STRING, G_TYPE_STRING);
 406         treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(liststore));
 407         g_object_unref(liststore);
 408
 409         renderer = gtk_cell_renderer_text_new();
 410         g_object_set(renderer, "xalign", 1.0, "ypad", 0, NULL);
 411         column = gtk_tree_view_column_new_with_attributes(
 412                         "No.", renderer, "text", LIST_NUMBER, NULL);
 413         gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 414         gtk_tree_view_column_set_sort_column_id(column, LIST_NUMBER);
 415 //      gtk_tree_view_column_set_alignment(column, 1.0);
 416         disable_header_focus(column, "No.");
 417
 418         renderer = gtk_cell_renderer_text_new();
 419         column = gtk_tree_view_column_new_with_attributes(" ", renderer,
 420                                               "text", LIST_COLON, NULL);
 421         gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 422         disable_header_focus(column, " ");
 423
 424         if (alias_flag) {
 425                 renderer = gtk_cell_renderer_text_new();
 426                 column = gtk_tree_view_column_new_with_attributes(
 427                         "directive", renderer, "text", LIST_ALIAS, NULL);
 428                 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 429                 gtk_tree_view_column_set_sort_column_id(column, LIST_ALIAS);
 430                 disable_header_focus(column, "directive");
 431         }
 432
 433         renderer = gtk_cell_renderer_text_new();
 434         column = gtk_tree_view_column_new_with_attributes("operand", renderer,
 435                                               "text", LIST_OPERAND, NULL);
 436         gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 437         gtk_tree_view_column_set_sort_column_id(column, LIST_OPERAND);
 438         disable_header_focus(column, "operand");
 439
 440         // ヘッダ表示
 441 //      gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
 442
 443         return treeview;
 444 }
 445 /*---------------------------------------------------------------------------*/
 446 gint get_current_domain_index(transition_t *transition)
 447 {
 448         GtkTreeSelection        *selection;
 449         GtkTreeModel            *model;
 450         GtkTreeIter             iter;
 451         GList                   *list;
 452         gint                    index = -1;
 453
 454         selection = gtk_tree_view_get_selection(
 455                                 GTK_TREE_VIEW(transition->treeview));
 456         if (selection &&
 457             gtk_tree_selection_count_selected_rows(selection)) {
 458                 list = gtk_tree_selection_get_selected_rows(selection, NULL);
 459                 model = gtk_tree_view_get_model(
 460                                 GTK_TREE_VIEW(transition->treeview));
 461                 gtk_tree_model_get_iter(model, &iter, g_list_first(list)->data);
 462                 gtk_tree_model_get(model, &iter, COLUMN_INDEX, &index, -1);
 463                 g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
 464                 g_list_free(list);
 465         }
 466         DEBUG_PRINT("select Domain index[%d]\n", index);
 467         return index;
 468 }
 469
 470 gchar *get_alias_and_operand(GtkWidget *view, gboolean alias_flag)
 471 {
 472         GtkTreeSelection        *selection;
 473         GtkTreeIter             iter;
 474         GtkTreeModel            *model;
 475         GList                   *list;
 476         gchar                   *alias = NULL, *operand = NULL,
 477                                 *str_buff = NULL;
 478
 479         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
 480         if (selection &&
 481             gtk_tree_selection_count_selected_rows(selection)) {
 482                 list = gtk_tree_selection_get_selected_rows(selection, NULL);
 483                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 484                 gtk_tree_model_get_iter(model, &iter, g_list_first(list)->data);
 485                 if (alias_flag) {
 486                         gtk_tree_model_get(model, &iter,
 487                                 LIST_ALIAS, &alias, LIST_OPERAND, &operand, -1);
 488                         str_buff = g_strdup_printf("%s %s", alias, operand);
 489                         g_free(alias);
 490                         g_free(operand);
 491                 } else {
 492                         gtk_tree_model_get(model, &iter,
 493                                                 LIST_OPERAND, &operand, -1);
 494                         str_buff = g_strchug(operand);
 495                 }
 496         }
 497
 498         return str_buff;
 499 }
 500 /*---------------------------------------------------------------------------*/
 501 static gboolean move_pos_list(GtkTreeModel *model, GtkTreePath *path,
 502                                 GtkTreeIter *iter, transition_t *transition)
 503 {
 504         GtkWidget               *view = NULL;
 505         GtkTreeSelection        *selection;
 506         gint                    index;
 507         gchar                   *alias = NULL, *operand = NULL;
 508         gchar                   *entry, *str_buff = NULL;
 509         int                     cmp = -1;
 510
 511
 512         entry = get_combo_entry_last();
 513
 514         switch((int)transition->addentry) {
 515         case ADDENTRY_DOMAIN_LIST :
 516                 view = transition->treeview;
 517                 gtk_tree_model_get(model, iter, COLUMN_INDEX, &index, -1);
 518                 str_buff = decode_from_octal_str(
 519                                         get_domain_name(transition->dp, index));
 520                 cmp = strcmp(entry, str_buff);
 521                 break;
 522         case ADDENTRY_ACL_LIST :
 523                 view = transition->acl.listview;
 524                 gtk_tree_model_get(model, iter,
 525                                 LIST_ALIAS, &alias, LIST_OPERAND, &operand, -1);
 526                 str_buff = g_strdup_printf("%s %s", alias, operand);    // TODO
 527                 cmp = strcmp(entry, str_buff);
 528 //g_print("%2d[%s][%s]\n", cmp, entry, str_buff);
 529                 break;
 530         case ADDENTRY_EXCEPTION_LIST :
 531                 view = transition->exp.listview;
 532                 gtk_tree_model_get(model, iter,
 533                                 LIST_ALIAS, &alias, LIST_OPERAND, &operand, -1);
 534                 str_buff = g_strdup_printf("%s %s", alias, operand);    // TODO
 535                 cmp = strcmp(entry, str_buff);
 536                 break;
 537         case ADDENTRY_PROFILE_LIST :
 538                 view = transition->prf.listview;
 539                 gtk_tree_model_get(model, iter, LIST_NUMBER, &str_buff, -1);
 540                 cmp = atoi(entry) - transition->prf.list[atoi(str_buff)].directive;
 541 //g_print("entry[%s] [%s:%d]\n", entry, str_buff, transition->prf.list[atoi(str_buff)].directive);
 542                 break;
 543         case ADDENTRY_NAMESPACE_LIST :
 544                 view = transition->ns.listview;
 545                 gtk_tree_model_get(model, iter, LIST_OPERAND, &operand, -1);
 546                 cmp = strcmp(entry, operand);
 547                 break;
 548         }
 549         g_free(alias);
 550         g_free(operand);
 551         g_free(str_buff);
 552         g_free(entry);
 553
 554         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
 555
 556         if (cmp) {
 557                 gtk_tree_selection_unselect_path(selection, path);
 558                 return FALSE;
 559         } else {
 560                 gtk_tree_selection_select_path(selection, path);
 561 #if 0
 562         {// debug
 563                 gchar *path_str = gtk_tree_path_to_string(path);
 564                 g_print("Put Path[%s]\n", path_str);
 565                 g_free(path_str);
 566         }
 567 #endif
 568                 return TRUE;
 569         }
 570 }
 571
 572 void set_position_addentry(transition_t *transition, GtkTreePath **path)
 573 {
 574         GtkWidget               *view = NULL;
 575         GtkTreeModel            *model;
 576         GtkTreeSelection        *selection;
 577         GList                   *list;
 578
 579
 580         switch((int)transition->addentry) {
 581         case ADDENTRY_NON :
 582                 return;
 583                 break;
 584         case ADDENTRY_DOMAIN_LIST :
 585                 view = transition->treeview;
 586                 break;
 587         case ADDENTRY_ACL_LIST :
 588                 view = transition->acl.listview;
 589                 break;
 590         case ADDENTRY_EXCEPTION_LIST :
 591                 view = transition->exp.listview;
 592                 break;
 593         case ADDENTRY_PROFILE_LIST :
 594                 view = transition->prf.listview;
 595                 break;
 596         case ADDENTRY_NAMESPACE_LIST :
 597                 view = transition->ns.listview;
 598                 break;
 599         }
 600
 601         model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 602         gtk_tree_model_foreach(model,
 603                 (GtkTreeModelForeachFunc)move_pos_list, transition);
 604         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
 605         list = gtk_tree_selection_get_selected_rows(selection, NULL);
 606         if (list) {
 607                 gtk_tree_path_free(*path);
 608                 (*path) = gtk_tree_path_copy(g_list_first(list)->data);
 609                 g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
 610                 g_list_free(list);
 611         }
 612         transition->addentry = ADDENTRY_NON;
 613
 614 #if 0
 615         {// debug
 616                 gchar *path_str = gtk_tree_path_to_string(*path);
 617                 g_print("Get Path[%s]\n", path_str);
 618                 g_free(path_str);
 619         }
 620 #endif
 621 }
 622 /*---------------------------------------------------------------------------*/
 623 static void cb_selection(GtkTreeSelection *selection,
 624                                 transition_t *transition)
 625 {
 626         GtkTreeIter             iter;
 627         gint                    select_count;
 628         GtkTreeModel            *model;
 629         GList                   *list;
 630         gint                    index;
 631         GtkTreePath             *path = NULL;
 632         GtkTreeViewColumn       *column = NULL;
 633         gchar                   *name;
 634
 635         DEBUG_PRINT("In  **************************** \n");
 636         select_count = gtk_tree_selection_count_selected_rows(selection);
 637         DEBUG_PRINT("select count[%d]\n", select_count);
 638         if (0 == select_count)
 639                 return;
 640
 641         model = gtk_tree_view_get_model(
 642                                 GTK_TREE_VIEW(transition->treeview));
 643         list = gtk_tree_selection_get_selected_rows(selection, NULL);
 644         gtk_tree_model_get_iter(model, &iter, g_list_first(list)->data);
 645         g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
 646         g_list_free(list);
 647         gtk_tree_model_get(model, &iter, COLUMN_INDEX, &index, -1);
 648         DEBUG_PRINT("--- index [%4d] ---\n", index);
 649         name = decode_from_octal_str(get_domain_name(transition->dp, index));
 650         if (is_jump_source(transition->dp, index)) {
 651                 gchar *cp = strrchr(name, ' ');
 652                 if (cp)
 653                         *cp = '\0';
 654         }
 655         gtk_entry_set_text(GTK_ENTRY(transition->domainbar), name);
 656         g_free(name);
 657
 658         gtk_tree_view_get_cursor(GTK_TREE_VIEW(
 659                         transition->acl.listview), &path, &column);
 660
 661         get_acl_list(transition->dp, index,
 662                 &(transition->acl.list), &(transition->acl.count));
 663         add_list_data(&(transition->acl), CCS_SCREEN_ACL_LIST);
 664
 665         if (transition->acl.count) {
 666                 set_position_addentry(transition, &path);
 667                 DEBUG_PRINT("ACL count<%d>\n", transition->acl.count);
 668                 DEBUG_PRINT("ACL ");
 669                 view_cursor_set(transition->acl.listview, path, column);
 670 //              gtk_widget_grab_focus(transition->acl.listview);
 671                 disp_statusbar(transition, CCS_SCREEN_ACL_LIST);
 672         } else {        /* delete_domain or initializer_source */
 673                 disp_statusbar(transition, CCS_MAXSCREEN);
 674         }
 675         DEBUG_PRINT("Out **************************** \n");
 676 }
 677 /*---------------------------------------------------------------------------*/
 678 static void set_ns_tab_label(transition_t *transition,
 679                                 const gchar *namespace)
 680 {
 681         GtkWidget               *notebook;
 682         GtkWidget               *tab4;
 683
 684         notebook = g_object_get_data(
 685                                 G_OBJECT(transition->window), "notebook");
 686         tab4 = g_object_get_data(
 687                                 G_OBJECT(transition->window), "tab4");
 688         gtk_notebook_set_tab_label_text(
 689                                 GTK_NOTEBOOK(notebook), tab4, namespace);
 690         gtk_notebook_set_menu_label_text(
 691                                 GTK_NOTEBOOK(notebook), tab4, namespace);
 692
 693         put_ns_name(namespace);
 694 }
 695 /*---------------------------------------------------------------------------*/
 696 struct FindIsDis_t {
 697         gint            redirect_index;
 698         GtkTreeIter     iter;
 699         GtkTreePath     *path;
 700 };
 701
 702 static gboolean find_is_dis(GtkTreeModel *model, GtkTreePath *path,
 703                 GtkTreeIter *iter, struct FindIsDis_t *data)
 704 {
 705         gint            index;
 706
 707         gtk_tree_model_get(model, iter, COLUMN_INDEX, &index, -1);
 708         if (data->redirect_index == index) {
 709                 data->iter = *iter;
 710                 data->path = gtk_tree_path_copy(path);
 711                 return TRUE;
 712         }
 713         return FALSE;
 714 }
 715
 716 static void cb_initialize_domain(GtkTreeView *treeview, GtkTreePath *treepath,
 717                 GtkTreeViewColumn *treeviewcolumn, transition_t *transition)
 718 {
 719         GtkTreeIter             iter;
 720         GtkTreeModel            *model;
 721         struct FindIsDis_t      data;
 722         gint                    index;
 723
 724         DEBUG_PRINT("In  **************************** \n");
 725         model = gtk_tree_view_get_model(treeview);
 726         if (!gtk_tree_model_get_iter(model, &iter, treepath))
 727                 return;
 728
 729         gtk_tree_model_get(model, &iter, COLUMN_INDEX, &index,
 730                                 COLUMN_REDIRECT, &data.redirect_index, -1);
 731 //#undef DEBUG_PRINT
 732 //#define DEBUG_PRINT g_print
 733         DEBUG_PRINT("index[%d] redirect_index[%d]\n", index, data.redirect_index);
 734
 735         if (data.redirect_index == -2) {
 736                 gchar *namespace =
 737                         g_strdup(transition->dp->list[index].target->name);
 738                 DEBUG_PRINT("%s\n", namespace);
 739                 char *cp = strchr(namespace, ' ');
 740                 if (cp)
 741                         *cp = '\0';
 742                 set_ns_tab_label(transition, namespace);
 743                 g_free(namespace);
 744                 refresh_transition(NULL, transition);
 745                 return;
 746         } else if (data.redirect_index < 0)
 747                 return;         /* not initialize_domain */
 748
 749         data.path = NULL;
 750         gtk_tree_model_foreach(model,
 751                 (GtkTreeModelForeachFunc)find_is_dis, &data);
 752
 753         if (data.path) {
 754           {
 755                 gchar *path_str = gtk_tree_path_to_string(data.path);
 756                 DEBUG_PRINT("TreePath[%s]\n", path_str);
 757                 g_free(path_str);
 758           }
 759                 GtkTreeViewColumn       *column = NULL;
 760                 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(treeview), data.path);
 761                 gtk_tree_selection_select_iter(
 762                         gtk_tree_view_get_selection(
 763                         GTK_TREE_VIEW(treeview)), &data.iter);
 764                 DEBUG_PRINT("Domain ");
 765                 view_cursor_set(GTK_WIDGET(treeview), data.path, column);
 766         }
 767         DEBUG_PRINT("Out **************************** \n");
 768 }
 769 /*---------------------------------------------------------------------------*/
 770 void set_sensitive(GtkActionGroup *actions, int task_flag,
 771                                 enum ccs_screen_type current_page)
 772 {
 773         gboolean        sens_edt, sens_add, sens_del, sens_tsk,
 774                         sens_dch, sens_cpy, sens_opt;
 775
 776         sens_edt = sens_add = sens_del = sens_tsk =
 777                         sens_dch = sens_cpy = sens_opt = FALSE;
 778
 779         switch((int)current_page) {
 780         case CCS_SCREEN_DOMAIN_LIST :
 781         case CCS_MAXSCREEN :
 782                 sens_edt = TRUE;
 783                 sens_tsk = TRUE;
 784                 sens_dch = TRUE;
 785                 if (!task_flag) {
 786                         sens_add = TRUE;
 787                         sens_del = TRUE;
 788                         sens_cpy = TRUE;
 789                 }
 790                 break;
 791         case CCS_SCREEN_ACL_LIST :
 792                 sens_add = TRUE;
 793                 sens_del = TRUE;
 794                 sens_tsk = TRUE;
 795                 sens_dch = TRUE;
 796                 sens_cpy = TRUE;
 797                 sens_opt = TRUE;
 798                 break;
 799         case CCS_SCREEN_EXCEPTION_LIST :
 800                 sens_add = TRUE;
 801                 sens_del = TRUE;
 802                 sens_cpy = TRUE;
 803                 break;
 804         case CCS_SCREEN_PROFILE_LIST :
 805                 sens_edt = TRUE;
 806                 sens_add = TRUE;
 807                 sens_cpy = TRUE;
 808                 break;
 809         case CCS_SCREEN_NS_LIST :
 810                 sens_add = TRUE;
 811                 sens_cpy = TRUE;
 812                 break;
 813         }
 814
 815         gtk_action_set_sensitive(gtk_action_group_get_action(
 816                                         actions, "Edit"), sens_edt);
 817         gtk_action_set_sensitive(gtk_action_group_get_action(
 818                                         actions, "Add"), sens_add);
 819         gtk_action_set_sensitive(gtk_action_group_get_action(
 820                                         actions, "Delete"), sens_del);
 821         gtk_action_set_sensitive(gtk_action_group_get_action(
 822                                         actions, "ACL"), sens_dch);
 823         gtk_action_set_sensitive(gtk_action_group_get_action(
 824                                         actions, "Copy"), sens_cpy);
 825         gtk_action_set_sensitive(gtk_action_group_get_action(
 826                                 actions, "OptimizationSupport"), sens_opt);
 827
 828         if (!is_offline())
 829                 gtk_action_set_sensitive(gtk_action_group_get_action(
 830                                         actions, "Process"), sens_tsk);
 831 }
 832
 833 static gint popup_menu(transition_t *transition, guint button)
 834 {
 835         if (button == 3) {
 836                 GtkWidget       *popup;
 837                 /* get menu.c create_menu()*/
 838                 popup = g_object_get_data(
 839                                 G_OBJECT(transition->window), "popup");
 840
 841                 gtk_menu_popup(GTK_MENU(popup), NULL, NULL, NULL, NULL,
 842                                         0, gtk_get_current_event_time());
 843                 return TRUE;
 844         }
 845
 846         return FALSE;
 847 }
 848
 849 static gboolean cb_select_domain(GtkTreeView *treeview,  GdkEventButton *event,
 850                                 transition_t *transition)
 851 {
 852         transition->current_page = CCS_SCREEN_DOMAIN_LIST;
 853
 854         set_sensitive(transition->actions, transition->task_flag,
 855                                                 transition->current_page);
 856         if (event->button == 3) {
 857                 GtkWidget       *popup;
 858                 /* get menu.c create_menu()*/
 859                 popup = g_object_get_data(
 860                                 G_OBJECT(transition->window), "popup");
 861
 862                 gtk_menu_popup(GTK_MENU(popup), NULL, NULL, NULL, NULL,
 863                                         0, gtk_get_current_event_time());
 864                 return TRUE;
 865         }
 866
 867         return FALSE;
 868 }
 869
 870 static gboolean cb_select_acl(GtkTreeView *listview,  GdkEventButton *event,
 871                                 transition_t *transition)
 872 {
 873         transition->current_page = CCS_SCREEN_ACL_LIST;
 874         set_sensitive(transition->actions, transition->task_flag,
 875                                                 transition->current_page);
 876         return popup_menu(transition, event->button);
 877 }
 878
 879 static gboolean cb_select_exp(GtkTreeView *listview,  GdkEventButton *event,
 880                                 transition_t *transition)
 881 {
 882         transition->current_page = CCS_SCREEN_EXCEPTION_LIST;
 883         set_sensitive(transition->actions, transition->task_flag,
 884                                                 transition->current_page);
 885         return popup_menu(transition, event->button);
 886 }
 887
 888 static gboolean cb_select_prf(GtkTreeView *listview,  GdkEventButton *event,
 889                                 transition_t *transition)
 890 {
 891         transition->current_page = CCS_SCREEN_PROFILE_LIST;
 892         set_sensitive(transition->actions, transition->task_flag,
 893                                                 transition->current_page);
 894         return popup_menu(transition, event->button);
 895 }
 896
 897 static gboolean cb_select_ns(GtkTreeView *listview,  GdkEventButton *event,
 898                                 transition_t *transition)
 899 {
 900         transition->current_page = CCS_SCREEN_NS_LIST;
 901         set_sensitive(transition->actions, transition->task_flag,
 902                                                 transition->current_page);
 903         return popup_menu(transition, event->button);
 904 }
 905 /*---------------------------------------------------------------------------*/
 906 static void cb_ns_selection(GtkTreeSelection *selection,
 907                                 transition_t *transition)
 908 {
 909         GtkTreeIter             iter;
 910         GtkTreeModel            *model;
 911         GList                   *list;
 912         gchar                   *namespace;
 913
 914         if (0 == gtk_tree_selection_count_selected_rows(selection))
 915                 return;
 916
 917         model = gtk_tree_view_get_model(
 918                                 GTK_TREE_VIEW(transition->ns.listview));
 919         list = gtk_tree_selection_get_selected_rows(selection, NULL);
 920         gtk_tree_model_get_iter(model, &iter, g_list_first(list)->data);
 921         g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
 922         g_list_free(list);
 923         gtk_tree_model_get(model, &iter, LIST_OPERAND, &namespace, -1);
 924         set_ns_tab_label(transition, namespace);
 925         g_free(namespace);
 926 }
 927 /*---------------------------------------------------------------------------*/
 928 static gboolean inc_search(GtkTreeModel *model, gint column,
 929                 const gchar *key, GtkTreeIter *iter, gpointer search_data)
 930 {
 931         gchar   *buff;
 932         gboolean ret;
 933
 934         gtk_tree_model_get(model, iter, column, &buff, -1);
 935         DEBUG_PRINT("key[%s] buff[%s]\n", key, buff);
 936         ret = g_strrstr(buff, key) ? FALSE : TRUE;
 937         g_free(buff);
 938
 939         return ret;
 940 }
 941
 942 void view_setting(GtkWidget *treeview, gint search_column)
 943 {
 944         // 複数行選択可
 945         gtk_tree_selection_set_mode(
 946                         gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)),
 947                         GTK_SELECTION_MULTIPLE);
 948         // マウス複数行選択
 949         gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(treeview), TRUE);
 950         // インクリメンタルサーチ
 951         gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview),
 952                                                         search_column);
 953         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(treeview), TRUE);
 954         gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview),
 955                         (GtkTreeViewSearchEqualFunc)inc_search, NULL, NULL);
 956 }
 957
 958 /*---------------------------------------------------------------------------*/
 959 static GtkContainer *create_domain_view(GtkWidget *paned,
 960                 GtkWidget *treeview, void (*paned_pack)(),
 961                 gboolean resize,
 962                 GtkWidget *acl_window, gboolean *acl_detached)
 963 {
 964         GtkWidget       *scrolledwin;
 965         GtkContainer    *container;
 966
 967         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 968         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 969                                 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
 970         gtk_scrolled_window_set_shadow_type(
 971                         GTK_SCROLLED_WINDOW(scrolledwin), GTK_SHADOW_IN);
 972
 973         paned_pack(GTK_PANED(paned), scrolledwin, resize, TRUE);
 974
 975         if (!resize) {
 976                 view_setting(treeview, LIST_OPERAND);
 977         } else {
 978                 view_setting(treeview, COLUMN_DOMAIN_NAME);
 979         }
 980
 981         container = GTK_CONTAINER(scrolledwin);
 982         gtk_container_add(container, treeview);
 983
 984         return container;
 985 }
 986 /*---------------------------------------------------------------------------*/
 987 static void create_list_view(GtkWidget *box, GtkWidget *listview,
 988                                 gboolean multi_flag)
 989 {
 990         GtkWidget       *scrolledwin;
 991
 992         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 993         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 994                                         GTK_POLICY_AUTOMATIC,
 995                                         GTK_POLICY_ALWAYS);
 996         gtk_scrolled_window_set_shadow_type(
 997                 GTK_SCROLLED_WINDOW(scrolledwin), GTK_SHADOW_IN);
 998         gtk_box_pack_start(GTK_BOX(box), scrolledwin, TRUE, TRUE, 0);
 999         gtk_container_add(GTK_CONTAINER(scrolledwin), listview);
1000
1001         if (multi_flag) {
1002                 // 複数行選択可
1003                 gtk_tree_selection_set_mode(
1004                         gtk_tree_view_get_selection(
1005                                 GTK_TREE_VIEW(listview)),
1006                                 GTK_SELECTION_MULTIPLE);
1007                 // マウス複数行選択
1008                 gtk_tree_view_set_rubber_banding(
1009                                         GTK_TREE_VIEW(listview), TRUE);
1010         }
1011         // インクリメンタルサーチ
1012         gtk_tree_view_set_search_column(
1013                 GTK_TREE_VIEW(listview), LIST_OPERAND);
1014         gtk_tree_view_set_enable_search(
1015                 GTK_TREE_VIEW(listview), TRUE);
1016         gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(listview),
1017                 (GtkTreeViewSearchEqualFunc)inc_search, NULL, NULL);
1018 }
1019 /*---------------------------------------------------------------------------*/
1020 static void set_select_flag_domain(gpointer data,
1021                                         transition_t *transition)
1022 {
1023         GtkTreeModel            *model;
1024         GtkTreeIter             iter;
1025         gint                    index;
1026         struct ccs_domain_policy3 *dp = transition->dp;
1027
1028
1029         model = gtk_tree_view_get_model(
1030                                 GTK_TREE_VIEW(transition->treeview));
1031         if (!model || !gtk_tree_model_get_iter(model, &iter, data)) {
1032                 g_warning("ERROR: %s(%d)", __FILE__, __LINE__);
1033                 return;
1034         }
1035         gtk_tree_model_get(model, &iter, COLUMN_INDEX, &index, -1);
1036
1037         DEBUG_PRINT("index[%d]\n", index);
1038         /* deleted_domain or initializer_source */
1039         if (!(dp->list[index].is_dd) && !(dp->list[index].target))
1040                 dp->list_selected[index] = 1;
1041 }
1042
1043 gint delete_domain(transition_t *transition,
1044                         GtkTreeSelection *selection, gint count)
1045 {
1046         GList           *list;
1047         char            *err_buff = NULL;
1048         int             result;
1049
1050
1051         list = gtk_tree_selection_get_selected_rows(selection, NULL);
1052         g_list_foreach(list, (GFunc)set_select_flag_domain, transition);
1053
1054         g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
1055         g_list_free(list);
1056
1057         result = delete_domain_policy(transition->dp, &err_buff);
1058         if (result) {
1059                 g_warning("%s", err_buff);
1060                 free(err_buff);
1061         }
1062
1063         return result;
1064 }
1065 /*---------------------------------------------------------------------------*/
1066 gint set_domain_profile(transition_t *transition,
1067                         GtkTreeSelection *selection, guint profile)
1068 {
1069         char            *profile_str;
1070         GList           *list;
1071         char            *err_buff = NULL;
1072         int             result;
1073
1074         list = gtk_tree_selection_get_selected_rows(selection, NULL);
1075         if (transition->task_flag)
1076                 g_list_foreach(list, (GFunc)set_select_flag_process,
1077                                         &(transition->tsk));
1078         else
1079                 g_list_foreach(list, (GFunc)set_select_flag_domain,
1080                                         transition);
1081
1082         g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
1083         g_list_free(list);
1084
1085         profile_str = g_strdup_printf("%u", profile);
1086         result = set_profile(transition->dp, profile_str, &err_buff);
1087 //      g_free(profile_str);    → editpolicy.c
1088         if (result) {
1089                 g_warning("%s", err_buff);
1090                 free(err_buff);
1091         }
1092
1093         return result;
1094 }
1095 /*---------------------------------------------------------------------------*/
1096 gboolean disp_acl_line(GtkTreeModel *model, GtkTreePath *path,
1097                                 GtkTreeIter *iter, generic_list_t *acl)
1098 {
1099         GtkTreeSelection        *selection;
1100         gchar                   *str_num;
1101
1102         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(acl->listview));
1103
1104         gtk_tree_model_get(model, iter, LIST_NUMBER, &str_num, -1);
1105
1106         if (acl->list[atoi(str_num)].selected) {
1107 #if 0
1108 gchar *str_path = gtk_tree_path_to_string(path);
1109 g_print("select[%d] path[%s]\n", atoi(str_num), str_path);
1110 g_free(str_path);
1111 #endif
1112                 gtk_tree_selection_select_path(selection, path);
1113         } else {
1114                 gtk_tree_selection_unselect_path(selection, path);
1115         }
1116
1117         g_free(str_num);
1118         return FALSE;
1119 }
1120
1121 gint select_list_line(generic_list_t *gen)
1122 {
1123         GtkTreeSelection        *selection;
1124         GtkTreeIter             iter;
1125         GtkTreeModel            *model;
1126         GList                   *list;
1127         gchar                   *str_num;
1128         gint                    index = -1;
1129
1130         selection = gtk_tree_view_get_selection(
1131                                         GTK_TREE_VIEW(gen->listview));
1132         if (!selection ||
1133             !gtk_tree_selection_count_selected_rows(selection))
1134                 return index;
1135
1136         list = gtk_tree_selection_get_selected_rows(selection, NULL);
1137         if (!list)
1138                 return index;
1139
1140         model = gtk_tree_view_get_model(GTK_TREE_VIEW(gen->listview));
1141         gtk_tree_model_get_iter(model, &iter, g_list_first(list)->data);
1142         gtk_tree_model_get(model, &iter, LIST_NUMBER, &str_num, -1);
1143         g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
1144         g_list_free(list);
1145
1146         index = atoi(str_num);
1147         g_free(str_num);
1148
1149         return index;
1150 }
1151 /*---------------------------------------------------------------------------*/
1152 static void set_delete_flag_gen(gpointer data, generic_list_t *gen)
1153 {
1154         GtkTreeModel            *model;
1155         GtkTreeIter             iter;
1156         gchar                   *str_num;
1157
1158         model = gtk_tree_view_get_model(GTK_TREE_VIEW(gen->listview));
1159         if (!model || !gtk_tree_model_get_iter(model, &iter, data)) {
1160                 g_warning("ERROR: %s(%d)", __FILE__, __LINE__);
1161                 return;
1162         }
1163         gtk_tree_model_get(model, &iter, LIST_NUMBER, &str_num, -1);
1164
1165         DEBUG_PRINT("index[%d]\n", atoi(str_num));
1166         gen->list[atoi(str_num)].selected = 1;
1167         g_free(str_num);
1168 }
1169
1170 gint delete_acl(transition_t *transition,
1171                         GtkTreeSelection *selection, gint count)
1172 {
1173         GList           *list;
1174         char            *err_buff = NULL;
1175         int             result;
1176
1177
1178         list = gtk_tree_selection_get_selected_rows(selection, NULL);
1179         g_list_foreach(list, (GFunc)set_delete_flag_gen, &(transition->acl));
1180         g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
1181         g_list_free(list);
1182
1183         result = delete_acl_policy(transition->dp, &err_buff,
1184                         transition->acl.list, transition->acl.count);
1185         if (result) {
1186                 g_warning("%s", err_buff);
1187                 free(err_buff);
1188         }
1189
1190         return result;
1191 }
1192
1193 gint delete_exp(transition_t *transition,
1194                         GtkTreeSelection *selection, gint count)
1195 {
1196         GList           *list;
1197         char            *err_buff = NULL;
1198         int             result;
1199
1200         list = gtk_tree_selection_get_selected_rows(selection, NULL);
1201         g_list_foreach(list, (GFunc)set_delete_flag_gen, &(transition->exp));
1202         g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
1203         g_list_free(list);
1204
1205         result = delete_exp_policy(transition->dp, &err_buff,
1206                         transition->exp.list, transition->exp.count);
1207         if (result) {
1208                 g_warning("%s", err_buff);
1209                 free(err_buff);
1210         }
1211
1212         return result;
1213 }
1214 /*---------------------------------------------------------------------------*/
1215 static void create_tabs(GtkWidget *notebook, GtkWidget *box, const gchar *str)
1216 {
1217         GtkWidget       *label, *label_box, *menu_box;
1218
1219         // create tab
1220         label_box = gtk_hbox_new(FALSE, 0);
1221         label = gtk_label_new(str);
1222         gtk_box_pack_start(GTK_BOX(label_box), label, FALSE, TRUE, 0);
1223         gtk_widget_show_all(label_box);
1224
1225         // create context menu for tab
1226         menu_box = gtk_hbox_new(FALSE, 0);
1227         label = gtk_label_new(str);
1228         gtk_box_pack_start(GTK_BOX(menu_box), label, FALSE, TRUE, 0);
1229         gtk_widget_show_all(menu_box);
1230
1231         gtk_notebook_append_page_menu(GTK_NOTEBOOK(notebook),
1232                                         box, label_box, menu_box);
1233 }
1234
1235 gchar *disp_window_title(enum ccs_screen_type current_page)
1236 {
1237         char    str_ip[32];
1238         gchar   *title = NULL;
1239         const char *dir = get_policy_dir();
1240         enum    mode_enum {e_off, e_net, e_on, e_end};
1241         const gchar *mode[e_end] = {_("offline"), _("nework"), _("online")};
1242
1243
1244         switch((int)current_page) {
1245         case CCS_SCREEN_DOMAIN_LIST :
1246         case CCS_SCREEN_ACL_LIST :
1247                 if (is_offline())
1248                         title = g_strdup_printf("%s - %s%s%s", mode[e_off], dir,
1249                          CCS_DISK_POLICY_DIR, CCS_DISK_POLICY_DOMAIN_POLICY);
1250                 else if (is_network())
1251                         title = g_strdup_printf("%s(%s) - %s", mode[e_net],
1252                                         get_remote_ip(str_ip),
1253                                         CCS_PROC_POLICY_DOMAIN_POLICY);
1254                 else
1255                         title = g_strdup_printf("%s - %s", mode[e_on],
1256                                         CCS_PROC_POLICY_DOMAIN_POLICY);
1257                 break;
1258         case CCS_SCREEN_EXCEPTION_LIST :
1259                 if (is_offline())
1260                         title = g_strdup_printf("%s - %s%s%s", mode[e_off], dir,
1261                          CCS_DISK_POLICY_DIR, CCS_DISK_POLICY_EXCEPTION_POLICY);
1262                 else if (is_network())
1263                         title = g_strdup_printf("%s(%s) - %s", mode[e_net],
1264                                         get_remote_ip(str_ip),
1265                                         CCS_PROC_POLICY_EXCEPTION_POLICY);
1266                 else
1267                         title = g_strdup_printf("%s - %s", mode[e_on],
1268                                         CCS_PROC_POLICY_EXCEPTION_POLICY);
1269                 break;
1270         case CCS_SCREEN_PROFILE_LIST :
1271         case CCS_SCREEN_NS_LIST :
1272                 if (is_offline())
1273                         title = g_strdup_printf("%s - %s%s%s", mode[e_off], dir,
1274                          CCS_DISK_POLICY_DIR, CCS_DISK_POLICY_PROFILE);
1275                 else if (is_network())
1276                         title = g_strdup_printf("%s(%s) - %s", mode[e_net],
1277                                         get_remote_ip(str_ip),
1278                                         CCS_PROC_POLICY_PROFILE);
1279                 else
1280                         title = g_strdup_printf("%s - %s", mode[e_on],
1281                                         CCS_PROC_POLICY_PROFILE);
1282                 break;
1283         case CCS_SCREEN_STAT_LIST :
1284                 if (is_network())
1285                         title = g_strdup_printf("%s: %s(%s) - %s",
1286                                         _("Statistics"), mode[e_net],
1287                                         get_remote_ip(str_ip),
1288                                         CCS_PROC_POLICY_STAT);
1289                 else
1290                         title = g_strdup_printf("%s: %s - %s",
1291                                         _("Statistics"), mode[e_on],
1292                                         CCS_PROC_POLICY_STAT);
1293                 break;
1294         case CCS_SCREEN_MANAGER_LIST :
1295                 if (is_offline())
1296                         title = g_strdup_printf("%s: %s - %s%s%s",
1297                                 _("Manager Policy"), mode[e_off], dir,
1298                                 CCS_DISK_POLICY_DIR, CCS_DISK_POLICY_MANAGER);
1299                 else if (is_network())
1300                         title = g_strdup_printf("%s: %s(%s) - %s",
1301                                 _("Manager Policy"), mode[e_net],
1302                                 get_remote_ip(str_ip),
1303                                 CCS_PROC_POLICY_MANAGER);
1304                 else
1305                         title = g_strdup_printf("%s: %s - %s",
1306                                 _("Manager Policy"), mode[e_on],
1307                                 CCS_PROC_POLICY_MANAGER);
1308                 break;
1309         case CCS_MAXSCREEN :
1310                 if (is_offline())
1311                         title = g_strdup_printf("%s: %s - %s%s%s",
1312                                 _("Domain Policy Editor"), mode[e_off], dir,
1313                          CCS_DISK_POLICY_DIR, CCS_DISK_POLICY_DOMAIN_POLICY);
1314                 else if (is_network())
1315                         title = g_strdup_printf("%s: %s(%s) - %s",
1316                                         _("Domain Policy Editor"), mode[e_net],
1317                                         get_remote_ip(str_ip),
1318                                         CCS_PROC_POLICY_DOMAIN_POLICY);
1319                 else
1320                         title = g_strdup_printf("%s: %s - %s",
1321                                         _("Domain Policy Editor"), mode[e_on],
1322                                         CCS_PROC_POLICY_DOMAIN_POLICY);
1323                 break;
1324         }
1325
1326         return title;
1327 }
1328
1329 static void control_acl_window(transition_t *tran)
1330 {
1331         static gint             x, y, w, h;
1332         static gboolean saved_flag = FALSE;
1333
1334         if (tran->current_page == CCS_SCREEN_ACL_LIST) {
1335                 gtk_window_move(GTK_WINDOW(tran->acl_window), x, y);
1336                 gtk_window_set_default_size(
1337                                 GTK_WINDOW(tran->acl_window), w, h);
1338                 saved_flag = FALSE;
1339                 gtk_widget_show(tran->acl_window);
1340         } else {
1341                 if (!saved_flag) {
1342                         gtk_window_get_position(
1343                                 GTK_WINDOW(tran->acl_window), &x, &y);
1344                         gtk_window_get_size(
1345                                 GTK_WINDOW(tran->acl_window), &w, &h);
1346                         saved_flag = TRUE;
1347                 }
1348                 gtk_widget_hide(tran->acl_window);
1349         }
1350 }
1351
1352 static void cb_switch_page(GtkWidget    *notebook,
1353                                 GtkNotebookPage *page,
1354                                 gint            page_num,
1355                                 transition_t    *tran)
1356 {
1357         GtkTreeSelection        *selection_tree, *selection_list;
1358         gint                    old_page_num;
1359         gchar                   *title;
1360
1361         old_page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
1362         if (page_num == old_page_num)
1363                 return;
1364
1365         DEBUG_PRINT("In  Tab[%d]\n", page_num);
1366         switch(page_num) {
1367         case 0 :
1368                 selection_tree = gtk_tree_view_get_selection(
1369                                         GTK_TREE_VIEW(tran->treeview));
1370                 selection_list = gtk_tree_view_get_selection(
1371                                         GTK_TREE_VIEW(tran->acl.listview));
1372                 if (tran->acl_detached) {
1373                         tran->current_page = CCS_SCREEN_ACL_LIST;
1374                         control_acl_window(tran);
1375                 }
1376                 if (tran->task_flag ||
1377                         (selection_tree &&
1378                     gtk_tree_selection_count_selected_rows(selection_tree)))
1379                         tran->current_page = CCS_SCREEN_DOMAIN_LIST;
1380                 else if(selection_list &&
1381                     gtk_tree_selection_count_selected_rows(selection_list))
1382                         tran->current_page = CCS_SCREEN_ACL_LIST;
1383                 else
1384                         tran->current_page = CCS_MAXSCREEN;
1385                 g_object_set(G_OBJECT(notebook), "can-focus", TRUE, NULL);
1386                 break;
1387         case 1 :
1388                 tran->current_page = CCS_SCREEN_EXCEPTION_LIST;
1389                 if (tran->acl_detached) {
1390                         control_acl_window(tran);
1391                 }
1392                 g_object_set(G_OBJECT(notebook), "can-focus", FALSE, NULL);
1393                 break;
1394         case 2 :
1395                 tran->current_page = CCS_SCREEN_PROFILE_LIST;
1396                 if (tran->acl_detached) {
1397                         control_acl_window(tran);
1398                 }
1399                 g_object_set(G_OBJECT(notebook), "can-focus", FALSE, NULL);
1400                 break;
1401         case 3 :
1402                 tran->current_page = CCS_SCREEN_NS_LIST;
1403                 if (tran->acl_detached) {
1404                         control_acl_window(tran);
1405                 }
1406                 g_object_set(G_OBJECT(notebook), "can-focus", FALSE, NULL);
1407                 break;
1408         }
1409
1410         title = disp_window_title(tran->current_page);
1411         gtk_window_set_title(GTK_WINDOW(tran->window), title);
1412         g_free(title);
1413         set_sensitive(tran->actions, tran->task_flag,
1414                                         tran->current_page);
1415
1416         refresh_transition(NULL, tran);
1417         disp_statusbar(tran, tran->current_page);
1418         DEBUG_PRINT("Out Tab[%d]\n", page_num);
1419 }
1420 /*---------------------------------------------------------------------------*/
1421 static void cb_set_focus(GtkWindow *window,
1422                                 GtkWidget *view, transition_t *tran)
1423 {
1424         if (view == tran->treeview) {
1425                 DEBUG_PRINT("Focus changed!!<Domain>\n");
1426                 tran->current_page = CCS_SCREEN_DOMAIN_LIST;
1427         } else if (view == tran->acl.listview) {
1428                 DEBUG_PRINT("Focus changed!!<Acl>(%p)\n", view);
1429                 tran->current_page = CCS_SCREEN_ACL_LIST;
1430         } else if (view == tran->exp.listview) {
1431                 DEBUG_PRINT("Focus changed!!<Exception>\n");
1432                 tran->current_page = CCS_SCREEN_EXCEPTION_LIST;
1433         } else if (view == tran->prf.listview) {
1434                 DEBUG_PRINT("Focus changed!!<Profile>\n");
1435                 tran->current_page = CCS_SCREEN_PROFILE_LIST;
1436         } else if (view == tran->tsk.treeview) {
1437                 DEBUG_PRINT("Focus changed!!<Process>\n");
1438                 tran->current_page = CCS_SCREEN_DOMAIN_LIST;
1439         } else if (G_IS_OBJECT(view)) {
1440                 DEBUG_PRINT("Focus changed!![Other:%s(%p)]\n",
1441                                 g_type_name(G_OBJECT_TYPE(view)), view);
1442 //              g_object_set(G_OBJECT(view), "can-focus", FALSE, NULL);
1443         } else {
1444                 DEBUG_PRINT("Focus changed!![Not object(%p)]\n", view);
1445         }
1446 }
1447
1448 static void cb_set_focus_acl(GtkWindow *window,
1449                                 GtkWidget *view, transition_t *tran)
1450 {
1451         tran->current_page = CCS_SCREEN_ACL_LIST;
1452
1453         if (view == tran->acl.listview) {
1454                 DEBUG_PRINT("Focus changed!!<Acl>(%p)\n", view);
1455         } else if (G_IS_OBJECT(view)) {
1456                 DEBUG_PRINT("Focus changed!![Other:%s(%p)]\n",
1457                                 g_type_name(G_OBJECT_TYPE(view)), view);
1458                 g_object_set(G_OBJECT(view), "can-focus", FALSE, NULL);
1459         } else {
1460                 DEBUG_PRINT("Focus changed!![Not object(%p)]\n", view);
1461         }
1462 }
1463
1464 static void cb_show_acl(GtkWidget *view, transition_t *tran)
1465 {
1466         DEBUG_PRINT("Show ACL!!(%p)==(%p)\n", tran->acl.listview, view);
1467 }
1468 /*---------------------------------------------------------------------------*/
1469 int gpet_main(void)
1470 {
1471         GtkWidget       *window;
1472         GtkWidget       *menubar, *toolbar = NULL;
1473         GtkWidget       *statusbar;
1474         gint            contextid;
1475         GtkWidget       *vbox;
1476         GtkWidget       *tab1, *tab2, *tab3, *tab4;
1477         GtkWidget       *notebook;
1478         GtkWidget       *pane;
1479         GtkWidget       *domainbar;
1480         GtkWidget       *acl_window;
1481         GtkWidget       *treeview, *listview;
1482         GtkContainer    *container, *acl_container;
1483         gchar           *title;
1484         struct ccs_domain_policy3 dp = { NULL, 0, NULL };
1485         transition_t    transition;
1486
1487         transition.task_flag = 0;
1488         if (get_domain_policy(&dp, &(transition.domain_count)))
1489                 return 1;
1490         /*-----------------------------------------------*/
1491
1492         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1493         transition.window = window;
1494         gtk_window_set_title(GTK_WINDOW(window), _("gpet"));
1495         gtk_window_set_icon(GTK_WINDOW(window), get_png_file());
1496         gtk_container_set_border_width(GTK_CONTAINER(window), 0);
1497         g_signal_connect(G_OBJECT(window), "destroy",
1498                                 G_CALLBACK(gtk_main_quit), NULL);
1499
1500         vbox = gtk_vbox_new(FALSE, 1);
1501         gtk_container_add(GTK_CONTAINER(window), vbox);
1502
1503         // create menu bar & tool bar & popup menu
1504         menubar = create_menu(window, &transition, &toolbar);
1505         gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
1506         gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
1507
1508         // create notebook
1509         notebook = gtk_notebook_new();
1510 //      gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
1511         gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
1512         gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
1513         g_object_set(G_OBJECT(notebook), "can-focus", FALSE, NULL);
1514
1515         // create status bar
1516         statusbar = gtk_statusbar_new();
1517         gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
1518         contextid = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "");
1519         gtk_statusbar_push(GTK_STATUSBAR(statusbar), contextid, _("gpet"));
1520
1521
1522         tab1 = gtk_vbox_new(FALSE, 1);
1523         // create name bar for full domain name
1524         domainbar = gtk_entry_new();
1525         gtk_box_pack_start(GTK_BOX(tab1), domainbar, FALSE, FALSE, 0);
1526         gtk_editable_set_editable(GTK_EDITABLE(domainbar), FALSE);
1527         gtk_entry_set_has_frame(GTK_ENTRY(domainbar), FALSE);
1528         gtk_entry_set_text(GTK_ENTRY(domainbar), "");
1529 //      gtk_widget_set_can_focus(domainbar, FALSE);     // 2.18
1530         g_object_set(G_OBJECT(domainbar), "can-focus", FALSE, NULL);
1531
1532         pane = gtk_vpaned_new();
1533         g_object_set_data(G_OBJECT(window), "pane", pane);/* to save config */
1534         gtk_box_pack_start(GTK_BOX(tab1), pane, TRUE, TRUE, 0);
1535
1536         // create domain transition view
1537         treeview = create_tree_model();
1538         container = create_domain_view(
1539                         pane, treeview, gtk_paned_pack1, TRUE, NULL, NULL);
1540 //a     add_tree_data(GTK_TREE_VIEW(treeview), &dp);
1541 //a     gtk_tree_view_expand_all(GTK_TREE_VIEW(treeview));
1542                 // ツリーインデント pixel(2.12)
1543 //      gtk_tree_view_set_level_indentation(GTK_TREE_VIEW(treeview), 0);
1544                 // ツリー開くマーク(2.12)
1545 //      gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(treeview), TRUE);
1546         g_object_set(G_OBJECT(treeview), "enable-tree-lines", FALSE,
1547                                                 NULL);
1548 //      gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(treeview),
1549 //                                      GTK_TREE_VIEW_GRID_LINES_NONE);
1550         // create domain policy float window
1551         acl_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1552         title = disp_window_title(CCS_MAXSCREEN);
1553         gtk_window_set_title(GTK_WINDOW(acl_window), title);
1554         g_free(title);
1555         gtk_container_set_border_width(GTK_CONTAINER(acl_window), 0);
1556         gtk_window_set_position(GTK_WINDOW(acl_window),
1557                                                 GTK_WIN_POS_CENTER);
1558         gtk_window_set_destroy_with_parent(GTK_WINDOW(acl_window), TRUE);
1559         gtk_window_add_accel_group(GTK_WINDOW(acl_window),
1560                 g_object_get_data(G_OBJECT(window), "AccelGroup"));
1561         gtk_widget_hide(acl_window);
1562
1563         // create domain policy view
1564         listview = create_list_model(TRUE);
1565         transition.acl_detached = FALSE;
1566         acl_container = create_domain_view(pane, listview, gtk_paned_pack2,
1567                         FALSE, acl_window, &transition.acl_detached);
1568         /* to save menu.c Detach_acl() */
1569         g_object_set_data(G_OBJECT(window), "acl_container", acl_container);
1570
1571         // copy data pointer
1572         transition.domainbar = domainbar;
1573         transition.container = container;
1574         transition.treeview = treeview;
1575         transition.acl.listview = listview;
1576         transition.acl_window = acl_window;
1577         transition.statusbar = statusbar;
1578         transition.contextid = contextid;
1579         transition.dp = &dp;
1580         transition.acl.count = 0;
1581         transition.acl.list = NULL;
1582         transition.tsk.treeview = create_task_tree_model(&transition);
1583         transition.addentry = ADDENTRY_NON;
1584
1585         // cursor move  domain window
1586         g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)),
1587                         "changed", G_CALLBACK(cb_selection), &transition);
1588 //      g_signal_connect(GTK_TREE_VIEW(treeview), "cursor-changed",
1589 //                      G_CALLBACK(cb_selection), &transition);
1590         // double click or enter key  domain window
1591         g_signal_connect(G_OBJECT(treeview), "row-activated",
1592                         G_CALLBACK(cb_initialize_domain), &transition);
1593         // mouse click  domain window
1594         g_signal_connect(G_OBJECT(treeview), "button-press-event",
1595                         G_CALLBACK(cb_select_domain), &transition);
1596         // mouse click  acl window
1597         g_signal_connect(G_OBJECT(listview), "button-press-event",
1598                         G_CALLBACK(cb_select_acl), &transition);
1599
1600
1601         tab2 = gtk_vbox_new(FALSE, 1);
1602         // create exception policy view
1603         listview = create_list_model(TRUE);
1604         create_list_view(tab2, listview, TRUE);
1605         transition.exp.listview = listview;
1606         // mouse click  exception window
1607         g_signal_connect(G_OBJECT(listview), "button-press-event",
1608                          G_CALLBACK(cb_select_exp), &transition);
1609
1610         tab3 = gtk_vbox_new(FALSE, 1);
1611         // create profile view
1612         listview = create_list_model(FALSE);
1613         create_list_view(tab3, listview, FALSE);
1614         transition.prf.listview = listview;
1615         transition.prf.count = 0;
1616         transition.prf.list = NULL;
1617         if (get_profile(&(transition.prf.list), &(transition.prf.count)))
1618                 g_warning("Read error : profile");
1619         else
1620                 add_list_data(&(transition.prf), CCS_SCREEN_PROFILE_LIST);
1621         // mouse click  profile window
1622         g_signal_connect(G_OBJECT(listview), "button-press-event",
1623                          G_CALLBACK(cb_select_prf), &transition);
1624
1625         tab4 = gtk_vbox_new(FALSE, 1);
1626         // create namespace view
1627         listview = create_list_model(FALSE);
1628         create_list_view(tab4, listview, FALSE);
1629         transition.ns.listview = listview;
1630         transition.ns.count = 0;
1631         transition.ns.list = NULL;
1632         if (get_namespace(&(transition.ns.list), &(transition.ns.count)))
1633                 g_warning("Read error : namespace");
1634         else
1635                 add_list_data(&(transition.ns), CCS_SCREEN_NS_LIST);
1636         // mouse click  namespace window
1637         g_signal_connect(G_OBJECT(listview), "button-press-event",
1638                          G_CALLBACK(cb_select_ns), &transition);
1639         // cursor move  namespace window
1640         g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(listview)),
1641                         "changed", G_CALLBACK(cb_ns_selection), &transition);
1642
1643         // create tab
1644         create_tabs(notebook, tab1, _("Domain Transition"));
1645         create_tabs(notebook, tab2, _("Exception Policy"));
1646         create_tabs(notebook, tab3, _("Profile"));
1647         create_tabs(notebook, tab4, get_ns_name());
1648
1649         /* to save menu.c Process_state() */
1650         g_object_set_data(G_OBJECT(window), "notebook", notebook);
1651         g_object_set_data(G_OBJECT(window), "tab1", tab1);
1652         /* to save cb_ns_selection() */
1653         g_object_set_data(G_OBJECT(window), "tab4", tab4);
1654
1655         // tab change
1656         g_signal_connect(G_OBJECT(notebook), "switch_page",
1657                                 G_CALLBACK(cb_switch_page), &transition);
1658         read_config(&transition);
1659
1660         /* set widget names for .gpetrc */
1661         gtk_widget_set_name(transition.window, "GpetMainWindow");
1662         gtk_widget_set_name(transition.domainbar, "GpetDomainbar");
1663         gtk_widget_set_name(transition.acl_window, "GpetAclWindow");
1664
1665         gtk_widget_show_all(window);
1666
1667         gtk_main();
1668
1669         return 0;
1670 }
1671 /*---------------------------------------------------------------------------*/
1672 int main(int argc, char **argv)
1673 {
1674         const gchar *homedir = g_getenv("HOME");
1675         gchar   *gpetrc;
1676         int     result;
1677
1678 #ifdef ENABLE_NLS
1679         bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
1680         bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
1681         textdomain(GETTEXT_PACKAGE);
1682 #endif
1683
1684         gtk_init(&argc, &argv);
1685
1686         if (!homedir)
1687                 homedir = g_get_home_dir ();
1688         gpetrc = g_build_path("/", homedir, ".gpetrc", NULL);
1689         gtk_rc_parse(gpetrc);
1690         g_free(gpetrc);
1691
1692         result = ccs_main(argc, argv);
1693
1694         return result;
1695 }
1696 /*---------------------------------------------------------------------------*/