/*! * \brief GUI thread only create a plot surface and periodically call a * gui_handler that redraws the plot after a short timeout */ static gpointer gui_thread (gpointer data) { GtkWidget *window; GtkWidget *drawing_area; /* Create the Widgets */ GtkWidget *vbox, *menubar, *filemenu,*editmenu,*viewmenu,*helpmenu, *file, *edit, *view, *help,*pref_1,*toolbar,*help_Dialog,*about_Dialog, *new,*sep1,*sep2, *open,*save,*dialog, *save_as,*export,*export_diag, *quit, *sep, *tog_stat,*statusbar, *tog_tool; gdk_threads_enter(); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); /* Some nesseary inits */ GtkAccelGroup *accel_group = NULL; GtkToolItem *test_item; GtkToolItem *item_1; GtkToolItem *item_2; GtkToolItem *item_3; GtkToolItem *item_4; /* Set the window title */ gtk_window_set_title(GTK_WINDOW(window), "eStick Control Center V0.0-ecc"); /* Add Window Icon max size 128x128 Pixel current 64x64 used */ gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("window_symbol.png")); /* Default Window size at startup */ gtk_window_set_default_size (GTK_WINDOW(window), xsize+xoff, ysize+yoff); /* Set Border With of the window in Pixels */ gtk_container_set_border_width(GTK_CONTAINER(window), 0); /* Create a new Vertical Box, FALSE= WIdgets have not equal space, 0 pixels between widgets */ vbox = gtk_vbox_new(FALSE, 0); /* Add the Vertical Box to the main window */ gtk_container_add(GTK_CONTAINER(window), vbox); drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (drawing_area, xsize, ysize); /* Create the Menu Bar */ menubar = gtk_menu_bar_new(); /* Create the Toolbar Bar */ toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0); /* Create a new Statusbar*/ statusbar = gtk_statusbar_new(); /* Create the Handlers for the submenus*/ filemenu = gtk_menu_new(); editmenu = gtk_menu_new(); viewmenu = gtk_menu_new(); helpmenu = gtk_menu_new(); /* Create new accelerator Group */ accel_group = gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW(window), accel_group); /* Create the File Drop Down Point in the menu bar with mnemonic character */ file = gtk_menu_item_new_with_mnemonic("_File"); /* Create the Edit Drop Down Point in the menu bar with mnemonic character */ edit = gtk_menu_item_new_with_mnemonic("_Edit"); /* Create the View Drop Down Point in the menu bar with mnemonic character */ view = gtk_menu_item_new_with_mnemonic("_View"); /* Create the Help Drop Down Point in the menu bar with mnemonic character */ help = gtk_menu_item_new_with_mnemonic("_Help"); /* ############################# Items for the Menu Bar################## */ /* Use the open point from the libary and the stock symbol */ open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL); g_signal_connect(G_OBJECT(open), "activate",G_CALLBACK(file_open),file_open); /*Connect signal to display the Message for the Save Menu Item in the statusbar, when the mouse cursors hovers over*/ g_signal_connect (G_OBJECT (open), "enter-notify-event",G_CALLBACK (statusbar_hint), statusbar); /*Remove Message from the statusbar when the mouse cursors leaves this menu point*/ g_signal_connect (G_OBJECT (open), "leave-notify-event",G_CALLBACK (statusbar_hint), statusbar); /*Attach the text for the statusbar to the Menu Item*/ g_object_set_data (G_OBJECT (open), "menuhint",(gpointer) "Open a recorded File"); /* Create vertical seperator line in the file menu */ sep1 = gtk_separator_menu_item_new(); /* Use the save point from the libary and the stock symbol */ save = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, NULL); g_signal_connect(G_OBJECT(save), "activate",G_CALLBACK(file_save),(gpointer) window); /*Connect signal to display the Message for the Save Menu Item in the statusbar, when the mouse cursors hovers over*/ g_signal_connect (G_OBJECT (save), "enter-notify-event",G_CALLBACK (statusbar_hint), statusbar); /*Remove Message from the statusbar when the mouse cursors leaves this menu point*/ g_signal_connect (G_OBJECT (save), "leave-notify-event",G_CALLBACK (statusbar_hint), statusbar); /*Attach the text for the statusbar to the Menu Item*/ g_object_set_data (G_OBJECT (save), "menuhint",(gpointer) "Save to specified File"); /* Use the save_as point from the libary and the stock symbol */ save_as = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE_AS, NULL); g_signal_connect(G_OBJECT(save_as), "activate",G_CALLBACK(file_save_as),(gpointer) window); /*Connect signal to display the Message for the Save_as Menu Item in the statusbar, when the mouse cursors hovers over*/ g_signal_connect (G_OBJECT (save_as), "enter-notify-event",G_CALLBACK (statusbar_hint), statusbar); /*Remove Message from the statusbar when the mouse cursors leaves this menu point*/ g_signal_connect (G_OBJECT (save_as), "leave-notify-event",G_CALLBACK (statusbar_hint), statusbar); /*Attach the text for the statusbar to the Menu Item*/ g_object_set_data (G_OBJECT (save_as), "menuhint",(gpointer) "Save to a new File"); /* Create vertical seperator line in the file menu */ sep2 = gtk_separator_menu_item_new(); /* For the export function, no stock symbol exists, used instead a point with only a label*/ export = gtk_menu_item_new_with_label("Export");
void showCustomBox(const std::string &title, const std::string &message, GdkPixbuf *titlePixbuf/*=NULL*/, GdkPixbuf *messagePixbuf/*=NULL*/, GtkWidget *transient_widget/*=NULL*/) { GtkWidget *dialog; GtkWidget *dialog_vbox1; GtkWidget *hbox1; GtkWidget *image1; GtkWidget *label1; GtkWidget *dialog_action_area1; GtkWidget *okbutton1; dialog = gtk_dialog_new (); gtk_widget_set_size_request (dialog, -1, 120); gtk_window_set_title (GTK_WINDOW (dialog), title.c_str()); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); // Make transient if necessary if (transient_widget) { GtkWidget *toplevel = getToplevel(transient_widget); if (toplevel && GTK_IS_WINDOW (toplevel) && GTK_WIDGET_MAPPED (toplevel)) gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (toplevel)); } if (titlePixbuf) gtk_window_set_icon (GTK_WINDOW (dialog), titlePixbuf); dialog_vbox1 = GTK_DIALOG (dialog)->vbox; gtk_widget_show (dialog_vbox1); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0); image1 = createPixmapFromPixbuf (messagePixbuf); gtk_widget_set_size_request (image1 , 70, 64); gtk_widget_show (image1); gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, TRUE, 0); label1 = gtk_label_new (message.c_str()); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0); gtk_widget_set_size_request (label1, -1, 23); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); dialog_action_area1 = GTK_DIALOG (dialog)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); // Suspend AReVi Scheduler runModalBox(dialog); gtk_widget_destroy (dialog); }
void gui_create_tasks_page (GtkWidget *vbox, GUI *appGUI) { GtkWidget *vbox5, *vbox6; GtkWidget *vbox7, *vbox11, *vbox12; GtkWidget *label; GtkWidget *hbox1; GtkWidget *frame; GtkWidget *table; GtkWidget *alignment; GtkWidget *ti_font_button; GtkWidget *scrolledwindow; GtkWidget *tasks_category_table; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gchar tmpbuf[BUFFER_SIZE]; GdkColor color; appGUI->opt->tasks_vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), appGUI->opt->tasks_vbox, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Appearance")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); vbox5 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox5); gtk_container_add (GTK_CONTAINER (alignment), vbox5); table = gtk_table_new (3, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox5), table, FALSE, FALSE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 8); hbox1 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox1); gtk_table_attach (GTK_TABLE (table), hbox1, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); appGUI->opt->due_today_color_picker = gtk_color_button_new (); gtk_widget_show (appGUI->opt->due_today_color_picker); g_signal_connect (G_OBJECT (appGUI->opt->due_today_color_picker), "color-set", G_CALLBACK(due_today_color_changed_cb), appGUI); gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->opt->due_today_color_picker, _("Color of items that are due today"), NULL); gdk_color_parse(config.due_today_color, &color); gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_today_color_picker), &color); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->opt->due_today_color_picker, FALSE, FALSE, 0); appGUI->opt->due_7days_color_picker = gtk_color_button_new (); gtk_widget_show (appGUI->opt->due_7days_color_picker); g_signal_connect (G_OBJECT (appGUI->opt->due_7days_color_picker), "color-set", G_CALLBACK(due_7days_color_changed_cb), appGUI); gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->opt->due_7days_color_picker, _("Color of items that are due in the next 7 days"), NULL); gdk_color_parse(config.due_7days_color, &color); gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_7days_color_picker), &color); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->opt->due_7days_color_picker, FALSE, FALSE, 0); appGUI->opt->past_due_color_picker = gtk_color_button_new (); gtk_widget_show (appGUI->opt->past_due_color_picker); g_signal_connect (G_OBJECT (appGUI->opt->past_due_color_picker), "color-set", G_CALLBACK(past_due_color_changed_cb), appGUI); gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->opt->past_due_color_picker, _("Color of items that are past due"), NULL); gdk_color_parse(config.past_due_color, &color); gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->past_due_color_picker), &color); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->opt->past_due_color_picker, FALSE, FALSE, 0); appGUI->opt->ti_font_entry = gtk_entry_new (); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ti_font_entry, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->ti_font_entry); gtk_table_attach (GTK_TABLE (table), appGUI->opt->ti_font_entry, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); if (config.default_stock_icons) { ti_font_button = gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE); } else { ti_font_button = gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE); } GTK_WIDGET_UNSET_FLAGS(ti_font_button, GTK_CAN_FOCUS); gtk_widget_show (ti_font_button); g_signal_connect (G_OBJECT (ti_font_button), "clicked", G_CALLBACK (ti_font_select_cb), appGUI); gtk_table_attach (GTK_TABLE (table), ti_font_button, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); sprintf(tmpbuf, "%s:", _("Task info font")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); sprintf(tmpbuf, "%s:", _("Colors")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->opt->tasks_enable_rules_hint_checkbutton = gtk_check_button_new_with_mnemonic (_("Draw rows in alternating colors")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_enable_rules_hint_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->tasks_enable_rules_hint_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->tasks_enable_rules_hint_checkbutton), "toggled", G_CALLBACK (tasks_enable_rules_hint_checkbutton_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_enable_rules_hint_checkbutton, 0, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Visible columns")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); vbox12 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox12); gtk_container_add (GTK_CONTAINER (alignment), vbox12); table = gtk_table_new (1, 3, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox12), table, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (table), 4); gtk_table_set_col_spacings (GTK_TABLE (table), 8); appGUI->opt->vc_due_date_checkbutton = gtk_check_button_new_with_mnemonic (_("Due date")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_due_date_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->vc_due_date_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->vc_due_date_checkbutton), "toggled", G_CALLBACK (visible_columns_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_due_date_checkbutton, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); appGUI->opt->vc_priority_checkbutton = gtk_check_button_new_with_mnemonic (_("Priority")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_priority_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->vc_priority_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->vc_priority_checkbutton), "toggled", G_CALLBACK (visible_columns_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_priority_checkbutton, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); appGUI->opt->vc_category_checkbutton = gtk_check_button_new_with_mnemonic (_("Category")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_category_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->vc_category_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->vc_category_checkbutton), "toggled", G_CALLBACK (visible_columns_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_category_checkbutton, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Categories")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); vbox6 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox6); gtk_container_add (GTK_CONTAINER (alignment), vbox6); tasks_category_table = gtk_table_new (4, 3, FALSE); gtk_widget_show (tasks_category_table); gtk_box_pack_start (GTK_BOX (vbox6), tasks_category_table, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (tasks_category_table), 8); gtk_table_set_row_spacings (GTK_TABLE (tasks_category_table), 8); gtk_table_set_col_spacings (GTK_TABLE (tasks_category_table), 4); appGUI->opt->tasks_category_entry = gtk_entry_new (); gtk_widget_show (appGUI->opt->tasks_category_entry); gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_entry, 0, 1, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (G_OBJECT (appGUI->opt->tasks_category_entry), "key_release_event", G_CALLBACK (tasks_category_entry_key_release_cb), appGUI); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_table_attach (GTK_TABLE (tasks_category_table), scrolledwindow, 0, 3, 0, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); appGUI->opt->tasks_category_store = gtk_list_store_new(1, G_TYPE_STRING); appGUI->opt->tasks_category_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->opt->tasks_category_store)); appGUI->opt->tasks_category_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview)); gtk_widget_show (appGUI->opt->tasks_category_treeview); g_signal_connect(G_OBJECT(appGUI->opt->tasks_category_select), "changed", G_CALLBACK(tasks_category_selected_cb), appGUI); gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->opt->tasks_category_treeview); gtk_container_set_border_width (GTK_CONTAINER (appGUI->opt->tasks_category_treeview), 4); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), FALSE); gtk_widget_set_size_request (appGUI->opt->tasks_category_treeview, -1, 80); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column); if (config.default_stock_icons) { appGUI->opt->tasks_category_add_button = gui_stock_button(GTK_STOCK_ADD, FALSE); } else { appGUI->opt->tasks_category_add_button = gui_stock_button(OSMO_STOCK_BUTTON_ADD, FALSE); } GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_add_button, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->tasks_category_add_button); gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_add_button, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect(appGUI->opt->tasks_category_add_button, "clicked", G_CALLBACK(tasks_category_add_cb), appGUI); gtk_widget_set_sensitive(appGUI->opt->tasks_category_add_button, FALSE); if (config.default_stock_icons) { appGUI->opt->tasks_category_remove_button = gui_stock_button(GTK_STOCK_REMOVE, FALSE); } else { appGUI->opt->tasks_category_remove_button = gui_stock_button(OSMO_STOCK_BUTTON_REMOVE, FALSE); } GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_remove_button, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->tasks_category_remove_button); gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_remove_button, 2, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect(appGUI->opt->tasks_category_remove_button, "clicked", G_CALLBACK(tasks_category_remove_cb), appGUI); gtk_widget_set_sensitive(appGUI->opt->tasks_category_remove_button, FALSE); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Sorting")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); vbox7 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox7); gtk_container_add (GTK_CONTAINER (alignment), vbox7); table = gtk_table_new (1, 5, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox7), table, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (table), 4); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "%s:", _("Order")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); sprintf(tmpbuf, "%s:", _("Mode")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->opt->tasks_sort_order_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->opt->tasks_sort_order_combobox); g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_order_combobox), "changed", G_CALLBACK(tasks_sort_order_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_order_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Ascending")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Descending")); gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_order_combobox), config.tasks_sorting_order); appGUI->opt->tasks_sort_mode_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->opt->tasks_sort_mode_combobox); g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_mode_combobox), "changed", G_CALLBACK(tasks_sort_mode_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_mode_combobox, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Due date"), _("Priority")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Priority"), _("Due date")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Due date"), _("Done")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Done"), _("Due date")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Priority"), _("Done")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Done"), _("Priority")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf); gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_mode_combobox), config.tasks_sorting_mode); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); sprintf(tmpbuf, "<b>%s</b>", _("Tasks options")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_padding (GTK_MISC (label), 0, 4); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0); vbox11 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox11); gtk_container_add (GTK_CONTAINER (alignment), vbox11); appGUI->opt->ct_hide_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Hide completed tasks")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_hide_items_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->ct_hide_items_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled", G_CALLBACK (hide_delete_changed_cb), appGUI); gtk_box_pack_start (GTK_BOX (vbox11), appGUI->opt->ct_hide_items_checkbutton, FALSE, FALSE, 4); g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled", G_CALLBACK (hide_items_cb), appGUI); appGUI->opt->ct_delete_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Delete completed tasks without confirmation")); GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_delete_items_checkbutton, GTK_CAN_FOCUS); gtk_widget_show (appGUI->opt->ct_delete_items_checkbutton); g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled", G_CALLBACK (hide_delete_changed_cb), appGUI); gtk_box_pack_start (GTK_BOX (vbox11), appGUI->opt->ct_delete_items_checkbutton, FALSE, FALSE, 4); g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled", G_CALLBACK (delete_items_cb), appGUI); }
GtkWidget* create_lshw (void) { GtkWidget *lshw; GtkWidget *vbox1; GtkWidget *menu; GtkWidget *menuitem4; GtkWidget *menuitem4_menu; GtkWidget *save; GtkWidget *quit1; GtkWidget *menuitem6; GtkWidget *menuitem6_menu; GtkWidget *refresh1; GtkWidget *menuitem7; GtkWidget *menuitem7_menu; GtkWidget *about1; GtkWidget *toolbar1; GtkIconSize tmp_toolbar_icon_size; GtkWidget *upbutton; GtkWidget *refreshbutton; GtkWidget *savebutton; GtkWidget *quitbutton; GtkWidget *scrolledwindow1; GtkWidget *viewport2; GtkWidget *hbox1; GtkWidget *hpaned1; GtkWidget *hbox3; GtkWidget *scrolledwindow10; GtkWidget *treeview1; GtkWidget *scrolledwindow11; GtkWidget *treeview2; GtkWidget *scrolledwindow12; GtkWidget *treeview3; GtkWidget *vbox2; GtkWidget *scrolledwindow13; GtkWidget *viewport3; GtkWidget *scrolledwindow14; GtkWidget *description; GtkWidget *statusbar; GtkAccelGroup *accel_group; GtkTooltips *tooltips; tooltips = gtk_tooltips_new (); accel_group = gtk_accel_group_new (); lshw = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (lshw), "lshw"); gtk_window_set_default_size (GTK_WINDOW (lshw), 700, 480); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (lshw), vbox1); menu = gtk_menu_bar_new (); gtk_widget_show (menu); gtk_box_pack_start (GTK_BOX (vbox1), menu, FALSE, FALSE, 0); menuitem4 = gtk_menu_item_new_with_mnemonic ("_File"); gtk_widget_show (menuitem4); gtk_container_add (GTK_CONTAINER (menu), menuitem4); menuitem4_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem4), menuitem4_menu); save = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group); gtk_widget_show (save); gtk_container_add (GTK_CONTAINER (menuitem4_menu), save); gtk_widget_set_sensitive (save, FALSE); quit1 = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group); gtk_widget_show (quit1); gtk_container_add (GTK_CONTAINER (menuitem4_menu), quit1); menuitem6 = gtk_menu_item_new_with_mnemonic ("_View"); gtk_widget_show (menuitem6); gtk_container_add (GTK_CONTAINER (menu), menuitem6); menuitem6_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem6), menuitem6_menu); refresh1 = gtk_image_menu_item_new_from_stock ("gtk-refresh", accel_group); gtk_widget_show (refresh1); gtk_container_add (GTK_CONTAINER (menuitem6_menu), refresh1); gtk_widget_add_accelerator (refresh1, "activate", accel_group, GDK_F5, (GdkModifierType) 0, GTK_ACCEL_VISIBLE); menuitem7 = gtk_menu_item_new_with_mnemonic ("_Help"); gtk_widget_show (menuitem7); gtk_container_add (GTK_CONTAINER (menu), menuitem7); menuitem7_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem7), menuitem7_menu); about1 = gtk_menu_item_new_with_mnemonic ("_About"); gtk_widget_show (about1); gtk_container_add (GTK_CONTAINER (menuitem7_menu), about1); toolbar1 = gtk_toolbar_new (); gtk_widget_show (toolbar1); gtk_box_pack_start (GTK_BOX (vbox1), toolbar1, FALSE, FALSE, 0); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_BOTH); tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1)); upbutton = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-up"); gtk_widget_show (upbutton); gtk_container_add (GTK_CONTAINER (toolbar1), upbutton); gtk_widget_set_sensitive (upbutton, FALSE); refreshbutton = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-refresh"); gtk_widget_show (refreshbutton); gtk_container_add (GTK_CONTAINER (toolbar1), refreshbutton); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (refreshbutton), tooltips, "Rescan the hardware", NULL); savebutton = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-save"); gtk_widget_show (savebutton); gtk_container_add (GTK_CONTAINER (toolbar1), savebutton); gtk_widget_set_sensitive (savebutton, FALSE); quitbutton = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-quit"); gtk_widget_show (quitbutton); gtk_container_add (GTK_CONTAINER (toolbar1), quitbutton); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow1); gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow1, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); viewport2 = gtk_viewport_new (NULL, NULL); gtk_widget_show (viewport2); gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport2); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (viewport2), hbox1); hpaned1 = gtk_hpaned_new (); gtk_widget_show (hpaned1); gtk_box_pack_start (GTK_BOX (hbox1), hpaned1, TRUE, TRUE, 0); hbox3 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox3); gtk_paned_pack1 (GTK_PANED (hpaned1), hbox3, FALSE, TRUE); scrolledwindow10 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow10); gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow10, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow10), 2); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow10), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow10), GTK_SHADOW_ETCHED_IN); treeview1 = gtk_tree_view_new (); gtk_widget_show (treeview1); gtk_container_add (GTK_CONTAINER (scrolledwindow10), treeview1); gtk_widget_set_size_request (treeview1, 128, -1); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview1), FALSE); scrolledwindow11 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow11); gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow11, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow11), 2); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow11), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow11), GTK_SHADOW_ETCHED_IN); treeview2 = gtk_tree_view_new (); gtk_widget_show (treeview2); gtk_container_add (GTK_CONTAINER (scrolledwindow11), treeview2); gtk_widget_set_size_request (treeview2, 128, -1); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview2), FALSE); scrolledwindow12 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow12); gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow12, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow12), 2); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow12), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow12), GTK_SHADOW_ETCHED_IN); treeview3 = gtk_tree_view_new (); gtk_widget_show (treeview3); gtk_container_add (GTK_CONTAINER (scrolledwindow12), treeview3); gtk_widget_set_size_request (treeview3, 128, -1); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview3), FALSE); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_paned_pack2 (GTK_PANED (hpaned1), vbox2, TRUE, TRUE); scrolledwindow13 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow13); gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow13, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow13), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); viewport3 = gtk_viewport_new (NULL, NULL); gtk_widget_show (viewport3); gtk_container_add (GTK_CONTAINER (scrolledwindow13), viewport3); gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport3), GTK_SHADOW_NONE); scrolledwindow14 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow14); gtk_container_add (GTK_CONTAINER (viewport3), scrolledwindow14); gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow14), 2); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow14), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow14), GTK_SHADOW_ETCHED_IN); description = gtk_text_view_new (); gtk_widget_show (description); gtk_container_add (GTK_CONTAINER (scrolledwindow14), description); GTK_WIDGET_UNSET_FLAGS (description, GTK_CAN_FOCUS); gtk_tooltips_set_tip (tooltips, description, "This pane displays detailed information about the selected hardware node", NULL); gtk_text_view_set_editable (GTK_TEXT_VIEW (description), FALSE); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (description), FALSE); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (description), 10); gtk_text_view_set_right_margin (GTK_TEXT_VIEW (description), 10); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (description)), "no information available.\n\nclick on Refresh to query hardware", -1); statusbar = gtk_statusbar_new (); gtk_widget_show (statusbar); gtk_box_pack_start (GTK_BOX (vbox1), statusbar, FALSE, FALSE, 0); gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (statusbar), FALSE); g_signal_connect ((gpointer) lshw, "delete_event", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect_after ((gpointer) lshw, "map", G_CALLBACK (on_lshw_map), NULL); g_signal_connect ((gpointer) save, "activate", G_CALLBACK (on_save_activate), NULL); g_signal_connect ((gpointer) quit1, "activate", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect ((gpointer) refresh1, "activate", G_CALLBACK (refresh_display), NULL); g_signal_connect ((gpointer) about1, "activate", G_CALLBACK (on_about1_activate), NULL); g_signal_connect ((gpointer) upbutton, "clicked", G_CALLBACK (go_up), NULL); g_signal_connect ((gpointer) refreshbutton, "clicked", G_CALLBACK (refresh_display), NULL); g_signal_connect ((gpointer) savebutton, "clicked", G_CALLBACK (on_savebutton_clicked), NULL); g_signal_connect ((gpointer) quitbutton, "clicked", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect ((gpointer) treeview1, "row_activated", G_CALLBACK (on_treeview1_row_activated), NULL); g_signal_connect ((gpointer) treeview1, "cursor_changed", G_CALLBACK (on_treeview1_cursor_changed), NULL); g_signal_connect ((gpointer) treeview2, "row_activated", G_CALLBACK (on_treeview2_row_activated), NULL); g_signal_connect ((gpointer) treeview2, "cursor_changed", G_CALLBACK (on_treeview2_cursor_changed), NULL); g_signal_connect ((gpointer) treeview3, "row_activated", G_CALLBACK (on_treeview3_row_activated), NULL); g_signal_connect ((gpointer) treeview3, "cursor_changed", G_CALLBACK (on_treeview3_cursor_changed), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (lshw, lshw, "lshw"); GLADE_HOOKUP_OBJECT (lshw, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (lshw, menu, "menu"); GLADE_HOOKUP_OBJECT (lshw, menuitem4, "menuitem4"); GLADE_HOOKUP_OBJECT (lshw, menuitem4_menu, "menuitem4_menu"); GLADE_HOOKUP_OBJECT (lshw, save, "save"); GLADE_HOOKUP_OBJECT (lshw, quit1, "quit1"); GLADE_HOOKUP_OBJECT (lshw, menuitem6, "menuitem6"); GLADE_HOOKUP_OBJECT (lshw, menuitem6_menu, "menuitem6_menu"); GLADE_HOOKUP_OBJECT (lshw, refresh1, "refresh1"); GLADE_HOOKUP_OBJECT (lshw, menuitem7, "menuitem7"); GLADE_HOOKUP_OBJECT (lshw, menuitem7_menu, "menuitem7_menu"); GLADE_HOOKUP_OBJECT (lshw, about1, "about1"); GLADE_HOOKUP_OBJECT (lshw, toolbar1, "toolbar1"); GLADE_HOOKUP_OBJECT (lshw, upbutton, "upbutton"); GLADE_HOOKUP_OBJECT (lshw, refreshbutton, "refreshbutton"); GLADE_HOOKUP_OBJECT (lshw, savebutton, "savebutton"); GLADE_HOOKUP_OBJECT (lshw, quitbutton, "quitbutton"); GLADE_HOOKUP_OBJECT (lshw, scrolledwindow1, "scrolledwindow1"); GLADE_HOOKUP_OBJECT (lshw, viewport2, "viewport2"); GLADE_HOOKUP_OBJECT (lshw, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (lshw, hpaned1, "hpaned1"); GLADE_HOOKUP_OBJECT (lshw, hbox3, "hbox3"); GLADE_HOOKUP_OBJECT (lshw, scrolledwindow10, "scrolledwindow10"); GLADE_HOOKUP_OBJECT (lshw, treeview1, "treeview1"); GLADE_HOOKUP_OBJECT (lshw, scrolledwindow11, "scrolledwindow11"); GLADE_HOOKUP_OBJECT (lshw, treeview2, "treeview2"); GLADE_HOOKUP_OBJECT (lshw, scrolledwindow12, "scrolledwindow12"); GLADE_HOOKUP_OBJECT (lshw, treeview3, "treeview3"); GLADE_HOOKUP_OBJECT (lshw, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (lshw, scrolledwindow13, "scrolledwindow13"); GLADE_HOOKUP_OBJECT (lshw, viewport3, "viewport3"); GLADE_HOOKUP_OBJECT (lshw, scrolledwindow14, "scrolledwindow14"); GLADE_HOOKUP_OBJECT (lshw, description, "description"); GLADE_HOOKUP_OBJECT (lshw, statusbar, "statusbar"); GLADE_HOOKUP_OBJECT_NO_REF (lshw, tooltips, "tooltips"); gtk_window_add_accel_group (GTK_WINDOW (lshw), accel_group); return lshw; }
/** * @fn GtkWidget* create_mainwin (void) * Crea la ventana principal */ GtkWidget* create_mainwin (void) { GtkWidget *app1; GtkWidget *dock1; GtkWidget *eventbox1; GtkWidget *viewport1; GtkWidget *vbox_main; GtkWidget *vbox_paned; GtkWidget *scrolledwindow; GtkWidget *paned; GtkWidget *text; GtkWidget *inputline; GtkWidget *sw; GtkWidget *ahbox; app1 = gnome_app_new ( PACKAGE, "Tenes Empanadas Graciela"); gtk_object_set_data (GTK_OBJECT (app1), "app1", app1); gtk_window_set_default_size (GTK_WINDOW (app1), 664, 640); gtk_window_set_policy (GTK_WINDOW (app1), TRUE, TRUE, FALSE); dock1 = GNOME_APP (app1)->dock; gtk_widget_ref (dock1); gtk_object_set_data_full (GTK_OBJECT (app1), "dock1", dock1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (dock1); gnome_app_create_menus (GNOME_APP (app1), menubar_uiinfo); gnome_app_create_toolbar(GNOME_APP(app1), toolbar_main); /* TODO: ask in GNOME if this is wanted */ /* gtk_menu_item_right_justify( GTK_MENU_ITEM(menubar_uiinfo[4].widget)); */ gtk_widget_realize (app1); gtk_signal_connect ( GTK_OBJECT(app1), "destroy", GTK_SIGNAL_FUNC( on_exit_activate ), NULL ); gtk_signal_connect ( GTK_OBJECT(app1), "delete_event", GTK_SIGNAL_FUNC( on_exit_activate ), NULL ); SensiData.connect_button = toolbar_main[0].widget; SensiData.start_button = toolbar_main[1].widget; /* 2 is a separator */ SensiData.enviarfichas_button = toolbar_main[3].widget; SensiData.reagrupe_button = toolbar_main[4].widget; SensiData.getcard_button = toolbar_main[5].widget; SensiData.endturn_button = toolbar_main[6].widget; /* 7 is a separator */ SensiData.status_button = toolbar_main[8].widget; eventbox1 = gtk_event_box_new (); gtk_widget_ref (eventbox1); gtk_object_set_data_full (GTK_OBJECT (app1), "eventbox1", eventbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (eventbox1); gnome_app_set_contents (GNOME_APP (app1), eventbox1); viewport1 = gtk_viewport_new (NULL, NULL); gtk_widget_show (viewport1); gtk_container_add (GTK_CONTAINER (eventbox1), viewport1); vbox_main = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox_main); gtk_container_add (GTK_CONTAINER (viewport1), vbox_main); /* status map */ if( mainstatus_create(&window_mainstatus) != TEG_STATUS_SUCCESS ) goto error; gtk_box_pack_start( GTK_BOX(vbox_main), window_mainstatus, FALSE,FALSE,0); /* paned */ paned = gtk_vpaned_new(); gtk_box_pack_start( GTK_BOX( vbox_main ), paned, TRUE, TRUE, 0 ); vbox_paned = gtk_vbox_new (FALSE, 0); gtk_paned_add1(GTK_PANED(paned), vbox_paned); gtk_widget_show (vbox_paned); /* map */ scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize(scrolledwindow, 640, 394); if( canvas_create_map() != TEG_STATUS_SUCCESS ) goto error; gtk_container_add(GTK_CONTAINER(scrolledwindow), canvas_map); gtk_container_add(GTK_CONTAINER(vbox_paned),scrolledwindow); gtk_widget_show (canvas_map); gtk_widget_show (scrolledwindow); /* text */ ahbox = gtk_hbox_new(FALSE, 2); gtk_paned_pack2(GTK_PANED(paned), ahbox, TRUE, TRUE); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(ahbox), sw, TRUE, TRUE, 0); gtk_widget_set_size_request(sw, 620, 60); text = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE); gtk_container_add(GTK_CONTAINER(sw), text); gtk_widget_set_name(text, "chatline"); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD); gtk_widget_realize(text); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 5); main_message_area = GTK_TEXT_VIEW(text); /* set_output_window_text(_("Tenes Empanadas Graciela")); */ gtk_widget_show(text); gtk_widget_show(sw); gtk_widget_show(ahbox); gtk_widget_show(paned); /* the chat line */ inputline = gtk_entry_new(); gtk_box_pack_start( GTK_BOX( vbox_main ), inputline, FALSE, FALSE, 0 ); gtk_widget_show(inputline); g_signal_connect(inputline, "activate", G_CALLBACK(inputline_return), NULL); chatline_init(); /* status bar */ statusbar = gnome_appbar_new (FALSE, TRUE, GNOME_PREFERENCES_NEVER); gtk_widget_ref (statusbar); gtk_object_set_data_full (GTK_OBJECT (app1), "statusbar", statusbar, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (statusbar); gnome_app_set_statusbar (GNOME_APP (app1), statusbar); gtk_box_pack_start(GTK_BOX(statusbar), ministatus_build(), FALSE, TRUE, 0); gnome_appbar_set_status(GNOME_APPBAR(statusbar), _("Welcome to TEG!")); gnome_app_install_menu_hints( GNOME_APP(app1), menubar_uiinfo ); /* icono */ { GdkBitmap *mask; GdkPixmap *icono; #include "../teg_pix/teg_icono.xpm" gtk_widget_realize (app1); icono = gdk_pixmap_create_from_xpm_d( app1->window, &mask, &app1->style->bg[GTK_STATE_NORMAL],teg_icono_xpm ); gdk_window_set_icon (app1->window, NULL, icono , mask ); } gtk_widget_show(app1); return app1; error: g_error(_("Unable to create map!")); return NULL; }
static void gimp_color_dialog_init (GimpColorDialog *dialog) { GtkWidget *table; GtkWidget *button; GtkWidget *arrow; gint i; color_dialogs = g_list_prepend (color_dialogs, dialog); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); dialog->selection = gimp_color_selection_new (); gtk_container_set_border_width (GTK_CONTAINER (dialog->selection), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), dialog->selection); gtk_widget_show (dialog->selection); g_signal_connect (dialog->selection, "color-changed", G_CALLBACK (gimp_color_dialog_color_changed), dialog); /* The color history */ table = gtk_table_new (2, 1 + COLOR_HISTORY_SIZE / 2, TRUE); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4); gtk_box_pack_end (GTK_BOX (GIMP_COLOR_SELECTION (dialog->selection)->right_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); button = gtk_button_new (); gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 1, 0, 1); gimp_help_set_help_data (button, _("Add the current color to the color history"), NULL); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_color_history_add_clicked), dialog); arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (button), arrow); gtk_widget_show (arrow); for (i = 0; i < COLOR_HISTORY_SIZE; i++) { GimpRGB history_color; gint row, column; column = i % (COLOR_HISTORY_SIZE / 2); row = i / (COLOR_HISTORY_SIZE / 2); button = gtk_button_new (); gtk_widget_set_size_request (button, COLOR_AREA_SIZE, COLOR_AREA_SIZE); gtk_table_attach_defaults (GTK_TABLE (table), button, column + 1, column + 2, row, row + 1); gtk_widget_show (button); color_history_get (i, &history_color); dialog->history[i] = gimp_color_area_new (&history_color, GIMP_COLOR_AREA_SMALL_CHECKS, GDK_BUTTON2_MASK); gtk_container_add (GTK_CONTAINER (button), dialog->history[i]); gtk_widget_show (dialog->history[i]); g_signal_connect (button, "clicked", G_CALLBACK (gimp_color_history_color_clicked), dialog); g_signal_connect (dialog->history[i], "color-changed", G_CALLBACK (gimp_color_history_color_changed), GINT_TO_POINTER (i)); } }
/* * CTK VCS (Visual Computing System) widget creation * */ GtkWidget* ctk_vcs_new(NvCtrlAttributeHandle *handle, CtkConfig *ctk_config) { GObject *object; CtkVcs *ctk_object; GtkWidget *label; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *event; GtkWidget *banner; GtkWidget *hseparator; GtkWidget *table; GtkWidget *scrollWin; GtkWidget *checkbutton; gchar *product_name; gchar *serial_number; gchar *build_date; gchar *product_id; gchar *firmware_version; gchar *hardware_version; gint current_row; gboolean high_perf_mode; ReturnStatus ret; gchar *s; char *psu_str = NULL; PSUEntry psuEntry; GtkWidget *vbox_scroll, *hbox_scroll; /* * get the static string data that we will display below */ /* Product Name */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_PRODUCT_NAME, &product_name); if (ret != NvCtrlSuccess) { product_name = g_strdup("Unable to determine"); } /* Serial Number */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_SERIAL_NUMBER, &serial_number); if (ret != NvCtrlSuccess) { serial_number = g_strdup("Unable to determine"); } /* Build Date */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_BUILD_DATE, &build_date); if (ret != NvCtrlSuccess) { build_date = g_strdup("Unable to determine"); } /* Product ID */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_PRODUCT_ID, &product_id); if (ret != NvCtrlSuccess) { product_id = g_strdup("Unable to determine"); } /* Firmware Version */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_FIRMWARE_VERSION, &firmware_version); if (ret != NvCtrlSuccess) { firmware_version = g_strdup("Unable to determine"); } /* Hardware Version */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_HARDWARE_VERSION, &hardware_version); if (ret != NvCtrlSuccess) { hardware_version = g_strdup("Unable to determine"); } /* now, create the object */ object = g_object_new(CTK_TYPE_VCS, NULL); ctk_object = CTK_VCS(object); /* cache the attribute handle */ ctk_object->handle = handle; ctk_object->ctk_config = ctk_config; /* set container properties of the object */ gtk_box_set_spacing(GTK_BOX(ctk_object), 10); /* banner */ banner = ctk_banner_image_new(BANNER_ARTWORK_VCS); gtk_box_pack_start(GTK_BOX(ctk_object), banner, FALSE, FALSE, 0); /* * This displays basic System information, including * display name, Operating system type and the NVIDIA driver version. */ vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(ctk_object), vbox, TRUE, TRUE, 0); /* General purpose error dialog */ ctk_object->error_dialog = create_error_dialog(ctk_object); if (NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE, &high_perf_mode) == NvCtrlSuccess) { hbox = gtk_hbox_new(FALSE, 0); checkbutton = gtk_check_button_new_with_label("Enable High Performance Mode"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), high_perf_mode); g_signal_connect(G_OBJECT(checkbutton), "toggled", G_CALLBACK(vcs_perf_checkbox_toggled), (gpointer) ctk_object); gtk_box_pack_start(GTK_BOX(hbox), checkbutton, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); } /* Create the Scrolling Window */ scrollWin = gtk_scrolled_window_new(NULL, NULL); hbox_scroll = gtk_hbox_new(FALSE, 0); vbox_scroll = gtk_vbox_new(FALSE, 5); event = gtk_event_box_new(); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollWin), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_modify_fg(event, GTK_STATE_NORMAL, &(event->style->text[GTK_STATE_NORMAL])); gtk_widget_modify_bg(event, GTK_STATE_NORMAL, &(event->style->base[GTK_STATE_NORMAL])); gtk_container_add(GTK_CONTAINER(event), hbox_scroll); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollWin), event); gtk_box_pack_start(GTK_BOX(hbox_scroll), vbox_scroll, TRUE, TRUE, 5); gtk_widget_set_size_request(scrollWin, -1, 50); gtk_box_pack_start(GTK_BOX(vbox), scrollWin, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); label = gtk_label_new("VCS Information"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); table = gtk_table_new(5, 2, FALSE); gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(table), 3); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); add_table_row(table, 0, 0, 0.5, "Product Name:", 0, 0.5, product_name); add_table_row(table, 1, 0, 0.5, "Serial Number:", 0, 0.5, serial_number); add_table_row(table, 2, 0, 0.5, "Build Date:", 0, 0.5, build_date); add_table_row(table, 3, 0, 0.5, "Product ID:", 0, 0.5, product_id); add_table_row(table, 4, 0, 0.5, "Firmware version:", 0, 0.5, firmware_version); add_table_row(table, 5, 0, 0.5, "Hardware version:", 0, 0.5, hardware_version); g_free(product_name); g_free(serial_number); g_free(build_date); g_free(product_id); g_free(firmware_version); g_free(hardware_version); /* Query Canoas 2.0 specific details */ if ((NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE, &high_perf_mode) == NvCtrlSuccess) && (NvCtrlGetStringAttribute(ctk_object->handle, NV_CTRL_STRING_VCSC_PSU_INFO, &psu_str) == NvCtrlSuccess)) { GtkWidget *vbox_padding; /* Show the additonal queried information */ /* Populate scrolling window with data */ vbox_padding = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); label = gtk_label_new("VCS Thermal Information"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); table = gtk_table_new(3, 2, FALSE); gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(table), 3); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); label = gtk_label_new("Intake Temperature:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->intake_temp = label; label = gtk_label_new("Exhaust Temperature:"); /* This is the current largest label. Get its size */ gtk_widget_size_request(label, &ctk_object->req); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->exhaust_temp = label; label = gtk_label_new("Board Temperature:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 2, 3, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->board_temp = label; /* Populate table for PSU information */ psuEntry.psu_current = -1; psuEntry.psu_power = -1; psuEntry.psu_voltage = -1; psuEntry.psu_state = -1; if (psu_str) { parse_token_value_pairs(psu_str, apply_psu_entry_token, &psuEntry); } vbox_padding = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); label = gtk_label_new("VCS Power Supply Unit Information"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); table = gtk_table_new(4, 2, FALSE); gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(table), 3); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); label = gtk_label_new("PSU State:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->psu_state = label; label = gtk_label_new("PSU Current:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->psu_current = label; current_row = 2; if (psuEntry.psu_power != -1) { label = gtk_label_new("PSU Power:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->psu_power = label; current_row++; } if (psuEntry.psu_voltage != -1) { label = gtk_label_new("PSU Voltage:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->psu_voltage = label; } /* Create container for fan status table */ vbox_padding = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); label = gtk_label_new("VCS Fan Status"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); ctk_object->fan_status_container = hbox; /* Register a timer callback to update the dynamic information */ s = g_strdup_printf("VCS Monitor (VCS %d)", NvCtrlGetTargetId(ctk_object->handle)); ctk_config_add_timer(ctk_object->ctk_config, DEFAULT_UPDATE_VCS_INFO_TIME_INTERVAL, s, (GSourceFunc) update_vcs_info, (gpointer) ctk_object); g_free(s); update_vcs_info(ctk_object); } gtk_widget_show_all(GTK_WIDGET(object)); return GTK_WIDGET(object); }
GtkWidget *dt_lib_gui_get_expander(dt_lib_module_t *module) { /* check if module is expandable */ if(!module->expandable()) { module->expander = NULL; return NULL; } int bs = DT_PIXEL_APPLY_DPI(12); GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); GtkWidget *expander = dtgtk_expander_new(header, module->widget); GtkWidget *header_evb = dtgtk_expander_get_header_event_box(DTGTK_EXPANDER(expander)); GtkWidget *pluginui_frame = dtgtk_expander_get_frame(DTGTK_EXPANDER(expander)); /* setup the header box */ g_signal_connect(G_OBJECT(header_evb), "button-press-event", G_CALLBACK(_lib_plugin_header_button_press), module); /* setup plugin content frame */ gtk_frame_set_shadow_type(GTK_FRAME(pluginui_frame), GTK_SHADOW_IN); /* * initialize the header widgets */ int idx = 0; GtkWidget *hw[5] = { NULL, NULL, NULL, NULL, NULL }; /* add the expand indicator icon */ hw[idx] = dtgtk_icon_new(dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* add module label */ char label[128]; g_snprintf(label, sizeof(label), "<span size=\"larger\">%s</span>", module->name()); hw[idx] = gtk_label_new(""); gtk_widget_set_name(hw[idx], "panel_label"); gtk_label_set_markup(GTK_LABEL(hw[idx++]), label); /* add reset button if module has implementation */ if(module->gui_reset) { hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_reset, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER); module->reset_button = GTK_WIDGET(hw[idx]); g_object_set(G_OBJECT(hw[idx]), "tooltip-text", _("reset parameters"), (char *)NULL); g_signal_connect(G_OBJECT(hw[idx]), "clicked", G_CALLBACK(dt_lib_gui_reset_callback), module); } else hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* add preset button if module has implementation */ if(module->get_params) { hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_presets, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER); module->presets_button = GTK_WIDGET(hw[idx]); g_object_set(G_OBJECT(hw[idx]), "tooltip-text", _("presets"), (char *)NULL); g_signal_connect(G_OBJECT(hw[idx]), "clicked", G_CALLBACK(popup_callback), module); } else hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* add a spacer to align buttons with iop buttons (enabled button) */ hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* lets order header elements depending on left/right side panel placement */ int c = module->container(); if((c == DT_UI_CONTAINER_PANEL_LEFT_TOP) || (c == DT_UI_CONTAINER_PANEL_LEFT_CENTER) || (c == DT_UI_CONTAINER_PANEL_LEFT_BOTTOM)) { for(int i = 0; i <= 4; i++) if(hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i], i == 1 ? TRUE : FALSE, i == 1 ? TRUE : FALSE, 2); gtk_widget_set_halign(hw[1], GTK_ALIGN_START); dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_RIGHT); } else { for(int i = 4; i >= 0; i--) if(hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i], i == 1 ? TRUE : FALSE, i == 1 ? TRUE : FALSE, 2); gtk_widget_set_halign(hw[1], GTK_ALIGN_END); dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT); } /* add empty space around widget */ gtk_widget_set_margin_start(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_end(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_top(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_bottom(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_show_all(module->widget); gtk_widget_set_name(pluginui_frame, "lib-plugin-ui"); module->expander = expander; gtk_widget_set_hexpand(module->widget, FALSE); gtk_widget_set_vexpand(module->widget, FALSE); return module->expander; }
int main (int argc, char *argv[]) { GtkWidget *window, *vbox, *hbox, *w, *scrolled_win; GtkWidget *label, *entry, *textview; GtkTextBuffer *buffer; GooCanvasItem *root, *witem; /* Initialize GTK+. */ gtk_init (&argc, &argv); /* Create the window and widgets. */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 640, 600); gtk_widget_show (window); g_signal_connect (window, "delete_event", G_CALLBACK (on_delete_event), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_container_set_border_width (GTK_CONTAINER (vbox), 4); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (window), vbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); w = gtk_button_new_with_label ("Add Widget"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (add_widget_clicked), NULL); w = gtk_button_new_with_label ("Remove Widget"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (remove_widget_clicked), NULL); w = gtk_button_new_with_label ("Move Widget"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (move_widget_clicked), NULL); w = gtk_button_new_with_label ("Change Anchor"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (change_anchor_clicked), NULL); w = gtk_button_new_with_label ("Change Widget"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (change_widget_clicked), NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); w = gtk_button_new_with_label ("Hide Canvas"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (hide_canvas_clicked), NULL); w = gtk_button_new_with_label ("Show Canvas"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (show_canvas_clicked), NULL); w = gtk_button_new_with_label ("Hide Item"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (hide_item_clicked), NULL); w = gtk_button_new_with_label ("Show Item"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (show_item_clicked), NULL); w = gtk_button_new_with_label ("Change Transform"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (change_transform_clicked), NULL); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN); gtk_widget_show (scrolled_win); gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); canvas = goo_canvas_new (); gtk_widget_set_can_focus (canvas, TRUE); gtk_widget_set_size_request (canvas, 600, 450); goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 1000, 1000); gtk_container_add (GTK_CONTAINER (scrolled_win), canvas); root = goo_canvas_get_root_item (GOO_CANVAS (canvas)); /* Add a few simple items. */ label = gtk_label_new ("Hello World"); witem = goo_canvas_widget_new (root, label, 50, 50, 200, 100, NULL); g_object_set_data (G_OBJECT (witem), "id", "hello"); entry = gtk_entry_new (); move_item = goo_canvas_widget_new (root, entry, 50, 250, 200, 50, NULL); g_object_set_data (G_OBJECT (move_item), "id", "entry1"); entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry), "Size: -1 x -1"); witem = goo_canvas_widget_new (root, entry, 50, 300, -1, -1, NULL); g_object_set_data (G_OBJECT (witem), "id", "entry2"); entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry), "Size: 100 x -1"); witem = goo_canvas_widget_new (root, entry, 50, 350, 100, -1, NULL); g_object_set_data (G_OBJECT (witem), "id", "entry3"); /* Use a textview so we can see the width & height of the widget. */ scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_NEVER); textview = gtk_text_view_new (); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview)); gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), "Size: -1 x 100", -1); gtk_widget_show (textview); gtk_container_add (GTK_CONTAINER (scrolled_win), textview); gtk_widget_set_size_request (scrolled_win, 160, 50); witem = goo_canvas_widget_new (root, scrolled_win, 50, 400, -1, 100, NULL); g_object_set_data (G_OBJECT (witem), "id", "scrolledwin"); /* Create a vbox item with several child entry widgets to check focus traversal.*/ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); entry = gtk_entry_new (); gtk_widget_show (entry); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); entry = gtk_entry_new (); gtk_widget_show (entry); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); entry = gtk_entry_new (); gtk_widget_show (entry); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); witem = goo_canvas_widget_new (root, vbox, 50, 600, -1, -1, NULL); g_object_set_data (G_OBJECT (witem), "id", "vbox"); /* Create a few normal canvas items that take keyboard focus. */ create_focus_box (canvas, 110, 80, 50, 30, "red"); create_focus_box (canvas, 300, 160, 50, 30, "orange"); create_focus_box (canvas, 500, 50, 50, 30, "yellow"); gtk_widget_show (canvas); /* Pass control to the GTK+ main event loop. */ gtk_main (); return 0; }
static gboolean update_fan_status(CtkVcs *ctk_object) { gint ret; char *fan_entry_str = NULL; char *tokens; GtkWidget *table; GtkWidget *label; FanEntry current_fan; gchar output_str[16]; gint current_row; if (!ctk_object->fan_status_container) { return FALSE; } ret = NvCtrlGetStringAttribute(ctk_object->handle, NV_CTRL_STRING_VCSC_FAN_STATUS, &fan_entry_str); if (ret != NvCtrlSuccess) { return FALSE; } ctk_empty_container(ctk_object->fan_status_container); /* Generate the new table */ table = gtk_table_new(1, 3, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 3); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); gtk_box_pack_start(GTK_BOX(ctk_object->fan_status_container), table, FALSE, FALSE, 0); label = gtk_label_new("Fan Number"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new("Fan Speed"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new("Fan Status"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 2, 3, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); /* Parse string of fan entries and populate table */ current_row = 1; for (tokens = strtok(fan_entry_str, ";"); tokens; tokens = strtok(NULL, ";")) { /* Invalidate fan entry */ current_fan.fan_number = -1; current_fan.fan_speed = -1; current_fan.fan_failed = -1; parse_token_value_pairs(tokens, apply_fan_entry_token, ¤t_fan); if ((current_fan.fan_number != -1) && (current_fan.fan_speed != -1) && (current_fan.fan_failed != -1)) { gtk_table_resize(GTK_TABLE(table), current_row + 1, 3); g_snprintf(output_str, 16, "%d", current_fan.fan_number); label = gtk_label_new(output_str); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); g_snprintf(output_str, 16, "%d rpm", current_fan.fan_speed); label = gtk_label_new(output_str); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); if (!current_fan.fan_failed) { g_snprintf(output_str, 16, "Ok"); } else { g_snprintf(output_str, 16, "Failed"); } label = gtk_label_new(output_str); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 2, 3, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); current_row++; } else { nv_warning_msg("Incomplete Fan Entry (fan=%d, speed=%d, failFlag=%d)", current_fan.fan_number, current_fan.fan_speed, current_fan.fan_failed); } } gtk_widget_show_all(table); XFree(fan_entry_str); return TRUE; }
int main( int argc, char *argv[] ) { static GtkWidget *window; GtkWidget *scrolled_window; GtkWidget *table; GtkWidget *button; char buffer[32]; int i, j; gtk_init (&argc, &argv); /* Create a new dialog window for the scrolled window to be * packed into. */ window = gtk_dialog_new (); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL); gtk_window_set_title (GTK_WINDOW (window), "GtkScrolledWindow example"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); gtk_widget_set_size_request (window, 300, 300); /* create a new scrolled window. */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10); /* the policy is one of GTK_POLICY AUTOMATIC, or GTK_POLICY_ALWAYS. * GTK_POLICY_AUTOMATIC will automatically decide whether you need * scrollbars, whereas GTK_POLICY_ALWAYS will always leave the scrollbars * there. The first one is the horizontal scrollbar, the second, * the vertical. */ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); /* The dialog window is created with a vbox packed into it. */ gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); /* create a table of 10 by 10 squares. */ table = gtk_table_new (10, 10, FALSE); /* set the spacing to 10 on x and 10 on y */ gtk_table_set_row_spacings (GTK_TABLE (table), 10); gtk_table_set_col_spacings (GTK_TABLE (table), 10); /* pack the table into the scrolled window */ gtk_scrolled_window_add_with_viewport ( GTK_SCROLLED_WINDOW (scrolled_window), table); gtk_widget_show (table); /* this simply creates a grid of toggle buttons on the table * to demonstrate the scrolled window. */ for (i = 0; i < 10; i++) for (j = 0; j < 10; j++) { sprintf (buffer, "button (%d,%d)\n", i, j); button = gtk_toggle_button_new_with_label (buffer); gtk_table_attach_defaults (GTK_TABLE (table), button, i, i+1, j, j+1); gtk_widget_show (button); } /* Add a "close" button to the bottom of the dialog */ button = gtk_button_new_with_label ("close"); g_signal_connect_swapped (G_OBJECT (button), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (window)); /* this makes it so the button is the default. */ GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); /* This grabs this button to be the default button. Simply hitting * the "Enter" key will cause this button to activate. */ gtk_widget_grab_default (button); gtk_widget_show (button); gtk_widget_show (window); gtk_main(); return 0; }
PrefsDisplayItemsDialog *prefs_display_items_dialog_create(void) { PrefsDisplayItemsDialog *dialog; GtkWidget *window; GtkWidget *vbox; GtkWidget *label_hbox; GtkWidget *label; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *clist_hbox; GtkWidget *scrolledwin; GtkWidget *stock_clist; GtkWidget *shown_clist; GtkWidget *btn_vbox; GtkWidget *btn_vbox1; GtkWidget *add_btn; GtkWidget *remove_btn; GtkWidget *up_btn; GtkWidget *down_btn; GtkWidget *btn_hbox; GtkWidget *default_btn; GtkWidget *confirm_area; GtkWidget *ok_btn; GtkWidget *cancel_btn; gchar *title[1]; dialog = g_new0(PrefsDisplayItemsDialog, 1); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(window), 8); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal(GTK_WINDOW(window), TRUE); gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE); gtk_window_set_title(GTK_WINDOW(window), _("Display items setting")); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(prefs_display_items_delete_event), dialog); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(prefs_display_items_key_pressed), dialog); vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(window), vbox); label_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(label_hbox); gtk_box_pack_start(GTK_BOX(vbox), label_hbox, FALSE, FALSE, 4); label = gtk_label_new(""); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(label_hbox), label, FALSE, FALSE, 4); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); vbox1 = gtk_vbox_new(FALSE, VSPACING); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox1), 2); hbox1 = gtk_hbox_new(FALSE, 8); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0); clist_hbox = gtk_hbox_new(FALSE, 8); gtk_widget_show(clist_hbox); gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0); scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request (scrolledwin, SCROLLED_WINDOW_WIDTH * gtkut_get_dpi_multiplier(), SCROLLED_WINDOW_HEIGHT * gtkut_get_dpi_multiplier()); gtk_widget_show(scrolledwin); gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); title[0] = _("Available items"); stock_clist = gtk_clist_new_with_titles(1, title); gtk_widget_show(stock_clist); gtk_container_add(GTK_CONTAINER(scrolledwin), stock_clist); gtk_clist_set_selection_mode(GTK_CLIST(stock_clist), GTK_SELECTION_BROWSE); GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(stock_clist)->column[0].button, GTK_CAN_FOCUS); gtkut_clist_set_redraw(GTK_CLIST(stock_clist)); /* add/remove button */ btn_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(btn_vbox); gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0); btn_vbox1 = gtk_vbox_new(FALSE, 8); gtk_widget_show(btn_vbox1); gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0); add_btn = gtk_button_new_with_label(_(" -> ")); gtk_widget_show(add_btn); gtk_box_pack_start(GTK_BOX(btn_vbox1), add_btn, FALSE, FALSE, 0); remove_btn = gtk_button_new_with_label(_(" <- ")); gtk_widget_show(remove_btn); gtk_box_pack_start(GTK_BOX(btn_vbox1), remove_btn, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(add_btn), "clicked", G_CALLBACK(prefs_display_items_add), dialog); g_signal_connect(G_OBJECT(remove_btn), "clicked", G_CALLBACK(prefs_display_items_remove), dialog); clist_hbox = gtk_hbox_new(FALSE, 8); gtk_widget_show(clist_hbox); gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0); scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request (scrolledwin, SCROLLED_WINDOW_WIDTH * gtkut_get_dpi_multiplier(), SCROLLED_WINDOW_HEIGHT * gtkut_get_dpi_multiplier()); gtk_widget_show(scrolledwin); gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); title[0] = _("Displayed items"); shown_clist = gtk_clist_new_with_titles(1, title); gtk_widget_show(shown_clist); gtk_container_add(GTK_CONTAINER(scrolledwin), shown_clist); gtk_clist_set_selection_mode(GTK_CLIST(shown_clist), GTK_SELECTION_BROWSE); #if 0 gtk_clist_set_reorderable(GTK_CLIST(shown_clist), TRUE); gtk_clist_set_use_drag_icons(GTK_CLIST(shown_clist), FALSE); #endif GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(shown_clist)->column[0].button, GTK_CAN_FOCUS); gtkut_clist_set_redraw(GTK_CLIST(shown_clist)); g_signal_connect(G_OBJECT(shown_clist), "select-row", G_CALLBACK(prefs_display_items_shown_select_row), dialog); g_signal_connect_after(G_OBJECT(shown_clist), "row-move", G_CALLBACK(prefs_display_items_shown_row_move), dialog); /* up/down button */ btn_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(btn_vbox); gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0); btn_vbox1 = gtk_vbox_new(FALSE, 8); gtk_widget_show(btn_vbox1); gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0); up_btn = gtk_button_new_with_label(_("Up")); gtk_widget_show(up_btn); gtk_box_pack_start(GTK_BOX(btn_vbox1), up_btn, FALSE, FALSE, 0); down_btn = gtk_button_new_with_label(_("Down")); gtk_widget_show(down_btn); gtk_box_pack_start(GTK_BOX(btn_vbox1), down_btn, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(up_btn), "clicked", G_CALLBACK(prefs_display_items_up), dialog); g_signal_connect(G_OBJECT(down_btn), "clicked", G_CALLBACK(prefs_display_items_down), dialog); btn_hbox = gtk_hbox_new(FALSE, 8); gtk_widget_show(btn_hbox); gtk_box_pack_end(GTK_BOX(vbox), btn_hbox, FALSE, FALSE, 0); btn_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(btn_vbox); gtk_box_pack_start(GTK_BOX(btn_hbox), btn_vbox, FALSE, FALSE, 0); default_btn = gtk_button_new_with_label(_(" Revert to default ")); gtk_widget_show(default_btn); gtk_box_pack_start(GTK_BOX(btn_vbox), default_btn, TRUE, FALSE, 0); g_signal_connect(G_OBJECT(default_btn), "clicked", G_CALLBACK(prefs_display_items_default), dialog); gtkut_stock_button_set_create(&confirm_area, &ok_btn, GTK_STOCK_OK, &cancel_btn, GTK_STOCK_CANCEL, NULL, NULL); gtk_widget_show(confirm_area); gtk_box_pack_end(GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(ok_btn); g_signal_connect(G_OBJECT(ok_btn), "clicked", G_CALLBACK(prefs_display_items_ok), dialog); g_signal_connect(G_OBJECT(cancel_btn), "clicked", G_CALLBACK(prefs_display_items_cancel), dialog); dialog->window = window; dialog->label = label; dialog->stock_clist = stock_clist; dialog->shown_clist = shown_clist; dialog->add_btn = add_btn; dialog->remove_btn = remove_btn; dialog->up_btn = up_btn; dialog->down_btn = down_btn; dialog->confirm_area = confirm_area; dialog->ok_btn = ok_btn; dialog->cancel_btn = cancel_btn; gtkut_box_set_reverse_order(GTK_BOX(dialog->confirm_area), !prefs_common.comply_gnome_hig); manage_window_set_transient(GTK_WINDOW(dialog->window)); gtk_widget_grab_focus(dialog->ok_btn); dialog->finished = FALSE; dialog->cancelled = FALSE; return dialog; }
int main (int argc, char *argv[]) { GtkWidget *window, *treeview, *scrolled_win; GtkTreeStore *store; GtkTreeIter iter, child; guint i = 0, j; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Grocery List"); gtk_container_set_border_width (GTK_CONTAINER (window), 10); gtk_widget_set_size_request (window, 275, 300); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); treeview = gtk_tree_view_new (); setup_tree_view (treeview); store = gtk_tree_store_new (COLUMNS, G_TYPE_BOOLEAN, G_TYPE_INT, G_TYPE_STRING); while (list[i].product != NULL) { /* If the product type is a category, count the quantity of all of the products * in the category that are going to be boughty. */ if (list[i].product_type == PRODUCT_CATEGORY) { j = i + 1; /* Calculate how many products will be bought in the category. */ while (list[j].product != NULL && list[j].product_type != PRODUCT_CATEGORY) { if (list[j].buy) list[i].quantity += list[j].quantity; j++; } /* Add the category as a new root element. */ gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, BUY_IT, list[i].buy, QUANTITY, list[i].quantity, PRODUCT, list[i].product, -1); } /* Otherwise, add the product as a child of the category. */ else { gtk_tree_store_append (store, &child, &iter); gtk_tree_store_set (store, &child, BUY_IT, list[i].buy, QUANTITY, list[i].quantity, PRODUCT, list[i].product, -1); } i++; } gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store)); gtk_tree_view_expand_all (GTK_TREE_VIEW (treeview)); g_object_unref (store); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (scrolled_win), treeview); gtk_container_add (GTK_CONTAINER (window), scrolled_win); gtk_widget_show_all (window); gtk_main (); return 0; }
int main( int argc, char *argv[] ) { GtkWidget *window; GtkWidget *drawing_area; GtkWidget *vbox; GtkWidget *v1box; GtkWidget *hbox; GtkWidget *button; gtk_init (&argc, &argv); printf("Helo\n"); int i,j; for(i=0;i<1000;i++) { for(j=0;j<1000;j++) { pixels[i][j]=0; visited[i][j]=0; } } window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_title(GTK_WINDOW(window), "pencil_project"); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); g_signal_connect (GTK_WINDOW(window), "destroy", G_CALLBACK (quit), NULL); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); v1box = newVerticalbox ( FALSE, 0, TRUE, TRUE, 0 ); gtk_box_pack_start (GTK_BOX (hbox), v1box, FALSE, FALSE, 0); gtk_widget_show (v1box); /* Create the drawing area */ drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (GTK_WIDGET (drawing_area), breadth, height);//breadth,height global variables in buttons.h //cr = gdk_cairo_create(drawing_area->window); gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0); gtk_widget_show (drawing_area); g_signal_connect (drawing_area, "expose_event", G_CALLBACK (expose_event),NULL); /* g_signal_connect (drawing_area, "configure_event", G_CALLBACK (configure_event), NULL); /* Event signals */ g_signal_connect (drawing_area, "motion_notify_event", G_CALLBACK (motion_notify_event), NULL);//made them null as it don't have significance. handler_id = g_signal_connect (drawing_area, "button_press_event", G_CALLBACK (button_press_event), NULL); gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK |GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK |GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); button = horizontal_box ( FALSE, 0, TRUE, TRUE, 0, TRUE ); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); button = horizontal_box ( FALSE, 0, TRUE, TRUE, 0, FALSE ); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Fill"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect_swapped (button, "clicked", G_CALLBACK (button_press_event_fill), drawing_area); gtk_widget_show_all (window); gtk_main (); return 0; }
/************************************************************************** Size of overview changed **************************************************************************/ void overview_size_changed(void) { gtk_widget_set_size_request(overview_canvas, overview.width, overview.height); update_map_canvas_scrollbars_size(); }
static gboolean cg_combo_flags_popup_idle (gpointer data) { CgComboFlags *combo; CgComboFlagsPrivate *priv; GtkTreeSelection* selection; GtkWidget *toplevel; GtkWidget *scrolled; GdkWindow *window; GdkDeviceManager* device_manager; gint height, width, x, y; combo = CG_COMBO_FLAGS (data); priv = CG_COMBO_FLAGS_PRIVATE (combo); g_assert (priv->window == NULL); priv->window = gtk_window_new (GTK_WINDOW_POPUP); g_object_ref (G_OBJECT (priv->window)); gtk_window_set_resizable (GTK_WINDOW (priv->window), FALSE); g_signal_connect (G_OBJECT (priv->window), "key_press_event", G_CALLBACK (cg_combo_flags_window_key_press_cb), combo); g_signal_connect (G_OBJECT (priv->window), "button_press_event", G_CALLBACK (cg_combo_flags_window_button_press_cb), combo); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (priv->window), scrolled); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_widget_show (scrolled); priv->treeview = gtk_tree_view_new_with_model (priv->model); gtk_widget_show (priv->treeview); gtk_container_add (GTK_CONTAINER (scrolled), priv->treeview); g_signal_connect (G_OBJECT (priv->treeview), "key_press_event", G_CALLBACK (cg_combo_flags_treeview_key_press_cb), combo); g_signal_connect (G_OBJECT (priv->treeview), "button_press_event", G_CALLBACK (cg_combo_flags_treeview_button_press_cb), combo); priv->column = gtk_tree_view_column_new (); g_object_ref (G_OBJECT (priv->column)); cg_combo_flags_sync_cells (combo, GTK_CELL_LAYOUT (priv->column)); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), priv->column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_set_hover_selection (GTK_TREE_VIEW (priv->treeview), TRUE); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (combo)); if (GTK_IS_WINDOW (toplevel)) { gtk_window_group_add_window (gtk_window_get_group ( GTK_WINDOW (toplevel)), GTK_WINDOW (priv->window)); gtk_window_set_transient_for (GTK_WINDOW (priv->window), GTK_WINDOW (toplevel)); } gtk_window_set_screen (GTK_WINDOW (priv->window), gtk_widget_get_screen (GTK_WIDGET (combo))); cg_combo_flags_get_position (combo, &x, &y, &width, &height); gtk_widget_set_size_request (priv->window, width, height); gtk_window_move (GTK_WINDOW(priv->window), x, y); gtk_widget_show (priv->window); gtk_widget_grab_focus (priv->window); if (!gtk_widget_has_focus (priv->treeview)) gtk_widget_grab_focus (priv->treeview); window = gtk_widget_get_window (priv->window); device_manager = gdk_display_get_device_manager (gdk_window_get_display (window)); priv->pointer_device = gdk_device_manager_get_client_pointer (device_manager); priv->keyboard_device = gdk_device_get_associated_device (priv->pointer_device); gtk_grab_add (priv->window); gdk_device_grab (priv->pointer_device, window, GDK_OWNERSHIP_NONE, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, GDK_CURRENT_TIME); gdk_device_grab (priv->keyboard_device, window, GDK_OWNERSHIP_NONE, TRUE, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, NULL, GDK_CURRENT_TIME); return FALSE; }
void gui_create_tasks(GUI *appGUI) { GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table; GtkWidget *label; GtkWidget *top_scrolledwindow; GtkWidget *hseparator; GtkWidget *close_button; GtkCellRenderer *renderer; GtkWidget *top_viewport; GtkWidget *bottom_viewport; GtkTextBuffer *text_buffer; GError *error = NULL; GtkActionGroup *action_group = NULL; gchar tmpbuf[BUFFER_SIZE]; const gchar *ui_info = " <toolbar name=\"toolbar\">\n" " <toolitem name=\"add\" action=\"add\" />\n" " <toolitem name=\"delete\" action=\"delete\" />\n" " <separator name=\"sep1\" />\n" " <toolitem name=\"edit\" action=\"edit\" />\n" " </toolbar>\n"; GtkActionEntry entries[] = { { "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL }, { "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL }, { "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL }, }; guint n_entries = G_N_ELEMENTS (entries); appGUI->tsk->filter_index = 0; vbox1 = gtk_vbox_new (FALSE, 1); gtk_widget_show (vbox1); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8); sprintf(tmpbuf, "<b>%s</b>", _("Tasks")); gui_add_to_notebook (vbox1, tmpbuf, appGUI); appGUI->tsk->vbox = GTK_BOX(vbox1); if (config.hide_tasks == TRUE) { gtk_widget_hide(GTK_WIDGET(appGUI->tsk->vbox)); } /*-------------------------------------------------------------------------------------*/ action_group = gtk_action_group_new ("_actions"); gtk_action_group_add_actions (action_group, entries, n_entries, NULL); gtk_action_group_set_sensitive(action_group, TRUE); appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0); g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI); if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) { g_message ("building toolbar failed: %s", error->message); g_error_free (error); } gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget); gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS); gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips); /*-------------------------------------------------------------------------------------*/ /* assign callbacks */ g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked", G_CALLBACK(tasks_add_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked", G_CALLBACK(tasks_edit_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked", G_CALLBACK(tasks_remove_item_cb), appGUI); /*-------------------------------------------------------------------------------------*/ gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE); gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); table = gtk_table_new (1, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "<b>%s:</b>", _("Category filter")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); appGUI->tsk->cf_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->cf_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE); GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(appGUI->tsk->cf_combobox, "changed", G_CALLBACK(category_filter_cb), appGUI); g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus", G_CALLBACK(category_combo_box_focus_cb), NULL); appGUI->tsk->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->tsk->n_items_label); gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); /*-------------------------------------------------------------------------------------*/ appGUI->tsk->tasks_paned = gtk_vpaned_new(); gtk_widget_show (appGUI->tsk->tasks_paned); gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999); gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0); top_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (top_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE); gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE); top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (top_scrolledwindow); gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT); appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter), (GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb, appGUI, NULL); appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter)); appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint); gtk_widget_show (appGUI->tsk->tasks_list); GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED])); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL])); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event", G_CALLBACK(list_dbclick_cb), appGUI); appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list)); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed", G_CALLBACK(tasks_item_selected), appGUI); /* create columns */ renderer = gtk_cell_renderer_toggle_new(); appGUI->tsk->tasks_columns[TA_COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"), renderer, "active", TA_COLUMN_DONE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DONE]); g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"), renderer, "text", TA_COLUMN_DUE_DATE, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE], config.visible_due_date_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", TA_COLUMN_DUE_DATE_JULIAN, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", TA_COLUMN_START_DATE_JULIAN, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_START_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_START_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"), renderer, "text", TA_COLUMN_PRIORITY, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_PRIORITY], config.visible_priority_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_PRIORITY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", TA_COLUMN_CATEGORY, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_CATEGORY], config.visible_category_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_CATEGORY]); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_renderer_set_fixed_size(renderer, 0, -1); appGUI->tsk->tasks_columns[TA_COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"), renderer, "text", TA_COLUMN_SUMMARY, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_SUMMARY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", TA_COLUMN_DESCRIPTION, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_DESCRIPTION], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DESCRIPTION]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", TA_COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_COLOR], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_COLOR]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_BOLD] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_BOLD], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_BOLD]); /* configure list options */ gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE); /* configure sorting */ gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0, (GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, TA_COLUMN_DUE_DATE, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, TA_COLUMN_PRIORITY, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, TA_COLUMN_DONE, config.tasks_sorting_order); /*----------------------------------------------------------------------------*/ bottom_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (bottom_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE); gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0); gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2); appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0); gtk_widget_show(appGUI->tsk->panel_hbox); sprintf(tmpbuf, "%s:", _("Task details")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0); if (config.default_stock_icons) { close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE); } else { close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE); } GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE); gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL); gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (panel_close_desc_cb), appGUI); appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (appGUI->tsk->panel_scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_desc_textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_widget_show (appGUI->tsk->tasks_desc_textview); gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview)); gtk_text_buffer_create_tag (text_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL); appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font", "font", (gchar *) config.task_info_font, NULL); }
static void cinnamon_control_center_init (CinnamonControlCenter *self) { GError *err = NULL; CinnamonControlCenterPrivate *priv; GdkScreen *screen; GtkWidget *widget; priv = self->priv = CONTROL_CENTER_PRIVATE (self); priv->monitor_num = -1; self->priv->small_screen = SMALL_SCREEN_UNSET; /* load the user interface */ priv->builder = gtk_builder_new (); if (!gtk_builder_add_from_file (priv->builder, UIDIR "/shell.ui", &err)) { g_critical ("Could not build interface: %s", err->message); g_error_free (err); return; } /* connect various signals */ priv->window = W (priv->builder, "main-window"); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (priv->window), TRUE); screen = gtk_widget_get_screen (priv->window); g_signal_connect (screen, "monitors-changed", G_CALLBACK (monitors_changed_cb), self); g_signal_connect (priv->window, "configure-event", G_CALLBACK (main_window_configure_cb), self); g_signal_connect (priv->window, "notify::application", G_CALLBACK (application_set_cb), self); g_signal_connect_swapped (priv->window, "delete-event", G_CALLBACK (g_object_unref), self); g_signal_connect_after (priv->window, "key_press_event", G_CALLBACK (window_key_press_event), self); priv->notebook = W (priv->builder, "notebook"); /* Main scrolled window */ priv->scrolled_window = W (priv->builder, "scrolledwindow1"); if (!g_strcmp0(g_getenv("XDG_CURRENT_DESKTOP"), "Unity")) gtk_widget_set_size_request (priv->scrolled_window, UNITY_FIXED_WIDTH, -1); else gtk_widget_set_size_request (priv->scrolled_window, FIXED_WIDTH, -1); priv->main_vbox = W (priv->builder, "main-vbox"); g_signal_connect (priv->notebook, "notify::page", G_CALLBACK (notebook_page_notify_cb), priv); priv->nav_bar = cc_shell_nav_bar_new (); widget = W (priv->builder, "hbox1"); gtk_box_pack_start (GTK_BOX (widget), priv->nav_bar, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (widget), priv->nav_bar, 0); gtk_widget_show (priv->nav_bar); g_signal_connect (priv->nav_bar, "home-clicked", G_CALLBACK (home_button_clicked_cb), self); /* keep a list of custom widgets to unload on panel change */ priv->custom_widgets = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); /* load the available settings panels */ setup_model (self); /* load the panels that are implemented as plugins */ load_panel_plugins (self); /* setup search functionality */ setup_search (self); setup_lock (self); /* store default window title and name */ priv->default_window_title = g_strdup (gtk_window_get_title (GTK_WINDOW (priv->window))); priv->default_window_icon = g_strdup (gtk_window_get_icon_name (GTK_WINDOW (priv->window))); notebook_page_notify_cb (GTK_NOTEBOOK (priv->notebook), NULL, priv); }
void CalendarDatePrivate::initDayView() { ComputeDays(); GtkWidget* swipebox; gint rowCount = 7; gint offsetCols = (m_isShowWeekNum ? 1 : 0); gint colCount = 7 + offsetCols; int row = 0; int col = 0; char buffer[32]; int selectedYear = m_selectedYear; int selectedMonth = m_selectedMonth; GDateTime* nowDate = g_date_time_new_now_local(); int cellWidth = MAIN_BOX_DEFAULT_WIDTH / colCount; int cellHeight = MAIN_BOX_DEFAULT_WIDTH / rowCount; m_swipeBox[VIEWTYPE_DAY] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); swipebox = m_swipeBox[VIEWTYPE_DAY]; gtk_fixed_put(GTK_FIXED(m_mainBox), GTK_WIDGET(m_swipeBox[VIEWTYPE_DAY]), 0, 0); gtk_widget_set_name(GTK_WIDGET(swipebox), "calendar-table"); GDateTime* selectedDate = g_date_time_new_local(m_selectedYear, m_selectedMonth, m_selectedDayOfMonth, 1, 1, 1); gchar* dateLabelText = g_date_time_format(selectedDate, C_("calendar heading", "%Y, %b")); gtk_button_set_label(GTK_BUTTON(m_viewTypeSwitch), dateLabelText); g_date_time_unref(selectedDate); g_free(dateLabelText); for (col = 0; col < colCount; ++col) { GtkWidget* daylayout = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); for (row = 0; row < rowCount; ++row) { if (m_isShowWeekNum && (0 == col)) { if (0 == row) { GtkWidget* weeknumbtn = gtk_button_new_with_label(""); gtk_widget_set_size_request(GTK_WIDGET(weeknumbtn), cellWidth, cellHeight); gtk_box_pack_start(GTK_BOX(daylayout), GTK_WIDGET(weeknumbtn), TRUE, TRUE, 0); } else { int day = m_day[row - 1][6]; int month = selectedMonth; int year = selectedYear; switch (m_dayMonth[row - 1][6]) { case MONTH_PREV: --month; if (1 > month) { month = 12; --year; } break; case MONTH_CURRENT: break; case MONTH_NEXT: ++month; if (12 < month) { month = 1; ++year; } break; default: g_assert(FALSE); break; } int week = weekOfYear(year, month, day); g_snprintf(buffer, sizeof(buffer), "%02d", week); GtkWidget* weeknumbtn = gtk_button_new_with_label(buffer); gtk_widget_set_size_request(GTK_WIDGET(weeknumbtn), cellWidth, cellHeight); gtk_box_pack_start(GTK_BOX(daylayout), GTK_WIDGET(weeknumbtn), TRUE, TRUE, 0); } // end: if (0 == row) } else { if (0 == row) { GtkWidget* weekTitleItem = gtk_button_new_with_label(m_defaultAbbreviatedDayname[(col - offsetCols + m_weekStart) % 7]); gtk_widget_set_size_request(GTK_WIDGET(weekTitleItem), cellWidth, cellHeight); gtk_box_pack_start(GTK_BOX(daylayout), GTK_WIDGET(weekTitleItem), TRUE, TRUE, 0); } else { m_dayItem[row - 1][col - offsetCols] = new CalendarItem(ITEMTYPE_DAY_OF_MONTH, m_day[row - 1][col - offsetCols]); m_dayItem[row - 1][col - offsetCols]->setSize(cellWidth, cellHeight); m_dayItem[row - 1][col - offsetCols]->setParent(GTK_WIDGET(daylayout)); } } // end: if (priv->show_week_num && (0 == col)) } // end: for row gtk_box_pack_start(GTK_BOX(swipebox), GTK_WIDGET(daylayout), TRUE, TRUE, 0); } // end: for col g_date_time_unref(nowDate); }
void cal_notes_browser (GUI *appGUI) { GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *scrolledwindow; GtkWidget *hseparator; GtkWidget *hbuttonbox; GtkWidget *close_button; GtkWidget *notes_tools_table; GtkWidget *label; GtkObject *notes_month_spinbutton_adj; GtkObject *notes_year_spinbutton_adj; GtkTreeViewColumn *column; GtkCellRenderer *renderer; gchar tmpbuf[BUFFER_SIZE]; appGUI->cal->day_notes_list = NULL; appGUI->cal->day_notes_list_store = NULL; appGUI->cal->day_notes_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (appGUI->cal->day_notes_window), _("Calendar notes")); gtk_window_set_position (GTK_WINDOW (appGUI->cal->day_notes_window), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_default_size (GTK_WINDOW(appGUI->cal->day_notes_window), config.cb_window_size_x, config.cb_window_size_y); gtk_window_set_modal (GTK_WINDOW (appGUI->cal->day_notes_window), TRUE); g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "delete_event", G_CALLBACK(day_notes_window_close_cb), appGUI); gtk_window_set_transient_for(GTK_WINDOW(appGUI->cal->day_notes_window), GTK_WINDOW(appGUI->main_window)); gtk_container_set_border_width (GTK_CONTAINER (appGUI->cal->day_notes_window), 8); g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "key_press_event", G_CALLBACK (day_notes_key_press_cb), appGUI); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (appGUI->cal->day_notes_window), vbox1); notes_tools_table = gtk_table_new (6, 3, FALSE); gtk_widget_show (notes_tools_table); gtk_box_pack_start (GTK_BOX (vbox1), notes_tools_table, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (notes_tools_table), 3); gtk_table_set_col_spacings (GTK_TABLE (notes_tools_table), 2); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); sprintf(tmpbuf, "<b>%s:</b>", _("Search")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_table_attach (GTK_TABLE (notes_tools_table), hbox1, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); notes_month_spinbutton_adj = gtk_adjustment_new (1, 1, 12, 1, 5, 0); appGUI->cal->notes_month_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_month_spinbutton_adj), 1, 0); gtk_widget_show (appGUI->cal->notes_month_spinbutton); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_month_spinbutton, TRUE, TRUE, 0); g_signal_connect (appGUI->cal->notes_month_spinbutton, "value-changed", G_CALLBACK (notes_filter_changed_cb), appGUI); notes_year_spinbutton_adj = gtk_adjustment_new (utl_date_get_current_year (), 1, 9999, 1, 10, 0); appGUI->cal->notes_year_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_year_spinbutton_adj), 1, 0); gtk_widget_show (appGUI->cal->notes_year_spinbutton); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_year_spinbutton, TRUE, TRUE, 0); g_signal_connect (appGUI->cal->notes_year_spinbutton, "value-changed", G_CALLBACK (notes_filter_changed_cb), appGUI); sprintf(tmpbuf, "<b>%s:</b>", _("Filter")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->cal->notes_filter_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->cal->notes_filter_combobox); g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "focus", G_CALLBACK(notes_filter_combo_box_focus_cb), NULL); g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "changed", G_CALLBACK(notes_filter_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_filter_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current month")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current year")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected year")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month and year")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("All notes")); gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->cal->notes_filter_combobox), config.day_notes_browser_filter); appGUI->cal->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->cal->n_items_label); gtk_widget_set_size_request (appGUI->cal->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->n_items_label, 2, 3, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->cal->n_items_label), TRUE); appGUI->cal->notes_search_entry = gtk_entry_new (); gtk_widget_show (appGUI->cal->notes_search_entry); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_entry, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (G_OBJECT (appGUI->cal->notes_search_entry), "key_press_event", G_CALLBACK (search_entry_key_press_cb), appGUI); appGUI->cal->notes_search_checkbutton = gtk_check_button_new_with_mnemonic (_("Case sensitive")); gtk_widget_show (appGUI->cal->notes_search_checkbutton); GTK_WIDGET_UNSET_FLAGS(appGUI->cal->notes_search_checkbutton, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_checkbutton, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); appGUI->cal->past_notes_checkbutton = gtk_check_button_new_with_mnemonic (_("Strikethrough past day notes")); GTK_WIDGET_UNSET_FLAGS(appGUI->cal->past_notes_checkbutton, GTK_CAN_FOCUS); g_signal_connect (G_OBJECT (appGUI->cal->past_notes_checkbutton), "toggled", G_CALLBACK (browser_past_notes_cb), appGUI); gtk_widget_show (appGUI->cal->past_notes_checkbutton); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->past_notes_checkbutton, 0, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->cal->day_notes_list_store = gtk_list_store_new(DAY_NOTES_NUM_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN); appGUI->cal->day_notes_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->cal->day_notes_list_store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->cal->day_notes_list), TRUE); gtk_widget_show (appGUI->cal->day_notes_list); GTK_WIDGET_SET_FLAGS (appGUI->cal->day_notes_list, GTK_CAN_DEFAULT); gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->cal->day_notes_list); g_signal_connect(G_OBJECT(appGUI->cal->day_notes_list), "button_press_event", G_CALLBACK(day_notes_list_dbclick_cb), appGUI); appGUI->cal->day_notes_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->cal->day_notes_list)); /* create columns */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Date"), renderer, "text", DN_COLUMN_DATE, "strikethrough", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Julian", renderer, "text", DN_COLUMN_DATE_JULIAN, "strikethrough", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); gtk_tree_view_column_set_sort_column_id (column, DN_COLUMN_DATE_JULIAN); g_signal_emit_by_name(column, "clicked"); if (config.ascending_sorting_in_day_notes_browser == FALSE) { g_signal_emit_by_name(column, "clicked"); } renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes(_("Note"), renderer, "text", DN_COLUMN_NOTE_LINE, "strikethrough", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); refresh_notes_list (config.day_notes_browser_filter, NULL, appGUI); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4); hbuttonbox = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonbox), 4); close_button = utl_gui_create_button (GTK_STOCK_CLOSE, OSMO_STOCK_BUTTON_CLOSE, _("Close")); gtk_widget_show (close_button); GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); g_signal_connect(close_button, "clicked", G_CALLBACK(button_day_notes_window_close_cb), appGUI); gtk_container_add(GTK_CONTAINER(hbuttonbox), close_button); gtk_widget_show(appGUI->cal->day_notes_window); gtk_widget_grab_focus (appGUI->cal->day_notes_list); }
static void properties_activated_cb (GtkMenuItem *mitem, LdapFavoriteSelector *fsel) { if (! fsel->priv->popup_properties) { GtkWidget *pcont, *vbox, *hbox, *label, *entry, *grid; gchar *str; pcont = popup_container_new (GTK_WIDGET (mitem)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (pcont), vbox); label = gtk_label_new (""); str = g_strdup_printf ("<b>%s:</b>", _("Favorite's properties")); gtk_label_set_markup (GTK_LABEL (label), str); g_free (str); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); /* HIG */ gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); grid = gtk_grid_new (); gtk_box_pack_start (GTK_BOX (hbox), grid, TRUE, TRUE, 0); label = gtk_label_new (""); str = g_strdup_printf ("<b>%s:</b>", _("Name")); gtk_label_set_markup (GTK_LABEL (label), str); g_free (str); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1); label = gtk_label_new (""); str = g_strdup_printf ("<b>%s:</b>", _("Description")); gtk_label_set_markup (GTK_LABEL (label), str); g_free (str); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); entry = gtk_entry_new (); gtk_editable_set_editable (GTK_EDITABLE (entry), FALSE); gtk_grid_attach (GTK_GRID (grid), entry, 1, 0, 1, 1); fsel->priv->properties_name = entry; entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_grid_attach (GTK_GRID (grid), entry, 1, 1, 1, 1); fsel->priv->properties_descr = entry; g_signal_connect (entry, "changed", G_CALLBACK (property_changed_cb), fsel); fsel->priv->popup_properties = pcont; gtk_widget_show_all (vbox); } /* adjust contents */ GtkTreeSelection *selection; GtkTreeModel *model; GtkTreeIter iter; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (fsel->priv->treeview)); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gchar *name, *descr; gtk_tree_model_get (model, &iter, COLUMN_ID, &(fsel->priv->properties_id), COLUMN_POSITION, &(fsel->priv->properties_position), COLUMN_NAME, &name, COLUMN_DESCR, &descr, -1); if (name) { gtk_entry_set_text (GTK_ENTRY (fsel->priv->properties_name), name); g_free (name); } g_signal_handlers_block_by_func (fsel->priv->properties_descr, G_CALLBACK (property_changed_cb), fsel); gtk_entry_set_text (GTK_ENTRY (fsel->priv->properties_descr), descr ? descr : ""); g_signal_handlers_unblock_by_func (fsel->priv->properties_descr, G_CALLBACK (property_changed_cb), fsel); g_free (descr); gtk_widget_show (fsel->priv->popup_properties); } }