list-ui.c

这是一个用于管理个人事物安排的应用程序

            break;
            case COMPLETED:
              sicon = tick_icon;
            break;
            case ABANDONED:
              sicon = bar_icon;
            break;
            default:
              sicon = no_tick_icon;
            break;
            }
            
          categories = build_categories_string(i);
            
          gtk_list_store_append (list_store, &iter);
    
          gtk_list_store_set (list_store, &iter, 
                              COL_ICON, sicon,
                              COL_SUMMARY, i->summary,  
                              COL_STRIKETHROUGH, complete, 
                              COL_DATA, i,
                              COL_PRIORITY, priority,
                              COL_PRIORITY_TEXT, state_map[i->state].string,
                              COL_DUE, time,
                              COL_CATEGORY, categories,
                              -1);
          if (categories)
              g_free(categories);
        }
    }

  g_slist_free (list);
}

gboolean
button_press_event (GtkWidget *widget, GdkEventButton *b)
{
  if (b->button == 3)
    {
      gint x, y;
      GtkTreeViewColumn *col;
      GtkTreePath *path;
  
      x = b->x;
      y = b->y;
      
      if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
                                         x, y,
                                         &path, &col,
                                         NULL, NULL))
        {
          GtkTreeIter iter;
          struct todo_item *i;
    
          gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store), &iter, path);
          gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter, COL_DATA, &i, -1);
          gtk_menu_popup (GTK_MENU (item_menu), NULL, NULL, NULL, NULL, b->button, b->time);
          current_menu_item = i;
          gtk_tree_path_free (path);
        }
    }

  return TRUE;
}

gboolean
button_release_event (GtkWidget *widget, GdkEventButton *b)
{
  if (b->button == 1)
    {
      gint x, y;
      GtkTreeViewColumn *col;
      GtkTreePath *path;
  
      x = b->x;
      y = b->y;

      if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
                                         x, y,
                                         &path, &col,
                                         NULL, NULL))
        {
          GtkTreeViewColumn *pix_col;
              
          pix_col = g_object_get_data (G_OBJECT (widget), "pixmap-column");
          
          if (pix_col == col)
            toggle_completed (path);
          else
            open_editing_window (path);
      
          gtk_tree_path_free (path);
        }
    }

  return TRUE;
}

#ifdef IS_HILDON
static void
toggle_toolbar(GtkCheckMenuItem *menuitem, gpointer user_data)
{
  if (gtk_check_menu_item_get_active(menuitem))
    gtk_widget_show(toolbar);
  else
    gtk_widget_hide(toolbar);
}

static void
update_categories (GtkWidget *w, GSList *new, gpointer t)
{
  categories_menu ();
  if (new)
      g_slist_free(new);
}

static void
edit_categories (GtkWidget *w)
{
  GtkWidget *dialog;

  dialog = gpe_pim_categories_dialog (NULL, FALSE, 
                                      G_CALLBACK(update_categories), NULL);
  gtk_window_set_transient_for(GTK_WINDOW(dialog), 
                               GTK_WINDOW(gtk_widget_get_toplevel(w)));
  gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
}
#endif


#ifdef IS_HILDON
/* create hildon application main menu */
static void
create_app_menu(HildonAppView *appview)
{
  GtkMenu *menu_main = hildon_appview_get_menu(appview);    
  GtkWidget *menu_items = gtk_menu_new();
  GtkWidget *menu_categories = gtk_menu_new();
  GtkWidget *menu_view = gtk_menu_new();
  GtkWidget *menu_tools = gtk_menu_new();
    
  GtkWidget *item_items = gtk_menu_item_new_with_label(_("Item"));
  GtkWidget *item_categories = gtk_menu_item_new_with_label(_("Categories"));
  GtkWidget *item_view = gtk_menu_item_new_with_label(_("View"));
  GtkWidget *item_tools = gtk_menu_item_new_with_label(_("Tools"));
  GtkWidget *item_close = gtk_menu_item_new_with_label(_("Close"));
  GtkWidget *item_open = gtk_menu_item_new_with_label(_("Open..."));
  GtkWidget *item_add = gtk_menu_item_new_with_label(_("Add new"));
  GtkWidget *item_catedit = gtk_menu_item_new_with_label(_("Edit categories"));
  GtkWidget *item_toolbar = gtk_check_menu_item_new_with_label(_("Show toolbar"));
  GtkWidget *item_delete = gtk_menu_item_new_with_label(_("Delete completed items"));
  GtkWidget *item_move = gtk_menu_item_new_with_label(_("Move completed items to the end"));

  gtk_menu_append (GTK_MENU(menu_items), item_open);
  gtk_menu_append (GTK_MENU(menu_items), item_add);
  gtk_menu_append (GTK_MENU(menu_categories), item_catedit);
  gtk_menu_append (GTK_MENU(menu_view), item_toolbar);
  gtk_menu_append (GTK_MENU(menu_tools), item_delete);
  gtk_menu_append (GTK_MENU(menu_tools), item_move);
  gtk_menu_append (menu_main, item_items);
  gtk_menu_append (menu_main, item_categories);
  gtk_menu_append (menu_main, item_view);
  gtk_menu_append (menu_main, item_tools);
  gtk_menu_append (menu_main, item_close);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_items), menu_items);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_categories), menu_categories);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_view), menu_view);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_tools), menu_tools);

  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item_toolbar), TRUE);

  g_signal_connect(G_OBJECT(item_add), "activate", G_CALLBACK(new_todo_item), NULL);
  g_signal_connect(G_OBJECT(item_open), "activate", G_CALLBACK(item_do_edit), NULL);
  g_signal_connect(G_OBJECT(item_catedit), "activate", G_CALLBACK(edit_categories), NULL);
  g_signal_connect(G_OBJECT(item_toolbar), "activate", G_CALLBACK(toggle_toolbar), NULL);
  g_signal_connect(G_OBJECT(item_delete), "activate", G_CALLBACK(delete_completed_items), NULL);
  g_signal_connect(G_OBJECT(item_move), "activate", G_CALLBACK(refresh_items), NULL);
  g_signal_connect(G_OBJECT(item_close), "activate", G_CALLBACK(gtk_main_quit), NULL);

  gtk_widget_show_all (GTK_WIDGET(menu_main));  
}
#endif


static GtkItemFactoryEntry menu_items[] =
{
  { "/_Edit",   NULL, item_do_edit,     0, "<Item>" },
  { "/_Delete", NULL, item_do_delete,   0, "<StockItem>", GTK_STOCK_DELETE },
};

GtkWidget *
top_level (GtkWidget *window)
{
  GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
  GtkWidget *option = gtk_option_menu_new ();
  GtkWidget *scrolled = gtk_scrolled_window_new (NULL, NULL);
  GtkWidget *list_view;
  GtkAccelGroup *accel_group;
  GtkItemFactory *item_factory;
  GtkToolItem *item;
  GtkWidget *w;

  no_tick_icon = gpe_find_icon ("notick-box");
  tick_icon = gpe_find_icon ("tick-box");
  bar_icon = gpe_find_icon ("bar-box");
  dot_icon = gpe_find_icon ("dot-box");
  high_icon = gpe_find_icon ("high");

  g_option = option;
  categories_menu ();

  accel_group = gtk_accel_group_new ();
  item_factory = gtk_item_factory_new (GTK_TYPE_MENU, "<main>", accel_group);
  g_object_set_data_full (G_OBJECT (window), "<main>", item_factory,
                          (GDestroyNotify) g_object_unref);
  gtk_item_factory_create_items (item_factory, 
                                 sizeof (menu_items) / sizeof (menu_items[0]), 
                                 menu_items, NULL);

  item_menu = gtk_item_factory_get_widget (item_factory, "<main>");

  toolbar = gtk_toolbar_new ();
  gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL);

  /* New button */
#ifdef IS_HILDON  
  w = gtk_image_new_from_file(ICON_PATH "/qgn_indi_gene_plus.png");
  item = gtk_tool_button_new(w, _("New"));
#else
  item = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);
#endif
  g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK (new_todo_item), NULL);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
  
  /* Delete button */
#ifdef IS_HILDON  
  w = gtk_image_new_from_file(ICON_PATH "/qgn_toolb_gene_deletebutton.png");
  item = gtk_tool_button_new(w, _("Delete"));
#else
  item = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
#endif
  g_signal_connect(G_OBJECT(item), "clicked", 
                   G_CALLBACK (delete_completed_items), NULL);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
  

#ifdef IS_HILDON
  create_app_menu (HILDON_APPVIEW(window));
  
  w = gtk_image_new_from_file(ICON_PATH "/qgn_toolb_gene_refresh.png");
  item = gtk_tool_button_new(w, _("Refresh"));
  g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK (refresh_items), 
                   NULL);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
	  
  if (mode_landscape || large_screen)
    {
      w = gtk_image_new_from_file(ICON_PATH "/qgn_list_gene_bullets.png");
      item = gtk_tool_button_new(w, _("Categories"));
      g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK (edit_categories), 
                       NULL);
      gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
    }
    
  gtk_box_pack_end (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
#else
  /* Insert refresh button if we have enough space */
  if (mode_landscape || large_screen)
    {
      item = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH);
      g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK (refresh_items), 
                       NULL);
      gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);        
    }
	
  gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
#endif
    
  item = gtk_separator_tool_item_new();
  gtk_tool_item_set_expand(GTK_TOOL_ITEM(item), FALSE);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);

  if (mode_landscape || large_screen)
    {
      GtkWidget *label = gtk_label_new(_("Show:"));
      item = gtk_tool_item_new();
      gtk_container_add(GTK_CONTAINER(item), label);
      gtk_tool_item_set_expand(GTK_TOOL_ITEM(item), FALSE);
      gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
    }
    
  /* Category menu */    
  item = gtk_tool_item_new();
  gtk_container_add(GTK_CONTAINER(item), option);
  gtk_tool_item_set_expand(GTK_TOOL_ITEM(item), FALSE);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);

#ifndef IS_HILDON    
  /* Some space and quit button */
  item = gtk_separator_tool_item_new();
  gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(item), FALSE);
  gtk_tool_item_set_expand(GTK_TOOL_ITEM(item), TRUE);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
  item = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
  g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK (gtk_main_quit), NULL);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
#endif
    
  list_store = gtk_list_store_new (NUM_COLUMNS, 
                                   GDK_TYPE_PIXBUF, 
                                   G_TYPE_STRING, 
 								   G_TYPE_BOOLEAN, 
								   G_TYPE_POINTER,
                                   G_TYPE_STRING, 
                                   G_TYPE_STRING, 
                                   G_TYPE_STRING, 
                                   GDK_TYPE_PIXBUF,
                                   G_TYPE_STRING);
  list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));

  {
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *col;

    renderer = gtk_cell_renderer_pixbuf_new ();
    col = gtk_tree_view_column_new_with_attributes ("", renderer,
                                                    "pixbuf", COL_PRIORITY,
                                                    NULL);
    gtk_tree_view_column_set_min_width(col, 20);
    gtk_tree_view_insert_column (GTK_TREE_VIEW (list_view), col, -1);

    renderer = gtk_cell_renderer_pixbuf_new ();
    col = gtk_tree_view_column_new_with_attributes ("", renderer,
                                                    "pixbuf", COL_ICON, 
                                                    NULL);
    gtk_tree_view_column_set_min_width(col, 20);
    gtk_tree_view_insert_column (GTK_TREE_VIEW (list_view), col, -1);

    g_object_set_data (G_OBJECT (list_view), "pixmap-column", col);

   if (large_screen)
      {
        renderer = gtk_cell_renderer_text_new ();
        col = gtk_tree_view_column_new_with_attributes (_("Status"), renderer,
                                                        "text", COL_PRIORITY_TEXT,
                                                        "strikethrough", COL_STRIKETHROUGH, NULL);
        gtk_tree_view_insert_column (GTK_TREE_VIEW (list_view), col, -1);
      }
    renderer = gtk_cell_renderer_text_new ();
    col = gtk_tree_view_column_new_with_attributes (_("Summary"), renderer,
                                                    "text", COL_SUMMARY,
                                                    "strikethrough", COL_STRIKETHROUGH, NULL);
    gtk_tree_view_column_set_expand(col, TRUE);
#ifdef IS_HILDON	  
	gtk_tree_view_column_set_max_width(col, 360);
#endif	  
    gtk_tree_view_insert_column (GTK_TREE_VIEW (list_view), col, -1);
	
    if (large_screen)
      {
        renderer = gtk_cell_renderer_text_new ();
        col = gtk_tree_view_column_new_with_attributes (_("Due Date"), renderer,
                                                        "text", COL_DUE,
                                                        "strikethrough", COL_STRIKETHROUGH, NULL);
        gtk_tree_view_insert_column (GTK_TREE_VIEW (list_view), col, -1);
        renderer = gtk_cell_renderer_text_new ();
        col = gtk_tree_view_column_new_with_attributes (_("Category"), renderer,
                                                        "text", COL_CATEGORY,
                                                        "strikethrough", COL_STRIKETHROUGH, NULL);
        gtk_tree_view_insert_column (GTK_TREE_VIEW (list_view), col, -1);        
      }
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list_view), TRUE);
    gtk_tree_view_set_reorderable (GTK_TREE_VIEW (list_view), FALSE);
  }

  g_signal_connect (G_OBJECT (list_view), "button_press_event", 
                    G_CALLBACK (button_press_event), NULL);
  g_signal_connect (G_OBJECT (list_view), "button_release_event", 
                    G_CALLBACK (button_release_event), NULL);
  
  gtk_container_add (GTK_CONTAINER (scrolled), list_view);

  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
                                  GTK_POLICY_NEVER,
                                  GTK_POLICY_AUTOMATIC);

  gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);

  refresh_items ();

  return vbox;
}