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