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