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