Exemplo n.º 1
0
void
gui_create_tasks_options_page   (GtkWidget *vbox, GUI *appGUI) {

GtkWidget           *appearance_vbox, *categories_vbox;
GtkWidget           *sorting_vbox, *tasks_opt_vbox, *visible_columns_vbox;
GtkWidget           *label;
GtkWidget           *colors_hbox;
GtkWidget           *valid_hbox;
GtkWidget           *frame;
GtkWidget           *table;
GtkWidget           *alignment;
GtkWidget           *ti_font_button;
GtkWidget           *scrolledwindow;
GtkWidget           *tasks_category_table;
GtkCellRenderer     *renderer;
GtkTreeViewColumn   *column;
GdkColor            color;
GtkObject           *postpone_time_spinbutton_adj;

gchar tmpbuf[BUFFER_SIZE];


    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);

    appearance_vbox = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (appearance_vbox);
    gtk_container_add (GTK_CONTAINER (alignment), appearance_vbox);

    table = gtk_table_new (4, 4, FALSE);
    gtk_widget_show (table);
    gtk_box_pack_start (GTK_BOX (appearance_vbox), table, FALSE, FALSE, 0);
    gtk_table_set_col_spacings (GTK_TABLE (table), 4);
    gtk_table_set_row_spacings (GTK_TABLE (table), 8);

    colors_hbox = gtk_hbox_new (FALSE, 8);
    gtk_widget_show (colors_hbox);
    gtk_table_attach (GTK_TABLE (table), colors_hbox, 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);
	if (config.enable_tooltips) {
		gtk_widget_set_tooltip_text (appGUI->opt->due_today_color_picker, _("Color of items that are due today"));
	}
    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 (colors_hbox), 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);
	if (config.enable_tooltips) {
		gtk_widget_set_tooltip_text (appGUI->opt->due_7days_color_picker, _("Color of items that are due in the next 7 days"));
	}
    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 (colors_hbox), 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);
	if (config.enable_tooltips) {
		gtk_widget_set_tooltip_text (appGUI->opt->past_due_color_picker, _("Color of items that are past due"));
	}
    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 (colors_hbox), 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 = utl_gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE);
    } else {
        ti_font_button = utl_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);

    appGUI->opt->ct_bold_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Show in bold tasks with high priority"));
    GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_bold_items_checkbutton, GTK_CAN_FOCUS);
    gtk_widget_show (appGUI->opt->ct_bold_items_checkbutton);
    gtk_table_attach (GTK_TABLE (table), appGUI->opt->ct_bold_items_checkbutton, 0, 3, 3, 4,
                      (GtkAttachOptions) (GTK_FILL),
                      (GtkAttachOptions) (0), 0, 0);
    g_signal_connect (G_OBJECT (appGUI->opt->ct_bold_items_checkbutton), "toggled",
                      G_CALLBACK (bold_items_cb), appGUI);

    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);

    visible_columns_vbox = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (visible_columns_vbox);
    gtk_container_add (GTK_CONTAINER (alignment), visible_columns_vbox);

    table = gtk_table_new (1, 4, FALSE);
    gtk_widget_show (table);
    gtk_box_pack_start (GTK_BOX (visible_columns_vbox), 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_type_checkbutton = gtk_check_button_new_with_mnemonic (_("Type"));
    GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_type_checkbutton, GTK_CAN_FOCUS);
    gtk_widget_show (appGUI->opt->vc_type_checkbutton);
    g_signal_connect (G_OBJECT (appGUI->opt->vc_type_checkbutton), "toggled",
                      G_CALLBACK (visible_columns_changed_cb), appGUI);
    gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_type_checkbutton, 1, 2, 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, 2, 3, 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, 3, 4, 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);

    categories_vbox = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (categories_vbox);
    gtk_container_add (GTK_CONTAINER (alignment), categories_vbox);

    tasks_category_table = gtk_table_new (4, 3, FALSE);
    gtk_widget_show (tasks_category_table);
    gtk_box_pack_start (GTK_BOX (categories_vbox), 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(3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);

    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), TRUE);
    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, 120);

    renderer = gtk_cell_renderer_text_new();
    g_object_set (renderer, "editable", TRUE, "editable-set", TRUE, NULL);
    g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (tasks_category_cell_edited_cb), appGUI);

    column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", TC_COLUMN_NAME, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);
    gtk_tree_view_column_set_expand (column, TRUE);

    renderer = gtk_cell_renderer_toggle_new();    /* Show in calendar */
    column = gtk_tree_view_column_new_with_attributes(_("Calendar"), renderer, "active", TC_COLUMN_CALENDAR, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);
    
    g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_calendar_toggled), appGUI);

    renderer = gtk_cell_renderer_toggle_new();    /* Show in tasks list */
    column = gtk_tree_view_column_new_with_attributes(_("Tasks"), renderer, "active", TC_COLUMN_TASKS, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);

    g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_tasks_list_toggled), appGUI);

    if (config.default_stock_icons) {
        appGUI->opt->tasks_category_add_button = utl_gui_stock_button (GTK_STOCK_ADD, FALSE);
    } else {
        appGUI->opt->tasks_category_add_button = utl_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 = utl_gui_stock_button (GTK_STOCK_REMOVE, FALSE);
    } else {
        appGUI->opt->tasks_category_remove_button = utl_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);

    sorting_vbox = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (sorting_vbox);
    gtk_container_add (GTK_CONTAINER (alignment), sorting_vbox);

    table = gtk_table_new (1, 5, FALSE);
    gtk_widget_show (table);
    gtk_box_pack_start (GTK_BOX (sorting_vbox), 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);

    tasks_opt_vbox = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (tasks_opt_vbox);
    gtk_container_add (GTK_CONTAINER (alignment), tasks_opt_vbox);

    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 (tasks_opt_vbox), 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 (tasks_opt_vbox), 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);

    appGUI->opt->ct_add_item_checkbutton = gtk_check_button_new_with_mnemonic (_("Add new task when double clicked on tasks list"));
    GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_add_item_checkbutton, GTK_CAN_FOCUS);
    gtk_widget_show (appGUI->opt->ct_add_item_checkbutton);
    gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_add_item_checkbutton, FALSE, FALSE, 4);
    g_signal_connect (G_OBJECT (appGUI->opt->ct_add_item_checkbutton), "toggled",
                      G_CALLBACK (add_item_cb), appGUI);

    appGUI->opt->ct_remember_category_checkbutton = gtk_check_button_new_with_mnemonic (_("Remember the last selected category"));
    GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_remember_category_checkbutton, GTK_CAN_FOCUS);
    gtk_widget_show (appGUI->opt->ct_remember_category_checkbutton);
    gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_remember_category_checkbutton, FALSE, FALSE, 4);
    g_signal_connect (G_OBJECT (appGUI->opt->ct_remember_category_checkbutton), "toggled",
                      G_CALLBACK (remember_category_cb), appGUI);

    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);
    g_snprintf (tmpbuf, BUFFER_SIZE, "<b>%s</b>", _("Reminder 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);

    table = gtk_table_new (2, 4, FALSE);
    gtk_widget_show (table);
    gtk_container_add (GTK_CONTAINER (alignment), table);
    gtk_container_set_border_width (GTK_CONTAINER (table), 4);
    gtk_table_set_col_spacings (GTK_TABLE (table), 4);
    gtk_table_set_row_spacings (GTK_TABLE (table), 8);

    g_snprintf (tmpbuf, BUFFER_SIZE, "%s:", _("Postpone time"));
    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);

    postpone_time_spinbutton_adj = gtk_adjustment_new (0, 0, 1440, 1, 10, 0);
    appGUI->opt->postpone_time_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (postpone_time_spinbutton_adj), 1, 0);
    g_signal_connect (G_OBJECT (appGUI->opt->postpone_time_spinbutton), "value-changed",
                      G_CALLBACK (postpone_time_changed_cb), appGUI);
    gtk_widget_show (appGUI->opt->postpone_time_spinbutton);
    gtk_table_attach (GTK_TABLE (table), appGUI->opt->postpone_time_spinbutton, 1, 2, 0, 1,
                      (GtkAttachOptions) (GTK_FILL),
                      (GtkAttachOptions) (0), 0, 0);
    gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (appGUI->opt->postpone_time_spinbutton), TRUE);

    gtk_spin_button_set_value (GTK_SPIN_BUTTON(appGUI->opt->postpone_time_spinbutton), config.postpone_time);

    g_snprintf (tmpbuf, BUFFER_SIZE, "%s (%s)", _("minutes"), _("0 for disable"));
    label = gtk_label_new (tmpbuf);
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
                      (GtkAttachOptions) (GTK_FILL),
                      (GtkAttachOptions) (0), 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

    g_snprintf (tmpbuf, BUFFER_SIZE, "%s:", _("Global notification command"));
    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);

    valid_hbox = gtk_hbox_new (FALSE, 2);
    gtk_widget_show (valid_hbox);
    gtk_table_attach (GTK_TABLE (table), valid_hbox, 1, 3, 1, 2,
                    (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
                    (GtkAttachOptions) (GTK_FILL), 0, 0);

    appGUI->opt->global_notification_cmd_entry = gtk_entry_new ();
    gtk_widget_show (appGUI->opt->global_notification_cmd_entry);
    g_signal_connect (G_OBJECT (appGUI->opt->global_notification_cmd_entry), "key_release_event",
                      G_CALLBACK (global_notification_entry_key_release_cb), appGUI);
    gtk_box_pack_start (GTK_BOX (valid_hbox), appGUI->opt->global_notification_cmd_entry, TRUE, TRUE, 0);

    appGUI->opt->global_notification_valid_image = gtk_image_new ();
    gtk_widget_show (appGUI->opt->global_notification_valid_image);
    gtk_box_pack_start (GTK_BOX (valid_hbox), appGUI->opt->global_notification_valid_image, FALSE, FALSE, 0);
}
Exemplo n.º 2
0
G_MODULE_EXPORT gboolean create_2d_table_editor(gint table_num, GtkWidget *parent)
{
	GladeXML *main_xml = NULL;
	GladeXML *xml = NULL;
	GtkWidget *widget = NULL;
	GtkWidget *window = NULL;
	GtkWidget *curve = NULL;
	GtkWidget *x_parent = NULL;
	GtkWidget *y_parent = NULL;
	GtkWidget *x_table = NULL;
	GtkWidget *y_table = NULL;
	GtkWidget *label = NULL;
	GtkWidget *entry = NULL;
	GtkWidget *dummy = NULL;
	GtkWidget *gauge = NULL;
	GtkWidget *curve_parent = NULL;
	CurveData *cdata = NULL;
	GArray *x_entries = NULL;
	GArray *y_entries = NULL;
	GList *widget_list = NULL;
	GList *curve_list = NULL;
	GList *gauge_list = NULL;
	gchar * tmpbuf = NULL;
	gchar * filename = NULL;
	GList ***ecu_widgets = NULL;
	gfloat *mult = NULL;
	gfloat *adder = NULL;
	gfloat raw_lower = 0;
	gfloat raw_upper = 0;
	gint x_mult = 0;
	gint y_mult = 0;
	gint page = 0;
	gint offset = 0;
	gint i = 0;
	guint32 id = 0;
	gfloat tmpf = 0.0;
	gint rows = 0;
	gboolean embedded = FALSE;
	Firmware_Details *firmware = NULL;

	firmware = DATA_GET(global_data,"firmware");
	ecu_widgets = DATA_GET(global_data,"ecu_widgets");

	if (table_num >= firmware->total_te_tables)
	{
		warn_user_f("Requested to create 2D table editor window for an undefined (out of range) table ID");
		return FALSE;
	}
	if (!firmware->te_params)
	{
		warn_user_f("No 2D table Editor tables (te_tables) defined in interrogation profile, yet told to create a graph for a table... BUG detected!");
		return FALSE;
	}
	if (!firmware->te_params[table_num])
	{
		warn_user_f("Requested to create a 2D table editor window for an undefined table!");
		return FALSE;
	}
	main_xml = (GladeXML *)DATA_GET(global_data,"main_xml");
	if (!main_xml)
		return FALSE;

	if (GTK_IS_WIDGET(parent)) /* Embedded mode */
		embedded = TRUE;

	if (!embedded)
	{
		xml = glade_xml_new(main_xml->filename,"table_editor_window",NULL);
		window = glade_xml_get_widget(xml,"table_editor_window");
		if (firmware->te_params[table_num]->bind_to_list)
		{
			OBJ_SET_FULL(window,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free);
			OBJ_SET(window,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type));
			bind_to_lists_f(window,firmware->te_params[table_num]->bind_to_list);
			widget_list = g_list_prepend(widget_list,(gpointer)window);
		}
		glade_xml_signal_autoconnect(xml);

		g_signal_connect(G_OBJECT(window),"destroy_event",
				G_CALLBACK(close_2d_editor),NULL);
		g_signal_connect(G_OBJECT(window),"delete_event",
				G_CALLBACK(close_2d_editor),NULL);
		tmpbuf = g_strdup_printf("%s (%s)",_("2D Table Editor"),firmware->te_params[table_num]->title);
		gtk_window_set_title(GTK_WINDOW(window),tmpbuf);
		g_free(tmpbuf);
		gtk_window_set_default_size(GTK_WINDOW(window),640,480);

		widget = glade_xml_get_widget(xml,"2d_close_button");
		g_signal_connect_swapped(G_OBJECT(widget),"clicked",
				G_CALLBACK(close_2d_editor),window);

		widget = glade_xml_get_widget(xml,"get_data_button");
		OBJ_SET(widget,"handler",GINT_TO_POINTER(READ_VE_CONST));
		OBJ_SET_FULL(widget,"bind_to_list",g_strdup("get_data_buttons"),g_free);
		bind_to_lists_f(widget,"get_data_buttons");
		widget_list = g_list_prepend(widget_list,(gpointer)widget);

		widget = glade_xml_get_widget(xml,"burn_data_button");
		OBJ_SET(widget,"handler",GINT_TO_POINTER(BURN_MS_FLASH));
		OBJ_SET_FULL(widget,"bind_to_list",g_strdup("burners"),g_free);
		bind_to_lists_f(widget,"burners");
		widget_list = g_list_prepend(widget_list,(gpointer)widget);

		widget = glade_xml_get_widget(xml,"curve_editor_menuitem");
		gtk_widget_set_sensitive(GTK_WIDGET(widget), FALSE);

		widget = glade_xml_get_widget(xml,"close_menuitem");
		OBJ_SET(widget,"window",(gpointer)window);

		curve_parent = glade_xml_get_widget(xml,"te_right_frame");
	}
	else
		curve_parent = parent;
	curve = mtx_curve_new();
	if (!embedded)
		curve_list = g_list_prepend(curve_list,(gpointer)curve);
	mtx_curve_set_title(MTX_CURVE(curve),(gchar *)_(firmware->te_params[table_num]->title));
	mtx_curve_set_x_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->x_axis_label));
	mtx_curve_set_y_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->y_axis_label));

	if ((firmware->te_params[table_num]->gauge ||
				firmware->te_params[table_num]->c_gauge ||
				firmware->te_params[table_num]->f_gauge) && (!embedded))
	{
		parent = glade_xml_get_widget(xml,"te_gaugeframe");
		gauge = mtx_gauge_face_new();
		gauge_list = g_list_prepend(gauge_list,(gpointer)gauge);
		if (firmware->te_params[table_num]->gauge_temp_dep)
		{
			if ((GINT)DATA_GET(global_data,"mtx_temp_units") == CELSIUS)
				tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/');
			else if ((GINT)DATA_GET(global_data,"mtx_temp_units") == KELVIN)
				tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/');
			else
				tmpbuf = g_strdelimit(firmware->te_params[table_num]->f_gauge,"\\",'/');
		}
		else
			tmpbuf = g_strdelimit(firmware->te_params[table_num]->gauge,"\\",'/');
		filename = get_file(g_strconcat(GAUGES_DATA_DIR,PSEP,tmpbuf,NULL),NULL);
		mtx_gauge_face_import_xml(MTX_GAUGE_FACE(gauge),filename);
		lookup_current_value_f(firmware->te_params[table_num]->gauge_datasource, &tmpf);
		mtx_gauge_face_set_value(MTX_GAUGE_FACE(gauge),tmpf);

		g_free(filename);
		id = create_value_change_watch_f(firmware->te_params[table_num]->gauge_datasource,FALSE,"update_misc_gauge",(gpointer)gauge);
		OBJ_SET(gauge,"gauge_id",GINT_TO_POINTER(id));
		gtk_container_add(GTK_CONTAINER(parent),gauge);
	}
	cdata = g_new0(CurveData, 1);
	cdata->curve = curve;
	cdata->axis = _X_;
	cdata->source = firmware->te_params[table_num]->x_source;
	mtx_curve_set_show_x_marker(MTX_CURVE(curve),TRUE);
	OBJ_SET(curve,"cdata",(gpointer)cdata);
	mtx_curve_set_auto_hide_vertexes(MTX_CURVE(curve),TRUE);
	g_signal_connect(G_OBJECT(curve),"coords-changed",
			G_CALLBACK(coords_changed), NULL);
	g_signal_connect(G_OBJECT(curve),"vertex-proximity",
			G_CALLBACK(vertex_proximity), NULL);
	g_signal_connect(G_OBJECT(curve),"marker-proximity",
			G_CALLBACK(marker_proximity), NULL);

	if (!embedded)
	{
		label = glade_xml_get_widget(xml,"x_units");
		gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_units);
		label = glade_xml_get_widget(xml,"y_units");
		gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_units);
		label = glade_xml_get_widget(xml,"x_title");
		gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_name);
		label = glade_xml_get_widget(xml,"y_title");
		gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_name);
	}
	rows = firmware->te_params[table_num]->bincount;
	mtx_curve_set_empty_array(MTX_CURVE(curve),rows);
	x_table = gtk_table_new(rows,1,FALSE);
	y_table = gtk_table_new(rows,1,FALSE);

	if (embedded)
	{
		x_parent = gtk_frame_new(NULL);
		y_parent = gtk_frame_new(NULL);
	}
	else
	{
		x_parent = glade_xml_get_widget(xml,"te_x_frame");
		y_parent = glade_xml_get_widget(xml,"te_y_frame");
	}
	gtk_container_set_border_width(GTK_CONTAINER(x_table),5);
	gtk_container_set_border_width(GTK_CONTAINER(y_table),5);
	gtk_container_add(GTK_CONTAINER(x_parent),x_table);
	gtk_container_add(GTK_CONTAINER(y_parent),y_table);

	x_mult = get_multiplier_f(firmware->te_params[table_num]->x_size);
	y_mult = get_multiplier_f(firmware->te_params[table_num]->y_size);
	x_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *));
	y_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *));
	for (i=0;i<rows;i++)
	{
		/* X Column */
		entry = gtk_entry_new();
		OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i));
		gtk_entry_set_width_chars(GTK_ENTRY(entry),7);
		OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i));
		g_array_insert_val(x_entries,i,entry);
		OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_X_));
		OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE));
		OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC));
		OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_lower)),g_free);
		OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_upper)),g_free);
		OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->x_fromecu_mult);
		OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->x_fromecu_add);
		OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->x_precision));
		OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->x_size));
		OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->x_page));
		OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->x_temp_dep));
		OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->x_use_color));
		OBJ_SET(entry,"force_color_update",GINT_TO_POINTER(firmware->te_params[table_num]->x_use_color));

		if(firmware->te_params[table_num]->x_temp_dep)
		{
			OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
			OBJ_SET_FULL(entry,"bind_to_list",g_strdup("temperature"),g_free);
			bind_to_lists_f(entry,"temperature");
		}

		offset = (i*x_mult) + firmware->te_params[table_num]->x_base;
		OBJ_SET(entry,"offset",GINT_TO_POINTER(offset));

		g_signal_connect(G_OBJECT(entry),"changed",
				G_CALLBACK(update_2d_curve),curve);
		g_signal_connect(G_OBJECT(entry),"changed",
				G_CALLBACK(entry_changed_handler_f),NULL);
		g_signal_connect(G_OBJECT(entry),"key_press_event",
				G_CALLBACK(key_event_f),NULL);
		g_signal_connect(G_OBJECT(entry),"key_release_event",
				G_CALLBACK(key_event_f),NULL);
		g_signal_connect(G_OBJECT(entry),"focus_out_event",
				G_CALLBACK(focus_out_handler_f),NULL);
		g_signal_connect(G_OBJECT(entry),"activate",
				G_CALLBACK(std_entry_handler_f),NULL);

		if (firmware->te_params[table_num]->reversed)
			gtk_table_attach(GTK_TABLE(x_table),entry,
					0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0);
		else
			gtk_table_attach(GTK_TABLE(x_table),entry,
					0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0);
		page = firmware->te_params[table_num]->x_page;
		ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry);
		if (!embedded)
			widget_list = g_list_prepend(widget_list,(gpointer)entry);

		update_widget(G_OBJECT(entry),NULL);

		/* Y Column */
		entry = gtk_entry_new();
		gtk_entry_set_width_chars(GTK_ENTRY(entry),7);
		OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i));
		g_array_insert_val(y_entries,i,entry);
		OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_Y_));
		OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE));
		OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC));
		OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_lower)),g_free);
		OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_upper)),g_free);
		OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->y_fromecu_mult);
		OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->y_fromecu_add);
		OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->y_precision));
		OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->y_size));
		OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->y_page));
		OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->y_temp_dep));
		OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->y_use_color));
		OBJ_SET(entry,"force_color_update",GINT_TO_POINTER(firmware->te_params[table_num]->y_use_color));

		if(firmware->te_params[table_num]->y_temp_dep)
		{
			OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
			OBJ_SET_FULL(entry,"bind_to_list",g_strdup("temperature"),g_free);
			bind_to_lists_f(entry,"temperature");
		}
		offset = (i*y_mult) + firmware->te_params[table_num]->y_base;
		OBJ_SET(entry,"offset",GINT_TO_POINTER(offset));

		g_signal_connect(G_OBJECT(entry),"changed",
				G_CALLBACK(update_2d_curve),curve);
		g_signal_connect(G_OBJECT(entry),"changed",
				G_CALLBACK(entry_changed_handler_f),NULL);
		g_signal_connect(G_OBJECT(entry),"key_press_event",
				G_CALLBACK(key_event_f),NULL);
		g_signal_connect(G_OBJECT(entry),"key_release_event",
				G_CALLBACK(key_event_f),NULL);
		g_signal_connect(G_OBJECT(entry),"focus_out_event",
				G_CALLBACK(focus_out_handler_f),NULL);
		g_signal_connect(G_OBJECT(entry),"activate",
				G_CALLBACK(std_entry_handler_f),NULL);

		if (firmware->te_params[table_num]->reversed)
			gtk_table_attach(GTK_TABLE(y_table),entry,
					0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0);
		else
			gtk_table_attach(GTK_TABLE(y_table),entry,
					0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0);
		page = firmware->te_params[table_num]->y_page;
		ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry);
		if (!embedded)
			widget_list = g_list_prepend(widget_list,(gpointer)entry);

		update_widget(G_OBJECT(entry),NULL);
	}
	/* Create the "LOCK" buttons */
	dummy = gtk_toggle_button_new_with_label("Unlocked");
	OBJ_SET(dummy,"axis",GINT_TO_POINTER(_X_));
	g_signal_connect(G_OBJECT(dummy),"toggled",
			G_CALLBACK(set_axis_locking),curve);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->x_lock);
	gtk_table_attach(GTK_TABLE(x_table),dummy,
			0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0);
	dummy = gtk_toggle_button_new_with_label("Unlocked");
	OBJ_SET(dummy,"axis",GINT_TO_POINTER(_Y_));
	g_signal_connect(G_OBJECT(dummy),"toggled",
			G_CALLBACK(set_axis_locking),curve);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->y_lock);
	gtk_table_attach(GTK_TABLE(y_table),dummy,
			0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0);

	mtx_curve_set_x_precision(MTX_CURVE(curve),firmware->te_params[table_num]->x_precision);
	mtx_curve_set_y_precision(MTX_CURVE(curve),firmware->te_params[table_num]->y_precision);

	mult = firmware->te_params[table_num]->x_fromecu_mult;
	adder = firmware->te_params[table_num]->x_fromecu_add;
	raw_lower = firmware->te_params[table_num]->x_raw_lower;
	raw_upper = firmware->te_params[table_num]->x_raw_upper;

	if ((mult) && (adder))
	{
		firmware->te_params[table_num]->x_2d_lower_limit = 
			(raw_lower * (*mult)) + (*adder);
		firmware->te_params[table_num]->x_2d_upper_limit = 
			(raw_upper * (*mult)) + (*adder);
	}
	else if (mult)
	{
		firmware->te_params[table_num]->x_2d_lower_limit = 
			raw_lower * (*mult);
		firmware->te_params[table_num]->x_2d_upper_limit = 
			raw_upper * (*mult);
	}
	else
	{
		firmware->te_params[table_num]->x_2d_lower_limit = raw_lower;
		firmware->te_params[table_num]->x_2d_upper_limit = raw_upper;
	}

	/* Y */
	mult = firmware->te_params[table_num]->y_fromecu_mult;
	adder = firmware->te_params[table_num]->y_fromecu_add;
	raw_lower = firmware->te_params[table_num]->y_raw_lower;
	raw_upper = firmware->te_params[table_num]->y_raw_upper;

	if ((mult) && (adder))
	{
		firmware->te_params[table_num]->y_2d_lower_limit = 
			(raw_lower * (*mult)) + (*adder);
		firmware->te_params[table_num]->y_2d_upper_limit = 
			(raw_upper * (*mult)) + (*adder);
	}
	else if (mult)
	{
		firmware->te_params[table_num]->y_2d_lower_limit = 
			raw_lower * (*mult);
		firmware->te_params[table_num]->y_2d_upper_limit = 
			raw_upper * (*mult);
	}
	else
	{
		firmware->te_params[table_num]->y_2d_lower_limit = raw_lower;
		firmware->te_params[table_num]->y_2d_upper_limit = raw_upper;
	}

	mtx_curve_set_hard_limits(MTX_CURVE(curve),
			firmware->te_params[table_num]->x_2d_lower_limit,
			firmware->te_params[table_num]->x_2d_upper_limit,
			firmware->te_params[table_num]->y_2d_lower_limit,
			firmware->te_params[table_num]->y_2d_upper_limit);

	/* One shot to get marker drawn. */
	create_value_change_watch_f(cdata->source,TRUE,"update_curve_marker",(gpointer)cdata);
	/* continuous to catch changes. */
	id = create_value_change_watch_f(cdata->source,FALSE,"update_curve_marker",(gpointer)cdata);
	OBJ_SET(curve,"marker_id",GINT_TO_POINTER(id));
	if (!embedded)
	{
		OBJ_SET(window,"widget_list",widget_list);
		OBJ_SET(window,"curve_list",curve_list);
		OBJ_SET(window,"x_entries",x_entries);
		OBJ_SET(window,"y_entries",y_entries);
	}
	/*
	else
	{
		OBJ_SET(parent,"widget_list",widget_list);
		OBJ_SET(parent,"curve_list",curve_list);
		OBJ_SET(parent,"x_entries",x_entries);
		OBJ_SET(parent,"y_entries",y_entries);
	}
	*/
	OBJ_SET(curve,"x_entries",x_entries);
	OBJ_SET(curve,"y_entries",y_entries);
	gtk_container_add(GTK_CONTAINER(curve_parent),curve);

	if (embedded)
		gtk_widget_show_all(curve);
	else
		gtk_widget_show_all(window);
	return TRUE;
}
Exemplo n.º 3
0
void
filter_expression_save_dlg(gpointer data)
{
	GtkWidget   *main_vb, *main_filter_save_hb, *filter_save_frame,
		    *filter_save_type_vb, *filter_save_type_hb, *entry_hb,
		    *bbox, *ok_bt, *cancel_bt, *help_bt, *filter_text_box,
		    *label_text_box;
 
	const char *expr;

	/* The filter requested */
	expr = gtk_entry_get_text(GTK_ENTRY(data));

	if (filter_save_frame_w != NULL) {
		/* There's already a "Filter Save" dialog box; reactivate it. */
		reactivate_window(filter_save_frame_w);
		return;
	}

	filter_save_frame_w = dlg_window_new("Wireshark: Save Filter");

	/* Container for each row of widgets */
	main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
	gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5);
	gtk_container_add(GTK_CONTAINER(filter_save_frame_w), main_vb);
	gtk_widget_show(main_vb);


	/* */
	main_filter_save_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
	gtk_container_add(GTK_CONTAINER(main_vb), main_filter_save_hb);
	gtk_widget_show(main_filter_save_hb);

	/* Filter Save frame */
	filter_save_frame = gtk_frame_new("Save Filter as...");
	gtk_box_pack_start(GTK_BOX(main_filter_save_hb), filter_save_frame,
	    TRUE, TRUE, 0);
	gtk_widget_show(filter_save_frame);

	filter_save_type_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
	gtk_container_set_border_width(GTK_CONTAINER(filter_save_type_vb), 3);
	gtk_container_add(GTK_CONTAINER(filter_save_frame),
	    filter_save_type_vb);
	gtk_widget_show(filter_save_type_vb);

	/* filter_save type row */
	filter_save_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
	gtk_container_add(GTK_CONTAINER(filter_save_type_vb),
	    filter_save_type_hb);
	gtk_widget_show(filter_save_type_hb);

	/* filter_save row */
	entry_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
	gtk_box_pack_start(GTK_BOX(filter_save_type_vb), entry_hb, FALSE,
	    FALSE, 0);
	gtk_widget_show(entry_hb);

	filter_text_box = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(entry_hb), filter_text_box, TRUE, TRUE, 0);
	g_signal_connect(filter_text_box, "changed", G_CALLBACK(filter_te_syntax_check_cb), NULL);
	g_signal_connect(filter_text_box, "key-press-event", G_CALLBACK (filter_string_te_key_pressed_cb), NULL);
	g_signal_connect(filter_save_frame_w, "key-press-event", G_CALLBACK (filter_parent_dlg_key_pressed_cb), NULL);

	gtk_entry_set_text(GTK_ENTRY(filter_text_box), expr);
	gtk_widget_show(filter_text_box);

	label_text_box = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(entry_hb), label_text_box, TRUE, TRUE, 0);
	gtk_entry_set_text(GTK_ENTRY(label_text_box), "Filter");
	gtk_widget_show(label_text_box);

	/* Button row */
	bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL,
	    GTK_STOCK_HELP, NULL);
	gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0);
	gtk_widget_show(bbox);

	ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
	g_signal_connect(ok_bt, "clicked", G_CALLBACK(filter_save_ok_cb),
	filter_save_frame_w);

	cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
	g_signal_connect(cancel_bt, "clicked", G_CALLBACK(filter_save_close_cb),
	filter_save_frame_w);

	help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
	g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb),
	(gpointer)HELP_FILTER_SAVE_DIALOG);

	g_object_set_data(G_OBJECT(filter_save_frame_w),
	    E_FILTER_SAVE_EXPR_KEY, filter_text_box);
	g_object_set_data(G_OBJECT(filter_save_frame_w),
	    E_FILTER_SAVE_LABEL_KEY, label_text_box);

	dlg_set_activate(label_text_box, ok_bt);

	/* Give the initial focus to the "offset" entry box. */
	gtk_widget_grab_focus(label_text_box);

	g_signal_connect(filter_save_frame_w, "delete_event",
	G_CALLBACK(window_delete_event_cb), NULL);
	g_signal_connect(filter_save_frame_w, "destroy",
	G_CALLBACK(filter_save_frame_destroy_cb), NULL);

	gtk_widget_show(filter_save_frame_w);
	window_present(filter_save_frame_w);
}
Exemplo n.º 4
0
GtkWidget *plugin_configure(GtkDialog *dialog)
{
	GtkWidget *label_language, *label_dir, *vbox;
	GtkWidget *combo, *check_type, *check_on_open, *check_msgwin, *check_toolbar, *check_editor_menu;
	GtkWidget *vbox_interface, *frame_interface, *label_interface;
	GtkWidget *vbox_behavior, *frame_behavior, *label_behavior;
#ifdef HAVE_ENCHANT_1_5
	GtkWidget *entry_dir, *hbox, *button, *image;
#endif

	vbox = gtk_vbox_new(FALSE, 6);

	check_toolbar = gtk_check_button_new_with_label(
		_("Show toolbar item to toggle spell checking"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_toolbar), sc_info->show_toolbar_item);

	check_editor_menu = gtk_check_button_new_with_label(
		_("Show editor menu item to show spelling suggestions"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_editor_menu),
		sc_info->show_editor_menu_item);

	check_msgwin = gtk_check_button_new_with_label(
		_("Print misspelled words and suggestions in the messages window"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_msgwin), sc_info->use_msgwin);

	vbox_interface = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox_interface), check_toolbar, FALSE, FALSE, 3);
	gtk_box_pack_start(GTK_BOX(vbox_interface), check_editor_menu, TRUE, TRUE, 3);
	gtk_box_pack_start(GTK_BOX(vbox_interface), check_msgwin, TRUE, TRUE, 3);

	label_interface = gtk_label_new(NULL);
	gtk_label_set_use_markup(GTK_LABEL(label_interface), TRUE);
	gtk_label_set_markup(GTK_LABEL(label_interface), _("<b>Interface</b>"));

	frame_interface = gtk_frame_new(NULL);
	gtk_frame_set_label_widget(GTK_FRAME(frame_interface), label_interface);
	gtk_container_add(GTK_CONTAINER(frame_interface), vbox_interface);
	gtk_box_pack_start(GTK_BOX(vbox), frame_interface, FALSE, FALSE, 3);


	check_type = gtk_check_button_new_with_label(_("Check spelling while typing"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_type), sc_info->check_while_typing);

	check_on_open = gtk_check_button_new_with_label(_("Check spelling when opening a document"));
	ui_widget_set_tooltip_text(check_on_open,
		_("Enabling this option will check every document after it is opened in Geany. "
		  "Reloading a document will also trigger a re-check."));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_on_open), sc_info->check_on_document_open);

	label_language = gtk_label_new(_("Language to use for the spell check:"));
	gtk_misc_set_alignment(GTK_MISC(label_language), 0, 0.5);

	combo = gtk_combo_box_text_new();
	populate_dict_combo(GTK_COMBO_BOX(combo));

	if (sc_info->dicts->len > 20)
		gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 3);
	else if (sc_info->dicts->len > 10)
		gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 2);

#ifdef HAVE_ENCHANT_1_5
	label_dir = gtk_label_new_with_mnemonic(_("_Directory to look for dictionary files:"));
	gtk_misc_set_alignment(GTK_MISC(label_dir), 0, 0.5);

	entry_dir = gtk_entry_new();
	ui_entry_add_clear_icon(GTK_ENTRY(entry_dir));
	gtk_label_set_mnemonic_widget(GTK_LABEL(label_dir), entry_dir);
	ui_widget_set_tooltip_text(entry_dir,
		_("Read additional dictionary files from this directory. "
		  "For now, this only works with myspell dictionaries."));
	if (! EMPTY(sc_info->dictionary_dir))
		gtk_entry_set_text(GTK_ENTRY(entry_dir), sc_info->dictionary_dir);

	button = gtk_button_new();
	g_signal_connect(button, "clicked",
		G_CALLBACK(dictionary_dir_button_clicked_cb), entry_dir);

	image = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON);
	gtk_container_add(GTK_CONTAINER(button), image);

	hbox = gtk_hbox_new(FALSE, 6);
	gtk_box_pack_start(GTK_BOX(hbox), entry_dir, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);

	g_object_set_data(G_OBJECT(dialog), "dict_dir", entry_dir);
#endif

	vbox_behavior = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox_behavior), check_type, FALSE, FALSE, 3);
	gtk_box_pack_start(GTK_BOX(vbox_behavior), check_on_open, TRUE, TRUE, 3);
	gtk_box_pack_start(GTK_BOX(vbox_behavior), label_language, TRUE, TRUE, 3);
	gtk_box_pack_start(GTK_BOX(vbox_behavior), combo, TRUE, TRUE, 3);
#ifdef HAVE_ENCHANT_1_5
	gtk_box_pack_start(GTK_BOX(vbox_behavior), label_dir, TRUE, TRUE, 3);
	gtk_box_pack_start(GTK_BOX(vbox_behavior), hbox, TRUE, TRUE, 3);
#endif

	label_behavior = gtk_label_new(NULL);
	gtk_label_set_use_markup(GTK_LABEL(label_behavior), TRUE);
	gtk_label_set_markup(GTK_LABEL(label_behavior), _("<b>Behavior</b>"));

	frame_behavior = gtk_frame_new(NULL);
	gtk_frame_set_label_widget(GTK_FRAME(frame_behavior), label_behavior);
	gtk_container_add(GTK_CONTAINER(frame_behavior), vbox_behavior);
	gtk_box_pack_start(GTK_BOX(vbox), frame_behavior, FALSE, FALSE, 3);

	g_object_set_data(G_OBJECT(dialog), "combo", combo);
	g_object_set_data(G_OBJECT(dialog), "check_type", check_type);
	g_object_set_data(G_OBJECT(dialog), "check_on_open", check_on_open);
	g_object_set_data(G_OBJECT(dialog), "check_msgwin", check_msgwin);
	g_object_set_data(G_OBJECT(dialog), "check_toolbar", check_toolbar);
	g_object_set_data(G_OBJECT(dialog), "check_editor_menu", check_editor_menu);
	g_signal_connect(dialog, "response", G_CALLBACK(configure_response_cb), NULL);

	gtk_widget_show_all(vbox);

	return vbox;
}
Exemplo n.º 5
0
GtkWidget*      initGTKStuff(int *argc, char ***argv) {
  //  fprintf(stderr,"explicit threads init %d\n", XInitThreads());
  gtk_init(argc, argv);
  /* Create a new window */
  GtkWidget* window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window), "Java Plugin Host");

  /* Here we connect the "destroy" event to a signal handler */ 
  gtk_signal_connect (GTK_OBJECT (window), "destroy",
                      GTK_SIGNAL_FUNC (gtk_main_quit), NULL);

  gtk_widget_set_usize(window, 300, 400);
  /* Sets the border width of the window. */
  gtk_container_set_border_width (GTK_CONTAINER (window), 10);
  
  /* Create a Frame */
  GtkWidget* frame = gtk_frame_new(NULL);
   /* Set the style of the frame */
  gtk_frame_set_shadow_type( GTK_FRAME(frame), GTK_SHADOW_ETCHED_OUT);
  gtk_container_add(GTK_CONTAINER(window), frame);
  /////////
  gtk_signal_connect(GTK_OBJECT(window), "destroy",
                     GTK_SIGNAL_FUNC(gtk_main_quit),
                     NULL);
  gtk_signal_connect(GTK_OBJECT(window), "delete-event",
                     GTK_SIGNAL_FUNC(gtk_false),
                     NULL);
  /* Button initialization */
  GtkWidget* button1 = gtk_button_new_with_label ("Start JVM");
  GtkWidget* button2 = gtk_button_new_with_label ("Stop JVM");
  GtkWidget* button3 = gtk_button_new_with_label ("Close application");
  GtkWidget* button4 = gtk_button_new_with_label ("Register native window");
  GtkWidget* button5 = gtk_button_new_with_label ("Test registered window");
  GtkWidget* button6 = gtk_button_new_with_label ("Unregister window");
  GtkWidget* button7 = gtk_button_new_with_label ("Enable/Disable system capabilities");
  GtkWidget* button8 = gtk_button_new_with_label ("Attach new native thread");
  GtkWidget* button9 = gtk_button_new_with_label ("Get WF description");  
  GtkWidget* button10 = gtk_button_new_with_label ("Register test extension");   
  GtkWidget* button11 = gtk_button_new_with_label ("Create/Remove test peer");
  GtkWidget* button12 = gtk_button_new_with_label ("Test Java/native locking ability");
  GtkWidget* button13 = gtk_button_new_with_label ("Show/hide Java console");
  

  gtk_signal_connect (GTK_OBJECT (button1), "clicked",
                        GTK_SIGNAL_FUNC (b1_handler), NULL);
  gtk_signal_connect (GTK_OBJECT (button2), "clicked",
                        GTK_SIGNAL_FUNC (b2_handler), NULL);  
  gtk_signal_connect_object (GTK_OBJECT (button3), "clicked",
                             GTK_SIGNAL_FUNC (gtk_main_quit),
                             GTK_OBJECT (window));
  gtk_signal_connect_object (GTK_OBJECT (button4), "clicked",
                             GTK_SIGNAL_FUNC (b4_handler),
                             GTK_OBJECT (window));  
  gtk_signal_connect_object (GTK_OBJECT (button5), "clicked",
                             GTK_SIGNAL_FUNC (b5_handler),
                             GTK_OBJECT (window));
  gtk_signal_connect_object (GTK_OBJECT (button6), "clicked",
                             GTK_SIGNAL_FUNC (b6_handler),
                             GTK_OBJECT (window));
  gtk_signal_connect_object (GTK_OBJECT (button7), "clicked",
                             GTK_SIGNAL_FUNC (b7_handler),
                             GTK_OBJECT (window));
  gtk_signal_connect_object (GTK_OBJECT (button8), "clicked",
                             GTK_SIGNAL_FUNC (b8_handler),
                             GTK_OBJECT (window));
  gtk_signal_connect_object (GTK_OBJECT (button9), "clicked",
                             GTK_SIGNAL_FUNC (b9_handler),
                             GTK_OBJECT (window));
  gtk_signal_connect_object (GTK_OBJECT (button10), "clicked",
                             GTK_SIGNAL_FUNC (b10_handler),
                             GTK_OBJECT (window));
  gtk_signal_connect_object (GTK_OBJECT (button11), "clicked",
                             GTK_SIGNAL_FUNC (b11_handler),
                             GTK_OBJECT (window));
  gtk_signal_connect_object (GTK_OBJECT (button12), "clicked",
                             GTK_SIGNAL_FUNC (b12_handler),
                             GTK_OBJECT (window));
  gtk_signal_connect_object (GTK_OBJECT (button13), "clicked",
                             GTK_SIGNAL_FUNC (b13_handler),
                             GTK_OBJECT (window));
  GtkWidget* vbox1 = gtk_vbox_new (FALSE, 4);
  gtk_box_pack_start (GTK_BOX (vbox1), button1,  TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox1), button2,  TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox1), button13, TRUE, TRUE, 0);  
  gtk_box_pack_start (GTK_BOX (vbox1), button10, TRUE, TRUE, 0);  
  gtk_box_pack_start (GTK_BOX (vbox1), button4,  TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox1), button6,  TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox1), button7,  TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox1), button11, TRUE, TRUE, 0);  
  gtk_box_pack_start (GTK_BOX (vbox1), button5,  TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox1), button8,  TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox1), button9,  TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox1), button12, TRUE, TRUE, 0);  
  gtk_box_pack_start (GTK_BOX (vbox1), button3,  TRUE, TRUE, 0);  
  gtk_container_add(GTK_CONTAINER(frame), vbox1);
  ///////////
  gtk_widget_show(button1);
  gtk_widget_show(button2);
  gtk_widget_show(button3);
  gtk_widget_show(button4);
  gtk_widget_show(button5);
  gtk_widget_show(button6);
  gtk_widget_show(button7);
  gtk_widget_show(button8);
  gtk_widget_show(button9);
  gtk_widget_show(button10);
  gtk_widget_show(button11);
  gtk_widget_show(button12);
  gtk_widget_show(button13);  
  gtk_widget_show(vbox1);
  gtk_widget_show(frame);
  /* Display the window */
  gtk_widget_show (window);

  /* another window to play  with JDK */
  GtkWidget* window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_widget_set_usize(window1, 300, 300);
  GtkWidget* frame1 = gtk_frame_new(NULL);
  gtk_frame_set_shadow_type( GTK_FRAME(frame1), GTK_SHADOW_ETCHED_OUT);
  gtk_container_add(GTK_CONTAINER(window1), frame1);
  gtk_widget_show (frame1);
  gtk_widget_show (window1);
  topLevel = window1;
  return window1;
}
Exemplo n.º 6
0
void createMPQCOptimization(GtkWidget *box)
{
	GtkWidget* frame;
	GtkWidget* vboxFrame;
	GtkWidget* comboMaxIterations = NULL;
	GtkWidget* entryMaxIterations = NULL;
	GtkWidget *table = NULL;
	gint i;
	GtkWidget *buttonSinglePoint = NULL;
	GtkWidget *buttonOptimization = NULL;
	GtkWidget *button = NULL;
	static ButtonTypes buttonTypes[] = {SINGLEPOINT, OPTIMIZE};

	table = gtk_table_new(3,3,FALSE);

	frame = gtk_frame_new (_("Type of calcul"));
	gtk_widget_show (frame);
	gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 3);
	gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5);

	vboxFrame = gtk_vbox_new (FALSE, 3);
	gtk_widget_show (vboxFrame);
	gtk_container_add (GTK_CONTAINER (frame), vboxFrame);

	gtk_box_pack_start (GTK_BOX (vboxFrame), table, TRUE, TRUE, 0);

	i = 0;
	button = gtk_radio_button_new_with_label(NULL, _("Single point"));
	gtk_table_attach(GTK_TABLE(table),button,0,0+1,i,i+1,
		(GtkAttachOptions)	(GTK_FILL | GTK_EXPAND),
		(GtkAttachOptions)	(GTK_FILL | GTK_EXPAND),
                  3,3);
	buttonSinglePoint = button;
	g_object_set_data(G_OBJECT (buttonSinglePoint), "Type", &buttonTypes[0]);
	g_signal_connect(G_OBJECT(buttonSinglePoint),"clicked", G_CALLBACK(activateRadioButton),NULL);
	i = 1;
	button = gtk_radio_button_new_with_label(gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)), _("Optimization"));
	gtk_table_attach(GTK_TABLE(table),button,0,0+1,i,i+1,
		(GtkAttachOptions)	(GTK_FILL | GTK_EXPAND),
		(GtkAttachOptions)	(GTK_FILL | GTK_EXPAND),
                  3,3);
	buttonOptimization = button;
	g_object_set_data(G_OBJECT (buttonOptimization), "Type", &buttonTypes[1]);
	g_signal_connect(G_OBJECT(buttonOptimization),"clicked", G_CALLBACK(activateRadioButton),NULL);

	button = gtk_check_button_new_with_label (_("Transition state"));
	gtk_table_attach(GTK_TABLE(table),button,1,1+2,i,i+1,
		(GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
		(GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
                  3,3);
	gtk_widget_set_sensitive(button, mpqcMpqc.optimize);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
	g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(activateTransButton),NULL);
	g_object_set_data(G_OBJECT (buttonOptimization), "ButtonTransition", button);
	g_object_set_data(G_OBJECT (buttonSinglePoint), "ButtonTransition", button);

	i = 2;
	comboMaxIterations = addMPQCMaxIterationsToTable(table, i, buttonSinglePoint, buttonOptimization);
	entryMaxIterations = GTK_BIN(comboMaxIterations)->child;
	g_signal_connect(G_OBJECT(entryMaxIterations),"changed", G_CALLBACK(changedEntryMaxIterations),NULL);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (buttonSinglePoint), !mpqcMpqc.optimize);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (buttonOptimization), mpqcMpqc.optimize);
	g_object_set_data(G_OBJECT (box), "ButtonSinglePoint", buttonSinglePoint);
	g_object_set_data(G_OBJECT (box), "ButtonOptimization", buttonOptimization);

}
Exemplo n.º 7
0
/*
 *	initialization/finalization:
 */
static GObject *
_gtk_user_list_dialog_constructor(GType type, guint n_construct_properties, GObjectConstructParam *construct_params)
{
	GObject *object;
	GtkWidget *hbox;
	GtkWidget *vbox;
	GtkWidget *frame;
	GtkWidget *align;
	GtkWidget *scrolled;
	GtkUserListDialogPrivate *priv;

	object = G_OBJECT_CLASS(gtk_user_list_dialog_parent_class)->constructor(type, n_construct_properties, construct_params);

	gtk_widget_push_composite_child();

	priv = GTK_USER_LIST_DIALOG(object)->priv;

	/* create main box */
	hbox = gtk_hbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(gtk_deletable_dialog_get_content_area(GTK_DELETABLE_DIALOG(object))), hbox);

	/* create frame */
	frame = gtk_frame_new(NULL);
	gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 2);

	vbox = gtk_vbox_new(FALSE, 5);
	gtk_container_add(GTK_CONTAINER(frame), vbox);

	hbox = gtk_hbox_new(FALSE, 5);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 2);

	vbox = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 2);

	/* dialog message */
	align = gtk_alignment_new(0, 0, 0, 0);
	gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, TRUE, 10);

	priv->label_message = gtk_label_new("");
	gtk_container_add(GTK_CONTAINER(align), priv->label_message);

	/* create tree */
	scrolled = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);

	priv->tree = _gtk_user_list_dialog_create_tree(GTK_WIDGET(object));
	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), priv->tree);

	/* label */
	priv->label_count = gtk_label_new(NULL);
	gtk_box_pack_start(GTK_BOX(vbox), priv->label_count, FALSE, TRUE, 2);

	/* show widgets */
	gtk_widget_show_all(gtk_deletable_dialog_get_content_area(GTK_DELETABLE_DIALOG(object)));
	gtk_widget_set_visible(priv->label_message, FALSE);

	gtk_widget_push_composite_child();

	return object;
}
Exemplo n.º 8
0
GtkWidget *
create_canvas_fifteen (void)
{
	GtkWidget *vbox;
	GtkWidget *frame;
	GtkWidget *canvas;
	GtkWidget *button;
	GooCanvasItem **board;
	GooCanvasItem *root, *rect G_GNUC_UNUSED, *text;
	int i, x, y;
	char buf[20];

	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
	g_object_set (vbox, "margin", 4, NULL);
	gtk_widget_show (vbox);

	frame = gtk_frame_new (NULL);
	gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
	gtk_box_pack_start (GTK_BOX (vbox), frame);
	gtk_widget_set_halign (frame, GTK_ALIGN_FILL);
	gtk_widget_set_valign (frame, GTK_ALIGN_FILL);
	gtk_widget_set_hexpand (frame, TRUE);
	gtk_widget_set_vexpand (frame, TRUE);
	gtk_widget_show (frame);

	g_object_set (frame,
		      "halign", GTK_ALIGN_CENTER,
		      "valign", GTK_ALIGN_CENTER,
		      NULL);

	/* Create the canvas and board */

	canvas = goo_canvas_new ();
	g_object_set (G_OBJECT (canvas),
		      "automatic-bounds", TRUE,
		      "bounds-from-origin", FALSE,
		      NULL);
	root = goo_canvas_get_root_item (GOO_CANVAS (canvas));

	gtk_widget_set_size_request (canvas,
				     PIECE_SIZE * 4 + 1, PIECE_SIZE * 4 + 1);
#if 0
	goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0,
			       PIECE_SIZE * 4 + 1, PIECE_SIZE * 4 + 1);
#endif
	gtk_container_add (GTK_CONTAINER (frame), canvas);
	gtk_widget_show (canvas);

	board = g_new (GooCanvasItem *, 16);
	g_object_set_data (G_OBJECT (canvas), "board", board);
	g_signal_connect (canvas, "destroy",
			  G_CALLBACK (free_stuff),
			  board);

	for (i = 0; i < 15; i++) {
		y = i / 4;
		x = i % 4;

		board[i] = goo_canvas_group_new (root, NULL);
		goo_canvas_item_translate (board[i], x * PIECE_SIZE,
					   y * PIECE_SIZE);
		setup_item_signals (board[i]);

		rect = goo_canvas_rect_new (board[i], 0, 0,
					    PIECE_SIZE, PIECE_SIZE,
					    "fill_color", get_piece_color (i),
					    "stroke_color", "black",
					    "line-width", 1.0,
					    NULL);

		sprintf (buf, "%d", i + 1);

		text = goo_canvas_text_new (board[i], buf,
					    PIECE_SIZE / 2.0, PIECE_SIZE / 2.0,
					    -1, GOO_CANVAS_ANCHOR_CENTER,
					    "font", "Sans bold 24",
					    "fill_color", "black",
					    NULL);

		g_object_set_data (G_OBJECT (board[i]), "text", text);

		g_object_set_data (G_OBJECT (board[i]), "piece_num", GINT_TO_POINTER (i));
		g_object_set_data (G_OBJECT (board[i]), "piece_pos", GINT_TO_POINTER (i));

	}

	board[15] = NULL;

	/* Scramble button */

	button = gtk_button_new_with_label ("Scramble");
	gtk_box_pack_start (GTK_BOX (vbox), button);
	g_object_set_data (G_OBJECT (button), "board", board);
	g_signal_connect (button, "clicked",
			  G_CALLBACK (scramble),
			  canvas);
	gtk_widget_show (button);

	return vbox;
}
Exemplo n.º 9
0
void
chmod_dialog (gpointer data)
{
  GtkWidget *tempwid, *dialog, *hbox, *vbox;
  GList * templist, * filelist;
  gftp_window_data * wdata;
  gftp_file * tempfle;
  int num;

  wdata = data;
  if (!check_status (_("Chmod"), wdata, gftpui_common_use_threads (wdata->request), 0, 1, wdata->request->chmod != NULL))
    return;

#if GTK_MAJOR_VERSION == 1
  dialog = gtk_dialog_new ();
  gtk_window_set_title (GTK_WINDOW (dialog), _("Chmod"));
  gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area),
                              5);
  gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dialog)->action_area), TRUE);
#else
  dialog = gtk_dialog_new_with_buttons (_("Chmod"), NULL, 0,
                                        GTK_STOCK_CANCEL,
                                        GTK_RESPONSE_CANCEL,
                                        GTK_STOCK_OK,
                                        GTK_RESPONSE_OK,
                                        NULL);
#endif
  gtk_window_set_wmclass (GTK_WINDOW(dialog), "Chmod", "gFTP");
  gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
  gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 5);
  gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 10);
  gtk_widget_realize (dialog);

  if (gftp_icon != NULL)
    {
      gdk_window_set_icon (dialog->window, NULL, gftp_icon->pixmap,
                           gftp_icon->bitmap);
      gdk_window_set_icon_name (dialog->window, gftp_version);
    }

  tempwid = gtk_label_new (_("You can now adjust the attributes of your file(s)\nNote: Not all ftp servers support the chmod feature"));
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), tempwid, FALSE,
		      FALSE, 0);
  gtk_widget_show (tempwid);

  hbox = gtk_hbox_new (TRUE, 5);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE,
		      0);
  gtk_widget_show (hbox);

  tempwid = gtk_frame_new (_("Special"));
  gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0);
  gtk_widget_show (tempwid);

  vbox = gtk_vbox_new (TRUE, 5);
  gtk_container_add (GTK_CONTAINER (tempwid), vbox);
  gtk_widget_show (vbox);

  suid = gtk_check_button_new_with_label (_("SUID"));
  gtk_box_pack_start (GTK_BOX (vbox), suid, FALSE, FALSE, 0);
  gtk_widget_show (suid);

  sgid = gtk_check_button_new_with_label (_("SGID"));
  gtk_box_pack_start (GTK_BOX (vbox), sgid, FALSE, FALSE, 0);
  gtk_widget_show (sgid);

  sticky = gtk_check_button_new_with_label (_("Sticky"));
  gtk_box_pack_start (GTK_BOX (vbox), sticky, FALSE, FALSE, 0);
  gtk_widget_show (sticky);

  tempwid = gtk_frame_new (_("User"));
  gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0);
  gtk_widget_show (tempwid);

  vbox = gtk_vbox_new (TRUE, 5);
  gtk_container_add (GTK_CONTAINER (tempwid), vbox);
  gtk_widget_show (vbox);

  ur = gtk_check_button_new_with_label (_("Read"));
  gtk_box_pack_start (GTK_BOX (vbox), ur, FALSE, FALSE, 0);
  gtk_widget_show (ur);

  uw = gtk_check_button_new_with_label (_("Write"));
  gtk_box_pack_start (GTK_BOX (vbox), uw, FALSE, FALSE, 0);
  gtk_widget_show (uw);

  ux = gtk_check_button_new_with_label (_("Execute"));
  gtk_box_pack_start (GTK_BOX (vbox), ux, FALSE, FALSE, 0);
  gtk_widget_show (ux);

  tempwid = gtk_frame_new (_("Group"));
  gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0);
  gtk_widget_show (tempwid);

  vbox = gtk_vbox_new (TRUE, 5);
  gtk_container_add (GTK_CONTAINER (tempwid), vbox);
  gtk_widget_show (vbox);

  gr = gtk_check_button_new_with_label (_("Read"));
  gtk_box_pack_start (GTK_BOX (vbox), gr, FALSE, FALSE, 0);
  gtk_widget_show (gr);

  gw = gtk_check_button_new_with_label (_("Write"));
  gtk_box_pack_start (GTK_BOX (vbox), gw, FALSE, FALSE, 0);
  gtk_widget_show (gw);

  gx = gtk_check_button_new_with_label (_("Execute"));
  gtk_box_pack_start (GTK_BOX (vbox), gx, FALSE, FALSE, 0);
  gtk_widget_show (gx);

  tempwid = gtk_frame_new (_("Other"));
  gtk_box_pack_start (GTK_BOX (hbox), tempwid, FALSE, FALSE, 0);
  gtk_widget_show (tempwid);

  vbox = gtk_vbox_new (TRUE, 5);
  gtk_container_add (GTK_CONTAINER (tempwid), vbox);
  gtk_widget_show (vbox);

  or = gtk_check_button_new_with_label (_("Read"));
  gtk_box_pack_start (GTK_BOX (vbox), or, FALSE, FALSE, 0);
  gtk_widget_show (or);

  ow = gtk_check_button_new_with_label (_("Write"));
  gtk_box_pack_start (GTK_BOX (vbox), ow, FALSE, FALSE, 0);
  gtk_widget_show (ow);

  ox = gtk_check_button_new_with_label (_("Execute"));
  gtk_box_pack_start (GTK_BOX (vbox), ox, FALSE, FALSE, 0);
  gtk_widget_show (ox);

#if GTK_MAJOR_VERSION == 1
  tempwid = gtk_button_new_with_label (_("OK"));
  GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid,
		      TRUE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
		      GTK_SIGNAL_FUNC (dochmod), (gpointer) wdata);
  gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked",
			     GTK_SIGNAL_FUNC (gtk_widget_destroy),
			     GTK_OBJECT (dialog));
  gtk_widget_grab_default (tempwid);
  gtk_widget_show (tempwid);

  tempwid = gtk_button_new_with_label (_("  Cancel  "));
  GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid,
		      TRUE, TRUE, 0);
  gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked",
			     GTK_SIGNAL_FUNC (gtk_widget_destroy),
			     GTK_OBJECT (dialog));
  gtk_widget_show (tempwid);
#else
  g_signal_connect (GTK_OBJECT (dialog), "response",
                    G_CALLBACK (chmod_action), wdata);
#endif

  if (IS_ONE_SELECTED (wdata))
    {
      filelist = wdata->files;
      templist = gftp_gtk_get_list_selection (wdata);
      num = 0;
      templist = get_next_selection (templist, &filelist, &num);
      tempfle = filelist->data;

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (suid),
                                    tempfle->st_mode & S_ISUID);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ur),
                                    tempfle->st_mode & S_IRUSR);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (uw),
                                    tempfle->st_mode & S_IWUSR);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ux),
                                    tempfle->st_mode & S_IXUSR);

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sgid),
                                    tempfle->st_mode & S_ISGID);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gr),
                                    tempfle->st_mode & S_IRGRP);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gw),
                                    tempfle->st_mode & S_IWGRP);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gx),
                                    tempfle->st_mode & S_IXGRP);

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sticky),
                                    tempfle->st_mode & S_ISVTX);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (or),
                                    tempfle->st_mode & S_IROTH);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ow),
                                    tempfle->st_mode & S_IWOTH);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ox),
                                    tempfle->st_mode & S_IXOTH);
    }
  gtk_widget_show (dialog);
}
Exemplo n.º 10
0
/*!
  \brief Creates the lookuptables configurator window (MS1 FW's only)
  \param widget is unused
  \param data is unused
  \returns TRUE on success
  */
G_MODULE_EXPORT gboolean lookuptables_configurator(GtkWidget *widget, gpointer data)
{
	static gboolean ltc_created = FALSE;
	static GtkWidget * lookuptables_config_window = NULL;
	GtkListStore *store = NULL;
	GtkTreeStore *combostore = NULL;
	GtkTreeIter iter;
	GtkTreeIter per_iter;
	GtkTreeIter sys_iter;
	GtkCellRenderer *renderer = NULL;
	GtkTreeViewColumn *column = NULL;
	GtkWidget * vbox = NULL;
	GtkWidget * tree = NULL;
	GtkWidget * frame = NULL;
	GtkWidget * label = NULL;
	ListElement *element = NULL;
	ConfigFile *cfgfile = NULL;
	GArray *classes = NULL;
	GList *p_list = NULL;
	GList *s_list = NULL;
	gchar * tmpbuf = NULL;
	gchar ** vector = NULL;
	gchar ** tmpvector = NULL;
	Firmware_Details *firmware = NULL;

	firmware = (Firmware_Details *)DATA_GET(global_data,"firmware");

	if ((ltc_created) && (ltc_visible))
		return TRUE;
	if ((ltc_created) && (!ltc_visible))
	{
		gtk_widget_show_all(lookuptables_config_window);
		return TRUE;
	}
	else	/* i.e.  NOT created,  build it */
	{
		lookuptables_config_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
		gtk_window_set_title(GTK_WINDOW(lookuptables_config_window),_("MegaTunix LookupTables"));
		gtk_window_set_default_size(GTK_WINDOW(lookuptables_config_window),300,200);
		vbox = gtk_vbox_new(FALSE,0);
		gtk_container_add(GTK_CONTAINER(lookuptables_config_window),vbox);
		gtk_container_set_border_width(GTK_CONTAINER(vbox),5);
		g_signal_connect(G_OBJECT(lookuptables_config_window),"delete_event", G_CALLBACK(lookuptables_configurator_hide),NULL);

		ltc_created = TRUE;
		ltc_visible = TRUE;
		frame = gtk_frame_new("MegaTunix LookupTables");
		gtk_box_pack_start (GTK_BOX(vbox),frame,TRUE,TRUE,5);
		vbox = gtk_vbox_new(FALSE,0);
		gtk_container_add(GTK_CONTAINER(frame),vbox);
		label = gtk_label_new(NULL);
		gtk_label_set_markup(GTK_LABEL(label),_(" Click on the <i>LookupTable Filename</i> and press <b><u> Enter </u></b> to change "));
		gtk_box_pack_start(GTK_BOX(vbox),label,TRUE,TRUE,5);

		store = gtk_list_store_new(N_COLS,	/* total cols */
				G_TYPE_STRING, /* int name */
				G_TYPE_STRING, /* filename  combo*/
				G_TYPE_BOOLEAN,/* View/Edit */
				G_TYPE_BOOLEAN); /* change */

		combostore = gtk_tree_store_new(1,G_TYPE_STRING);/* lookuptable filename */

		gtk_tree_store_append(combostore,&per_iter,NULL);
		gtk_tree_store_append(combostore,&sys_iter,NULL);
		gtk_tree_store_set(combostore,&per_iter,
				0,"Personal", -1);
		gtk_tree_store_set(combostore,&sys_iter,
				0,"System", -1);
		vector = get_files((const gchar *)DATA_GET(global_data,"project_name"),LOOKUPTABLES_DATA_DIR,"inc",&classes);
		for (guint i=0;i<g_strv_length(vector);i++)
		{
			tmpvector = g_strsplit(vector[i],PSEP,-1);
			if (g_array_index(classes,FileClass,i) == PERSONAL)
			{
				element = (ListElement *)g_new0(ListElement, 1);
				element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
				p_list = g_list_append(p_list,element);
			}
			if (g_array_index(classes,FileClass,i) == SYSTEM)
			{
				element = (ListElement *)g_new0(ListElement, 1);
				element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
				s_list = g_list_append(s_list,element);
			}
			g_strfreev(tmpvector);
		}
		g_strfreev(vector);
		g_array_free(classes,TRUE);
		p_list = g_list_sort(p_list,list_sort);
		s_list = g_list_sort(s_list,list_sort);
		for (guint i=0;i<g_list_length(p_list);i++)
		{
			gtk_tree_store_append(combostore,&iter,&per_iter);
			element = (ListElement *)g_list_nth_data(p_list,i);
			gtk_tree_store_set(combostore,&iter,
					0,element->name,
					-1);
		}
		for (guint i=0;i<g_list_length(s_list);i++)
		{
			gtk_tree_store_append(combostore,&iter,&sys_iter);
			element = (ListElement *)g_list_nth_data(s_list,i);
			gtk_tree_store_set(combostore,&iter,
					0,element->name,
					-1);
		}
		g_list_foreach(p_list,free_element,NULL);
		g_list_foreach(s_list,free_element,NULL);
		g_list_free(p_list);
		g_list_free(s_list);

		cfgfile = cfg_open_file(firmware->profile_filename);
		if (!cfgfile)
			return FALSE;
		cfg_read_string(cfgfile,"lookuptables","tables",&tmpbuf);
		vector = g_strsplit(tmpbuf,",",-1);
		g_free(tmpbuf);
		for (guint i=0;i<g_strv_length(vector);i++)
		{
			cfg_read_string(cfgfile,"lookuptables",vector[i],&tmpbuf);
			gtk_list_store_append(store,&iter);
			gtk_list_store_set(store,&iter,
					INTERNAL_NAME_COL,vector[i],
					FILENAME_COL,tmpbuf,
					VIEW_EDIT_COL,FALSE,
					-1);
			g_free(tmpbuf);
		}
		g_strfreev(vector);

		tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
		gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree),TRUE);
		gtk_box_pack_start(GTK_BOX(vbox),tree,TRUE,TRUE,0);
		renderer = gtk_cell_renderer_text_new();
		column = gtk_tree_view_column_new_with_attributes("Internal Table Name",renderer,"text",INTERNAL_NAME_COL,NULL);
		gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);

		renderer = gtk_cell_renderer_combo_new();
		g_object_set(G_OBJECT(renderer),"has-entry",FALSE,"editable",TRUE,"model",combostore,"text-column",0,"style",PANGO_STYLE_ITALIC,NULL);
		g_signal_connect(G_OBJECT(renderer),"changed", G_CALLBACK(lookuptable_changed),store);
//		g_signal_connect(G_OBJECT(renderer),"editing-started", G_CALLBACK(editing_started),store);
		column = gtk_tree_view_column_new_with_attributes("LookupTable Filename",renderer,"text",FILENAME_COL,NULL);
		gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);

		/*		renderer = gtk_cell_renderer_toggle_new();
				column = gtk_tree_view_column_new_with_attributes("View/Edit",renderer,"active",VIEW_EDIT_COL,NULL);
				gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
		 */
		gtk_window_set_transient_for(GTK_WINDOW(lookuptables_config_window),GTK_WINDOW(lookup_widget("main_window")));
		gtk_widget_show_all (lookuptables_config_window);
		gtk_tree_view_columns_autosize( GTK_TREE_VIEW(tree));
		gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree),GTK_TREE_VIEW_GRID_LINES_BOTH);
//		g_signal_connect(G_OBJECT(tree),"row-activated", G_CALLBACK(row_activated),NULL);
	}
	return TRUE;
}
Exemplo n.º 11
0
/*****
 *
 * Main CTK widget creation.
 *
 */
GtkWidget* ctk_clocks_new(NvCtrlAttributeHandle *handle,
                          CtkConfig *ctk_config,
                          CtkEvent *ctk_event)
{
    GObject *object;
    CtkClocks *ctk_object;
    GtkObject *adjustment;
    GtkWidget *alignment;
    GtkWidget *scale;
    CtkDropDownMenu *menu;

    GtkWidget *label;   

    GtkWidget *frame;
    GtkWidget *banner;
    GtkWidget *hbox;
    GtkWidget *vbox;


    ReturnStatus ret;  /* NvCtrlxxx function return value */
    int value, i = 0;
    int clocks_2D;
    NVCTRLAttributeValidValuesRec ranges_2D;
    NVCTRLAttributeValidValuesRec range_detection;
    int clocks_3D;
    NVCTRLAttributeValidValuesRec ranges_3D;

    Bool overclocking_enabled;
    Bool auto_detection_available = FALSE;
    Bool probing_optimal = FALSE;
    Bool can_access_2d_clocks;
    Bool can_access_3d_clocks;
   

    /* Make sure we have a handle */

    g_return_val_if_fail(handle != NULL, NULL);

    /* If we can't query the overclocking state, don't load the page */

    ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_OVERCLOCKING_STATE,
                             &value);
    if ( ret != NvCtrlSuccess )
        return NULL;
    overclocking_enabled =
        (value==NV_CTRL_GPU_OVERCLOCKING_STATE_MANUAL)?True:False;
   
    /* Check if overclocking is busy */
    
    if ( overclocking_enabled ) {
        ret = NvCtrlGetValidAttributeValues(handle,
                                 NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION,
                                 &range_detection);
        if ( ret == NvCtrlSuccess ) {
            ret = NvCtrlGetAttribute(handle,
                                     NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE,
                                     &value);
            if ( ret != NvCtrlSuccess )
                return NULL;
            probing_optimal =
                (value == NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY);
            auto_detection_available = TRUE;
        }
    }

    /* Can we access the 2D clocks? */

    can_access_2d_clocks = True;
    ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_2D_CLOCK_FREQS, &clocks_2D);
    if ( ret != NvCtrlSuccess )
        can_access_2d_clocks = False;
    ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GPU_2D_CLOCK_FREQS,
                                        &ranges_2D);
    if ( ret != NvCtrlSuccess )
        can_access_2d_clocks = False;

    /* Can we access the 3D clocks? */

    can_access_3d_clocks = True;
    ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_3D_CLOCK_FREQS, &clocks_3D);
    if ( ret != NvCtrlSuccess )
        can_access_3d_clocks = False;
    ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GPU_3D_CLOCK_FREQS,
                                        &ranges_3D);
    if ( ret != NvCtrlSuccess )
        can_access_3d_clocks = False;

    /* If we can't access either of the clocks, don't load the page */

    if ( !can_access_2d_clocks && !can_access_3d_clocks )
        return NULL;

    /* Create the ctk object */

    object = g_object_new(CTK_TYPE_CLOCKS, NULL);
    ctk_object = CTK_CLOCKS(object);

    /* Cache the handle and configuration */

    ctk_object->handle               = handle;
    ctk_object->ctk_config           = ctk_config;
    ctk_object->overclocking_enabled = overclocking_enabled;
    ctk_object->auto_detection_available  = auto_detection_available;
    ctk_object->probing_optimal      = probing_optimal;

    /* Create the Clock menu widget */

    menu = (CtkDropDownMenu *)
        ctk_drop_down_menu_new(CTK_DROP_DOWN_MENU_FLAG_READONLY);
    i = 0;
        
    if ( can_access_2d_clocks ) {
            ctk_drop_down_menu_append_item(menu, "2D Clock Frequencies", i++);
    }

    if ( can_access_3d_clocks ) {
            ctk_drop_down_menu_append_item(menu, "3D Clock Frequencies", i++);
    }
    
    ctk_object->clock_menu = GTK_WIDGET(menu);

    g_signal_connect(G_OBJECT(ctk_object->clock_menu), "changed",
                     G_CALLBACK(clock_menu_changed),
                     (gpointer) ctk_object);
    
    ctk_config_set_tooltip(ctk_config, ctk_object->clock_menu,
                           __clock_menu_help);

    gtk_widget_set_sensitive(ctk_object->clock_menu,
                             overclocking_enabled && !probing_optimal);
    
    /* Create the Graphics clock frequency slider widget */

    if ( can_access_2d_clocks ) {
        adjustment =
            gtk_adjustment_new(GET_GPU_CLOCK(clocks_2D),
                               GET_GPU_CLOCK(ranges_2D.u.range.min),
                               GET_GPU_CLOCK(ranges_2D.u.range.max),
                               1, 5, 0.0);
        ctk_object->clocks_being_modified = CLOCKS_2D;
    } else {
        adjustment =
            gtk_adjustment_new(GET_GPU_CLOCK(clocks_3D),
                               GET_GPU_CLOCK(ranges_3D.u.range.min),
                               GET_GPU_CLOCK(ranges_3D.u.range.max),
                               1, 5, 0.0);
        ctk_object->clocks_being_modified = CLOCKS_3D;
    }

    scale = ctk_scale_new(GTK_ADJUSTMENT(adjustment), "GPU (MHz)",
                          ctk_config, G_TYPE_INT);
    ctk_object->gpu_clk_scale = scale;
    
    g_signal_connect(adjustment, "value_changed",
                     G_CALLBACK(adjustment_value_changed),
                     (gpointer) ctk_object);

    ctk_config_set_tooltip(ctk_config,
                           CTK_SCALE(ctk_object->gpu_clk_scale)->gtk_scale,
                           __graphics_clock_help);

    gtk_widget_set_sensitive(ctk_object->gpu_clk_scale,
                             overclocking_enabled && !probing_optimal);

    /* Create the Memory clock frequency slider widget */
    
    if ( can_access_2d_clocks ) {
        adjustment =
            gtk_adjustment_new(GET_MEM_CLOCK(clocks_2D),
                               GET_MEM_CLOCK(ranges_2D.u.range.min),
                               GET_MEM_CLOCK(ranges_2D.u.range.max),
                               1, 5, 0.0);
    } else {
        adjustment =
            gtk_adjustment_new(GET_MEM_CLOCK(clocks_3D),
                               GET_MEM_CLOCK(ranges_3D.u.range.min),
                               GET_MEM_CLOCK(ranges_3D.u.range.max),
                               1, 5, 0.0);
    }

    scale = ctk_scale_new(GTK_ADJUSTMENT(adjustment), "Memory (MHz)",
                          ctk_config, G_TYPE_INT);
    ctk_object->mem_clk_scale = scale;
    
    g_signal_connect(adjustment, "value_changed",
                     G_CALLBACK(adjustment_value_changed),
                     (gpointer) ctk_object);
    
    ctk_config_set_tooltip(ctk_config,
                           CTK_SCALE(ctk_object->mem_clk_scale)->gtk_scale,
                           __mem_clock_help);

    gtk_widget_set_sensitive(ctk_object->mem_clk_scale,
                             overclocking_enabled && !probing_optimal);

    /* Create the Enable Overclocking checkbox widget */

    ctk_object->enable_checkbox =
        gtk_check_button_new_with_label("Enable Overclocking");

    gtk_toggle_button_set_active
        (GTK_TOGGLE_BUTTON(ctk_object->enable_checkbox),
         overclocking_enabled);

    gtk_widget_set_sensitive(ctk_object->enable_checkbox,
                             overclocking_enabled && !probing_optimal);

    g_signal_connect(G_OBJECT(ctk_object->enable_checkbox), "toggled",
                     G_CALLBACK(overclocking_state_toggled),
                     (gpointer) ctk_object);

    ctk_config_set_tooltip(ctk_config, ctk_object->enable_checkbox,
                           __enable_button_help);
    
    gtk_widget_set_sensitive(ctk_object->enable_checkbox, !probing_optimal);

    /* Create the Apply button widget */

    ctk_object->apply_button =
        gtk_button_new_with_label("Apply");

    g_signal_connect(G_OBJECT(ctk_object->apply_button), "clicked",
                     G_CALLBACK(apply_clocks_clicked),
                     (gpointer) ctk_object);
    
    ctk_config_set_tooltip(ctk_config, ctk_object->apply_button,
                           __apply_button_help);

    gtk_widget_set_sensitive(ctk_object->apply_button, False);
    
    /* Create the Auto Detect button widget */

    ctk_object->detect_button =
        gtk_button_new_with_label("Auto Detect");

    g_signal_connect(G_OBJECT(ctk_object->detect_button), "clicked",
                     G_CALLBACK(detect_clocks_clicked),
                     (gpointer) ctk_object);
    
    ctk_config_set_tooltip(ctk_config, ctk_object->detect_button,
                           __detect_button_help);
    
    if ( ctk_object->clocks_being_modified == CLOCKS_2D ) {
        gtk_widget_set_sensitive(ctk_object->detect_button, False);
    } else {
        gtk_widget_set_sensitive(ctk_object->detect_button,
                                 overclocking_enabled &&
                                 auto_detection_available && !probing_optimal);
    }

    /* Create the Reset hardware button widget */

    ctk_object->reset_button =
        gtk_button_new_with_label("Reset Hardware Defaults");

    g_signal_connect(G_OBJECT(ctk_object->reset_button), "clicked",
                     G_CALLBACK(reset_clocks_clicked),
                     (gpointer) ctk_object);
    
    ctk_config_set_tooltip(ctk_config, ctk_object->reset_button,
                           __reset_button_help);

    gtk_widget_set_sensitive(ctk_object->reset_button, False);

    /* Create the auto detect dialog */

    ctk_object->detect_dialog =
        gtk_dialog_new_with_buttons("Auto Detect Optimal 3D Clock Frequencies?",
                                    GTK_WINDOW(gtk_widget_get_parent(GTK_WIDGET(ctk_object))),
                                    GTK_DIALOG_MODAL |  GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
                                    GTK_STOCK_OK,
                                    GTK_RESPONSE_ACCEPT,
                                    GTK_STOCK_CANCEL,
                                    GTK_RESPONSE_REJECT,
                                    NULL
                                    );
    
    label = gtk_label_new(__detect_confirm_msg);
    hbox = gtk_hbox_new(TRUE, 15);

    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15);

    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(ctk_object->detect_dialog)->vbox),
                       hbox, FALSE, FALSE, 15);

    /*
     * Now that we've created all the widgets we care about, we're
     * ready to compose the panel
     */

    /* Set container properties of the ctk object */

    gtk_box_set_spacing(GTK_BOX(ctk_object), 10);

    banner = ctk_banner_image_new(BANNER_ARTWORK_CLOCK);
    gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);

    /* Add Overclocking checkbox */

    hbox = gtk_hbox_new(FALSE, 0);

    gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(hbox), ctk_object->enable_checkbox,
                       FALSE, FALSE, 0);

    /* Add Clock frequency frame */

    frame = gtk_frame_new("Clock Frequencies");
    vbox = gtk_vbox_new(FALSE, 0);
    hbox = gtk_hbox_new(FALSE, 0);
            
    gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
    
    gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
    gtk_container_add(GTK_CONTAINER(frame), vbox);
            
    
    gtk_box_pack_start(GTK_BOX(hbox), ctk_object->clock_menu,
                       FALSE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(vbox), hbox,
                       FALSE, FALSE, 5);

    gtk_box_pack_start(GTK_BOX(vbox), ctk_object->gpu_clk_scale,
                       FALSE, FALSE, 5);
            
    gtk_box_pack_start(GTK_BOX(vbox), ctk_object->mem_clk_scale,
                       FALSE, FALSE, 5);                
        
    /* Add the Apply, Auto Detect, and Reset buttons */

    hbox = gtk_hbox_new(FALSE, 5);

    gtk_box_pack_start(GTK_BOX(hbox), ctk_object->apply_button,
                       FALSE, FALSE, 0);
    gtk_container_add(GTK_CONTAINER(hbox), ctk_object->detect_button);
    gtk_container_add(GTK_CONTAINER(hbox), ctk_object->reset_button);
        
    alignment = gtk_alignment_new(1, 1, 0, 0);
    gtk_container_add(GTK_CONTAINER(alignment), hbox);
    gtk_box_pack_start(GTK_BOX(object), alignment, TRUE, TRUE, 0);

    /* Setup the initial gui state */
    
    sync_gui_to_modify_clocks(ctk_object, ctk_object->clocks_being_modified);
    
    /* Handle events from other NV-CONTROL clients */
    
    g_signal_connect(G_OBJECT(ctk_event),
                     CTK_EVENT_NAME(NV_CTRL_GPU_OVERCLOCKING_STATE),
                     G_CALLBACK(overclocking_state_received),
                     (gpointer) ctk_object);
    
    g_signal_connect(G_OBJECT(ctk_event),
                     CTK_EVENT_NAME(NV_CTRL_GPU_2D_CLOCK_FREQS),
                     G_CALLBACK(clocks_received),
                     (gpointer) ctk_object);
    
    g_signal_connect(G_OBJECT(ctk_event),
                     CTK_EVENT_NAME(NV_CTRL_GPU_3D_CLOCK_FREQS),
                     G_CALLBACK(clocks_received),
                     (gpointer) ctk_object);
    
    g_signal_connect(G_OBJECT(ctk_event),
                     CTK_EVENT_NAME(NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS),
                     G_CALLBACK(clocks_received),
                     (gpointer) ctk_object);

    g_signal_connect(G_OBJECT(ctk_event),
                     CTK_EVENT_NAME(NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE),
                     G_CALLBACK(auto_detection_state_received),
                     (gpointer) ctk_object);

    /* Show the widget */

    gtk_widget_show_all(GTK_WIDGET(ctk_object));

    return GTK_WIDGET(ctk_object);

} /* ctk_clocks_new() */
Exemplo n.º 12
0
Arquivo: srv-prop.c Projeto: IR4T4/xqf
static GtkWidget *server_info_page (struct server *s) {
	GtkWidget *page_vbox;
	GtkWidget *table;
	GtkWidget *frame;
	GtkWidget *hbox;
	GtkWidget *vbox;
	GtkWidget *label;
	GSList *sources;
	GSList *list;

	struct master *m;
	struct server_props *props;
	char buf[32];
	GList *cfgs;
	int slots_buffer;
	guint row = 0;



	props = properties (s);

	page_vbox = gtk_vbox_new (FALSE, 8);
	gtk_container_set_border_width (GTK_CONTAINER (page_vbox), 8);

	/* Address */

	table = gtk_table_new (6, 4, FALSE);
	gtk_table_set_row_spacings (GTK_TABLE (table), 4);
	gtk_table_set_col_spacings (GTK_TABLE (table), 8);
	gtk_box_pack_start (GTK_BOX (page_vbox), table, FALSE, FALSE, 0);

	gtk_table_set_col_spacing (GTK_TABLE (table), 1, 16);

	label = gtk_label_new (_("IP Address:"));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
	gtk_widget_show (label);

	label = gtk_label_new (inet_ntoa (s->host->ip));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, row, row+1);
	gtk_widget_show (label);

	label = gtk_label_new (_("Port:"));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, row, row+1);
	gtk_widget_show (label);

	g_snprintf (buf, 32, "%d", s->port);

	label = gtk_label_new (buf);
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach_defaults (GTK_TABLE (table), label, 3, 4, row, row+1);
	gtk_widget_show (label);

	row++;

	label = gtk_label_new (_("Host Name:"));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
	gtk_widget_show (label);

	if (s->host->name) {
		label = gtk_label_new (s->host->name);
		gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
		gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 4, row, row+1);
		gtk_widget_show (label);
	}

	row++;

	label = gtk_label_new (_("Country:"));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
	gtk_widget_show (label);

#ifdef USE_GEOIP
	if (geoip_name_by_id(s->country_id)) {
		GtkWidget* hbox = gtk_hbox_new (FALSE, 4);
		struct pixmap* pix = get_pixmap_for_country(s->country_id);
		if (pix) {
			GtkWidget *pixmap = gtk_pixmap_new(pix->pix,pix->mask);
			gtk_box_pack_start (GTK_BOX (hbox), pixmap, FALSE, FALSE, 0);
			gtk_widget_show (pixmap);
		}

		label = gtk_label_new (geoip_name_by_id(s->country_id));
		gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
		gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
		gtk_widget_show (label);

		gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 4, row, row+1);
		gtk_widget_show (hbox);
	}
#endif

	row++;

	label = gtk_label_new (_("Refreshed:"));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
	gtk_widget_show (label);

	if (s->refreshed) {
		char* str = timet2string(&s->refreshed);

		label = gtk_label_new (str);
		g_free(str);
		gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
		gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 4, row, row+1);
		gtk_widget_show (label);
	}

	row++;

	// translator: last time and date the server answered the query
	label = gtk_label_new (_("Last answer:"));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
	gtk_widget_show (label);

	if (s->last_answer) {
		GtkStyle *style;
		GdkColor color;
		time_t max_days = 3; // XXX: hardcoded, has to be configurable some time
		char* str = timet2string(&s->last_answer);

		label = gtk_label_new (str);
		g_free(str);
		gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
		gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 4, row, row+1);

		if (s->last_answer + max_days*24*60*60 < s->refreshed) {
			// XXX: I don't know if that is the correct way, it's undocumented :-(
			style = gtk_widget_get_style(label);
			gdk_color_parse("red",&color);

			style->fg [GTK_STATE_NORMAL]   = color;
			style->fg [GTK_STATE_ACTIVE]   = color;
			style->fg [GTK_STATE_PRELIGHT] = color;
			style->fg [GTK_STATE_SELECTED] = color;
			style->fg [GTK_STATE_INSENSITIVE] = color;

			gtk_widget_set_style (label, style);
		}

		gtk_widget_show (label);
	}

	row++;

	/*pulp*/ /*Reserved Slots spin widget*/


	if (props) {
		if (props->reserved_slots) {


			slots_buffer=props->reserved_slots;
		}

		else {
			slots_buffer=0;
		}
	}

	else {
		slots_buffer=0;
	}



	label = gtk_label_new (_("Reserved Slots:"));
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
	gtk_widget_show (label);


	adj = (GtkAdjustment *) gtk_adjustment_new (slots_buffer, 0, 9, 1, 2,0);
	spinner = gtk_spin_button_new (adj, 0, 0);
	gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
	gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON (spinner), GTK_UPDATE_IF_VALID);
	gtk_table_attach_defaults (GTK_TABLE (table), spinner, 1, 2, row, row+1);
	gtk_widget_show (spinner);



	gtk_widget_show (table);

	/* Sources */

	frame = gtk_frame_new (_("Sources"));
	gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
	gtk_box_pack_start (GTK_BOX (page_vbox), frame, FALSE, FALSE, 0);

	vbox = gtk_vbox_new (FALSE, 4);
	gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
	gtk_container_add (GTK_CONTAINER (frame), vbox);

	sources = references_to_server (s);

	for (list = sources; list; list = list->next) {
		m = (struct master *) list->data;

		label = gtk_label_new (_(m->name));
		gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
		gtk_widget_show (label);
	}

	g_slist_free (sources);

	gtk_widget_show (vbox);
	gtk_widget_show (frame);

	/* Custom CFG */

	hbox = gtk_hbox_new (FALSE, 8);
	gtk_box_pack_start (GTK_BOX (page_vbox), hbox, FALSE, FALSE, 0);

	customcfg_combo = gtk_combo_new ();
	gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (customcfg_combo)->entry), 
			256);
	gtk_widget_set_usize (GTK_COMBO (customcfg_combo)->entry, 112, -1);

	if ((games[s->type].flags & GAME_CONNECT) != 0 && 
			games[s->type].custom_cfgs) {

		cfgs = (*games[s->type].custom_cfgs) (&games[s->type], NULL, s->game);

		combo_set_vals (customcfg_combo, cfgs, 
				(props && props->custom_cfg)? props->custom_cfg : NULL);
		if (cfgs) {
			g_list_foreach (cfgs, (GFunc) g_free, NULL);
			g_list_free (cfgs);
		}
	}
	else {
		gtk_widget_set_sensitive (customcfg_combo, FALSE);
	}

	gtk_box_pack_end (GTK_BOX (hbox), customcfg_combo, FALSE, FALSE, 0);
	gtk_widget_show (customcfg_combo);

	label = gtk_label_new (_("Custom CFG:"));
	gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
	gtk_widget_show (label);

	gtk_widget_show (hbox);

	gtk_widget_show (page_vbox);

	return page_vbox;
}
Exemplo n.º 13
0
static void
create_children (GNCDateEdit *gde)
{
    GtkWidget *frame;
    GtkWidget *hbox;
    GtkWidget *arrow;
    GtkTreeStore *store;
    GtkCellRenderer *cell;

    /* Create the text entry area. */
    gde->date_entry  = gtk_entry_new ();
    gtk_entry_set_width_chars (GTK_ENTRY (gde->date_entry), 11);
    gtk_box_pack_start (GTK_BOX (gde), gde->date_entry, TRUE, TRUE, 0);
    gtk_widget_show (GTK_WIDGET(gde->date_entry));
    g_signal_connect (G_OBJECT (gde->date_entry), "key-press-event",
                      G_CALLBACK (key_press_entry), gde);
    g_signal_connect (G_OBJECT (gde->date_entry), "focus-out-event",
                      G_CALLBACK (date_focus_out_event), gde);

    /* Create the popup button. */
    gde->date_button = gtk_toggle_button_new ();
    g_signal_connect (gde->date_button, "button-press-event",
                      G_CALLBACK(gnc_date_edit_button_pressed), gde);
    g_signal_connect (G_OBJECT (gde->date_button), "toggled",
                      G_CALLBACK (gnc_date_edit_button_toggled), gde);
    gtk_box_pack_start (GTK_BOX (gde), gde->date_button, FALSE, FALSE, 0);

    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
    gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
    gtk_container_add (GTK_CONTAINER (gde->date_button), hbox);
    gtk_widget_show (GTK_WIDGET(hbox));

    /* Calendar label, only shown if the date editor has a time field */
    gde->cal_label = gtk_label_new (_("Calendar"));
    gnc_label_set_alignment (gde->cal_label, 0.0, 0.5);
    gtk_box_pack_start (GTK_BOX (hbox), gde->cal_label, TRUE, TRUE, 0);
    if (gde->flags & GNC_DATE_EDIT_SHOW_TIME)
        gtk_widget_show (GTK_WIDGET(gde->cal_label));

    /* Graphic for the popup button. */
    arrow = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_BUTTON);

    g_signal_connect (G_OBJECT (arrow), "draw",
                      G_CALLBACK (gnc_draw_arrow_cb), GINT_TO_POINTER(1));

    gtk_box_pack_start (GTK_BOX (hbox), arrow, TRUE, FALSE, 0);
    gtk_widget_show (GTK_WIDGET(arrow));

    gtk_widget_show (GTK_WIDGET(gde->date_button));

    /* Time entry controls. */
    gde->time_entry = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY(gde->time_entry), 12);
    gtk_widget_set_size_request (GTK_WIDGET(gde->time_entry), 88, -1);
    gtk_box_pack_start (GTK_BOX (gde), gde->time_entry, TRUE, TRUE, 0);

    store = gtk_tree_store_new(1, G_TYPE_STRING);
    gde->time_combo = GTK_WIDGET(gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)));
    g_object_unref(store);
    /* Create cell renderer. */
    cell = gtk_cell_renderer_text_new();
    /* Pack it to the combo box. */
    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( gde->time_combo ), cell, TRUE );
    /* Connect renderer to data source */
    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( gde->time_combo ), cell, "text", 0, NULL );

    g_signal_connect (G_OBJECT (gde->time_combo), "changed",
                      G_CALLBACK  (set_time), gde);

    gtk_box_pack_start (GTK_BOX (gde), gde->time_combo, FALSE, FALSE, 0);

    /* We do not create the popup menu with the hour range until we are
     * realized, so that it uses the values that the user might supply in a
     * future call to gnc_date_edit_set_popup_range
     */
    g_signal_connect (G_OBJECT (gde), "realize",
                      G_CALLBACK  (fill_time_combo), gde);

    if (gde->flags & GNC_DATE_EDIT_SHOW_TIME)
    {
        gtk_widget_show (GTK_WIDGET(gde->time_entry));
        gtk_widget_show (GTK_WIDGET(gde->time_combo));
    }

    gde->cal_popup = gtk_window_new (GTK_WINDOW_POPUP);
    gtk_widget_set_name (gde->cal_popup, "gnc-date-edit-popup-window");

    gtk_window_set_type_hint (GTK_WINDOW (gde->cal_popup),
                              GDK_WINDOW_TYPE_HINT_COMBO);

    gtk_widget_set_events (GTK_WIDGET(gde->cal_popup),
                           gtk_widget_get_events (GTK_WIDGET(gde->cal_popup)) |
                           GDK_KEY_PRESS_MASK);

    g_signal_connect (gde->cal_popup, "delete-event",
                      G_CALLBACK(delete_popup), gde);
    g_signal_connect (gde->cal_popup, "key-press-event",
                      G_CALLBACK(key_press_popup), gde);
    g_signal_connect (gde->cal_popup, "button-press-event",
                      G_CALLBACK(gnc_date_edit_button_pressed), gde);
    g_signal_connect (gde->cal_popup, "button-release-event",
                      G_CALLBACK(gnc_date_edit_button_released), gde);
    gtk_window_set_resizable (GTK_WINDOW (gde->cal_popup), FALSE);
    gtk_window_set_screen (GTK_WINDOW (gde->cal_popup),
                           gtk_widget_get_screen (GTK_WIDGET (gde)));

    frame = gtk_frame_new (NULL);
    gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
    gtk_container_add (GTK_CONTAINER (gde->cal_popup), frame);
    gtk_widget_show (GTK_WIDGET(frame));

    gde->calendar = gtk_calendar_new ();
    gtk_calendar_set_display_options
    (GTK_CALENDAR (gde->calendar),
     (GTK_CALENDAR_SHOW_DAY_NAMES
      | GTK_CALENDAR_SHOW_HEADING));
    g_signal_connect (gde->calendar, "button-release-event",
                      G_CALLBACK(gnc_date_edit_button_released), gde);
    g_signal_connect (G_OBJECT (gde->calendar), "day-selected",
		      G_CALLBACK (day_selected), gde);
    g_signal_connect (G_OBJECT (gde->calendar),
                      "day-selected-double-click",
                      G_CALLBACK  (day_selected_double_click), gde);
    gtk_container_add (GTK_CONTAINER (frame), gde->calendar);
    gtk_widget_show (GTK_WIDGET(gde->calendar));
}
Exemplo n.º 14
0
GtkWidget *create_hdhomerun_config(void)
{
	GtkWidget *hdhomerun_config;
	GtkWidget *hbox1;
	GtkWidget *frame1;
	GtkWidget *vbox2;
	GtkWidget *scrolledwindow1;
	GtkWidget *DeviceListTree;
	GtkWidget *RescanBtn;
	GtkWidget *label1;
	GtkWidget *Tab;
	GtkWidget *vbox1;
	GtkWidget *frame2;
	GtkWidget *table2;
	GtkWidget *label11;
	GtkWidget *label12;
	GtkWidget *label13;
	GtkWidget *LaunchVlcBtn;
	GtkWidget *StopVlcBtn;
	GtkWidget *hbox2;
	GtkWidget *ChannelMapEdit;
	GtkObject *ChannelNumberSpin_adj;
	GtkWidget *ChannelNumberSpin;
	GtkWidget *ProgramList;
	GtkWidget *ScanDownBtn;
	GtkWidget *ScanUpBtn;
	GtkWidget *label15;
	GtkWidget *frame3;
	GtkWidget *table1;
	GtkWidget *label5;
	GtkWidget *label6;
	GtkWidget *label7;
	GtkWidget *label8;
	GtkWidget *SignalStrengthStatus;
	GtkWidget *SignalQualityStatus;
	GtkWidget *SymbolQualityStatus;
	GtkWidget *PhysicalChannelStatus;
	GtkWidget *label10;
	GtkWidget *NetworkRateStatus;
	GtkWidget *label4;
	GtkWidget *label2;
	GtkWidget *vbox3;
	GtkWidget *frame4;
	GtkWidget *table3;
	GtkWidget *FirmwareVersion;
	GtkWidget *UpgradeBtn;
	GtkWidget *hbox3;
	GtkWidget *UpgradeFilename;
	GtkWidget *UpgradeFilenameBtn;
	GtkWidget *label14;
	GtkWidget *label3;

	hdhomerun_config = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(hdhomerun_config), _("HDHomeRun Config"));
	gtk_window_set_resizable(GTK_WINDOW(hdhomerun_config), FALSE);

	hbox1 = gtk_hbox_new(FALSE, 6);
	gtk_widget_show(hbox1);
	gtk_container_add(GTK_CONTAINER(hdhomerun_config), hbox1);
	gtk_container_set_border_width(GTK_CONTAINER(hbox1), 3);

	frame1 = gtk_frame_new(NULL);
	gtk_widget_show(frame1);
	gtk_box_pack_start(GTK_BOX(hbox1), frame1, TRUE, TRUE, 0);

	vbox2 = gtk_vbox_new(FALSE, 3);
	gtk_widget_show(vbox2);
	gtk_container_add(GTK_CONTAINER(frame1), vbox2);
	gtk_container_set_border_width(GTK_CONTAINER(vbox2), 3);

	scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_show(scrolledwindow1);
	gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindow1, TRUE, TRUE, 0);

	DeviceListTree = gtk_tree_view_new();
	gtk_widget_show(DeviceListTree);
	gtk_container_add(GTK_CONTAINER(scrolledwindow1), DeviceListTree);
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(DeviceListTree), FALSE);
	gtk_tree_view_set_enable_search(GTK_TREE_VIEW(DeviceListTree), FALSE);

	RescanBtn = gtk_button_new_with_mnemonic(_("_Rescan"));
	gtk_widget_show(RescanBtn);
	gtk_box_pack_start(GTK_BOX(vbox2), RescanBtn, FALSE, FALSE, 0);

	label1 = gtk_label_new(_("Device"));
	gtk_widget_show(label1);
	gtk_frame_set_label_widget(GTK_FRAME(frame1), label1);
	gtk_label_set_use_markup(GTK_LABEL(label1), TRUE);
	gtk_misc_set_padding(GTK_MISC(label1), 3, 0);

	Tab = gtk_notebook_new();
	gtk_widget_show(Tab);
	gtk_box_pack_start(GTK_BOX(hbox1), Tab, TRUE, TRUE, 0);

	vbox1 = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(vbox1);
	gtk_container_add(GTK_CONTAINER(Tab), vbox1);

	frame2 = gtk_frame_new(NULL);
	gtk_widget_show(frame2);
	gtk_box_pack_start(GTK_BOX(vbox1), frame2, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(frame2), 3);

	table2 = gtk_table_new(3, 4, TRUE);
	gtk_widget_show(table2);
	gtk_container_add(GTK_CONTAINER(frame2), table2);
	gtk_container_set_border_width(GTK_CONTAINER(table2), 6);
	gtk_table_set_row_spacings(GTK_TABLE(table2), 3);
	gtk_table_set_col_spacings(GTK_TABLE(table2), 3);

	label11 = gtk_label_new(_("Channel"));
	gtk_widget_show(label11);
	gtk_table_attach(GTK_TABLE(table2), label11, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	label12 = gtk_label_new(_("Program"));
	gtk_widget_show(label12);
	gtk_table_attach(GTK_TABLE(table2), label12, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	label13 = gtk_label_new(_("Scan"));
	gtk_widget_show(label13);
	gtk_table_attach(GTK_TABLE(table2), label13, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	LaunchVlcBtn = gtk_button_new_with_mnemonic(_("_View"));
	gtk_widget_show(LaunchVlcBtn);
	gtk_table_attach(GTK_TABLE(table2), LaunchVlcBtn, 3, 4, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	StopVlcBtn = gtk_button_new_with_mnemonic(_("_Stop"));
	gtk_widget_show(StopVlcBtn);
	gtk_table_attach(GTK_TABLE(table2), StopVlcBtn, 3, 4, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	gtk_widget_set_sensitive(StopVlcBtn, FALSE);

	hbox2 = gtk_hbox_new(FALSE, 3);
	gtk_widget_show(hbox2);
	gtk_table_attach(GTK_TABLE(table2), hbox2, 1, 3, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	ChannelMapEdit = gtk_combo_box_new_text();
	gtk_widget_show(ChannelMapEdit);
	gtk_box_pack_start(GTK_BOX(hbox2), ChannelMapEdit, TRUE, TRUE, 0);

	ChannelNumberSpin_adj = gtk_adjustment_new(0, 0, 300, 1, 10, 0);
	ChannelNumberSpin = gtk_spin_button_new(GTK_ADJUSTMENT(ChannelNumberSpin_adj), 1, 0);
	gtk_widget_show(ChannelNumberSpin);
	gtk_box_pack_start(GTK_BOX(hbox2), ChannelNumberSpin, FALSE, FALSE, 0);
	gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ChannelNumberSpin), TRUE);
	gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(ChannelNumberSpin), TRUE);

	ProgramList = gtk_combo_box_new_text();
	gtk_widget_show(ProgramList);
	gtk_table_attach(GTK_TABLE(table2), ProgramList, 1, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	ScanDownBtn = gtk_toggle_button_new_with_mnemonic("_<<-");
	gtk_widget_show(ScanDownBtn);
	gtk_table_attach(GTK_TABLE(table2), ScanDownBtn, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	ScanUpBtn = gtk_toggle_button_new_with_mnemonic("->_>");
	gtk_widget_show(ScanUpBtn);
	gtk_table_attach(GTK_TABLE(table2), ScanUpBtn, 2, 3, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	label15 = gtk_label_new(_("Configuration"));
	gtk_widget_show(label15);
	gtk_frame_set_label_widget(GTK_FRAME(frame2), label15);
	gtk_label_set_use_markup(GTK_LABEL(label15), TRUE);
	gtk_misc_set_padding(GTK_MISC(label15), 3, 0);

	frame3 = gtk_frame_new(NULL);
	gtk_widget_show(frame3);
	gtk_box_pack_start(GTK_BOX(vbox1), frame3, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(frame3), 3);

	table1 = gtk_table_new(6, 2, FALSE);
	gtk_widget_show(table1);
	gtk_container_add(GTK_CONTAINER(frame3), table1);
	gtk_container_set_border_width(GTK_CONTAINER(table1), 6);
	gtk_table_set_row_spacings(GTK_TABLE(table1), 2);
	gtk_table_set_col_spacings(GTK_TABLE(table1), 2);

	label5 = gtk_label_new(_("Physical Channel"));
	gtk_widget_show(label5);
	gtk_table_attach(GTK_TABLE(table1), label5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	label6 = gtk_label_new(_("Signal Strength %"));
	gtk_widget_show(label6);
	gtk_table_attach(GTK_TABLE(table1), label6, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	label7 = gtk_label_new(_("Signal Quality %"));
	gtk_widget_show(label7);
	gtk_table_attach(GTK_TABLE(table1), label7, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	label8 = gtk_label_new(_("Symbol Quality %"));
	gtk_widget_show(label8);
	gtk_table_attach(GTK_TABLE(table1), label8, 0, 1, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	SignalStrengthStatus = gtk_progress_bar_new();
	gtk_widget_show(SignalStrengthStatus);
	gtk_table_attach(GTK_TABLE(table1), SignalStrengthStatus, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	SignalQualityStatus = gtk_progress_bar_new();
	gtk_widget_show(SignalQualityStatus);
	gtk_table_attach(GTK_TABLE(table1), SignalQualityStatus, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	SymbolQualityStatus = gtk_progress_bar_new();
	gtk_widget_show(SymbolQualityStatus);
	gtk_table_attach(GTK_TABLE(table1), SymbolQualityStatus, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);

	PhysicalChannelStatus = gtk_entry_new();
	gtk_widget_show(PhysicalChannelStatus);
	gtk_table_attach(GTK_TABLE(table1), PhysicalChannelStatus, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_widget_set_sensitive(PhysicalChannelStatus, FALSE);
	GTK_WIDGET_UNSET_FLAGS(PhysicalChannelStatus, GTK_CAN_FOCUS);
	gtk_editable_set_editable(GTK_EDITABLE(PhysicalChannelStatus), FALSE);
	gtk_entry_set_text(GTK_ENTRY(PhysicalChannelStatus), _("none"));
	gtk_entry_set_invisible_char(GTK_ENTRY(PhysicalChannelStatus), 9679);

	label10 = gtk_label_new(_("Network Rate"));
	gtk_widget_show(label10);
	gtk_table_attach(GTK_TABLE(table1), label10, 0, 1, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	NetworkRateStatus = gtk_entry_new();
	gtk_widget_show(NetworkRateStatus);
	gtk_table_attach(GTK_TABLE(table1), NetworkRateStatus, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
	gtk_widget_set_sensitive(NetworkRateStatus, FALSE);
	GTK_WIDGET_UNSET_FLAGS(NetworkRateStatus, GTK_CAN_FOCUS);
	gtk_editable_set_editable(GTK_EDITABLE(NetworkRateStatus), FALSE);
	gtk_entry_set_text(GTK_ENTRY(NetworkRateStatus), _("0.000 Mbps"));
	gtk_entry_set_invisible_char(GTK_ENTRY(NetworkRateStatus), 9679);

	label4 = gtk_label_new(_("Status"));
	gtk_widget_show(label4);
	gtk_frame_set_label_widget(GTK_FRAME(frame3), label4);
	gtk_label_set_use_markup(GTK_LABEL(label4), TRUE);
	gtk_misc_set_padding(GTK_MISC(label4), 3, 0);

	label2 = gtk_label_new(_("Tuner"));
	gtk_widget_show(label2);
	gtk_notebook_set_tab_label(GTK_NOTEBOOK(Tab), gtk_notebook_get_nth_page(GTK_NOTEBOOK(Tab), 0), label2);

	vbox3 = gtk_vbox_new(FALSE, 0);
	gtk_widget_show(vbox3);
	gtk_container_add(GTK_CONTAINER(Tab), vbox3);

	frame4 = gtk_frame_new(NULL);
	gtk_widget_show(frame4);
	gtk_box_pack_start(GTK_BOX(vbox3), frame4, FALSE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(frame4), 3);

	table3 = gtk_table_new(2, 2, FALSE);
	gtk_widget_show(table3);
	gtk_container_add(GTK_CONTAINER(frame4), table3);
	gtk_container_set_border_width(GTK_CONTAINER(table3), 3);
	gtk_table_set_row_spacings(GTK_TABLE(table3), 3);
	gtk_table_set_col_spacings(GTK_TABLE(table3), 3);

	FirmwareVersion = gtk_label_new("");
	gtk_widget_show(FirmwareVersion);
	gtk_table_attach(GTK_TABLE(table3), FirmwareVersion, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	gtk_misc_set_alignment(GTK_MISC(FirmwareVersion), 0, 0.5);

	UpgradeBtn = gtk_button_new_with_mnemonic(_("Upgrade"));
	gtk_widget_show(UpgradeBtn);
	gtk_table_attach(GTK_TABLE(table3), UpgradeBtn, 1, 2, 1, 2, (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);
	gtk_widget_set_sensitive(UpgradeBtn, FALSE);

	hbox3 = gtk_hbox_new(FALSE, 3);
	gtk_widget_show(hbox3);
	gtk_table_attach(GTK_TABLE(table3), hbox3, 0, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

	UpgradeFilename = gtk_entry_new();
	gtk_widget_show(UpgradeFilename);
	gtk_box_pack_start(GTK_BOX(hbox3), UpgradeFilename, TRUE, TRUE, 0);
	gtk_entry_set_invisible_char(GTK_ENTRY(UpgradeFilename), 9679);

	UpgradeFilenameBtn = gtk_button_new_with_mnemonic("...");
	gtk_widget_show(UpgradeFilenameBtn);
	gtk_box_pack_start(GTK_BOX(hbox3), UpgradeFilenameBtn, FALSE, FALSE, 0);

	label14 = gtk_label_new(_("Upgrade"));
	gtk_widget_show(label14);
	gtk_frame_set_label_widget(GTK_FRAME(frame4), label14);
	gtk_misc_set_padding(GTK_MISC(label14), 3, 0);

	label3 = gtk_label_new(_("Upgrade"));
	gtk_widget_show(label3);
	gtk_notebook_set_tab_label(GTK_NOTEBOOK(Tab), gtk_notebook_get_nth_page(GTK_NOTEBOOK(Tab), 1), label3);

	g_signal_connect((gpointer) hdhomerun_config, "destroy", G_CALLBACK(gtk_main_quit), NULL);
	g_signal_connect((gpointer) hdhomerun_config, "key_press_event", G_CALLBACK(on_hdhomerun_config_key_press_event), NULL);
	g_signal_connect((gpointer) RescanBtn, "clicked", G_CALLBACK(on_RescanBtn_clicked), NULL);
	g_signal_connect_after((gpointer) Tab, "switch_page", G_CALLBACK(on_Tab_switch_page), NULL);
	g_signal_connect((gpointer) LaunchVlcBtn, "clicked", G_CALLBACK(on_LaunchVlcBtn_clicked), NULL);
	g_signal_connect((gpointer) StopVlcBtn, "clicked", G_CALLBACK(on_StopVlcBtn_clicked), NULL);
	g_signal_connect((gpointer) ChannelMapEdit, "changed", G_CALLBACK(on_ChannelMapEdit_changed), NULL);
	g_signal_connect((gpointer) ChannelNumberSpin, "value_changed", G_CALLBACK(on_ChannelNumberSpin_value_changed), NULL);
	g_signal_connect_after((gpointer) ChannelNumberSpin, "activate", G_CALLBACK(on_ChannelNumberSpin_activate), NULL);
	g_signal_connect((gpointer) ProgramList, "changed", G_CALLBACK(on_ProgramList_changed), NULL);
	g_signal_connect((gpointer) ScanDownBtn, "clicked", G_CALLBACK(on_ScanDownBtn_clicked), NULL);
	g_signal_connect((gpointer) ScanUpBtn, "clicked", G_CALLBACK(on_ScanUpBtn_clicked), NULL);
	g_signal_connect((gpointer) UpgradeBtn, "clicked", G_CALLBACK(on_UpgradeBtn_clicked), NULL);
	g_signal_connect((gpointer) UpgradeFilename, "changed", G_CALLBACK(on_UpgradeFilename_changed), NULL);
	g_signal_connect((gpointer) UpgradeFilenameBtn, "clicked", G_CALLBACK(on_UpgradeFilenameBtn_clicked), NULL);

	/* Store pointers to all widgets, for use by lookup_widget(). */
	GLADE_HOOKUP_OBJECT_NO_REF(hdhomerun_config, hdhomerun_config, "hdhomerun_config");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox1, "hbox1");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, frame1, "frame1");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox2, "vbox2");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, scrolledwindow1, "scrolledwindow1");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, DeviceListTree, "DeviceListTree");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, RescanBtn, "RescanBtn");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label1, "label1");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, Tab, "Tab");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox1, "vbox1");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, frame2, "frame2");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, table2, "table2");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label11, "label11");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label12, "label12");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label13, "label13");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, LaunchVlcBtn, "LaunchVlcBtn");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, StopVlcBtn, "StopVlcBtn");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox2, "hbox2");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, ChannelMapEdit, "ChannelMapEdit");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, ChannelNumberSpin, "ChannelNumberSpin");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, ProgramList, "ProgramList");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, ScanDownBtn, "ScanDownBtn");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, ScanUpBtn, "ScanUpBtn");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label15, "label15");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, frame3, "frame3");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, table1, "table1");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label5, "label5");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label6, "label6");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label7, "label7");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label8, "label8");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, SignalStrengthStatus, "SignalStrengthStatus");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, SignalQualityStatus, "SignalQualityStatus");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, SymbolQualityStatus, "SymbolQualityStatus");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, PhysicalChannelStatus, "PhysicalChannelStatus");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label10, "label10");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, NetworkRateStatus, "NetworkRateStatus");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label4, "label4");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label2, "label2");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox3, "vbox3");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, frame4, "frame4");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, table3, "table3");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, FirmwareVersion, "FirmwareVersion");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeBtn, "UpgradeBtn");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox3, "hbox3");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeFilename, "UpgradeFilename");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeFilenameBtn, "UpgradeFilenameBtn");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label14, "label14");
	GLADE_HOOKUP_OBJECT(hdhomerun_config, label3, "label3");

	return hdhomerun_config;
}
Exemplo n.º 15
0
static GtkWidget *create_custom_widget(GtkPrintOperation *operation, gpointer user_data)
{	/* copied from interface.c */
	GtkWidget *page;
	GtkWidget *frame33;
	GtkWidget *alignment36;
	GtkWidget *vbox30;
	GtkWidget *hbox10;
	GtkWidget *label203;
	PrintWidgets *w = user_data;

	gtk_print_operation_set_custom_tab_label(operation, _("Document Setup"));

	page = gtk_vbox_new(FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(page), 5);

	w->check_print_linenumbers = gtk_check_button_new_with_mnemonic(_("Print line numbers"));
	gtk_box_pack_start(GTK_BOX(page), w->check_print_linenumbers, FALSE, FALSE, 0);
	gtk_widget_set_tooltip_text(w->check_print_linenumbers, _("Add line numbers to the printed page"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_linenumbers), printing_prefs.print_line_numbers);

	w->check_print_pagenumbers = gtk_check_button_new_with_mnemonic(_("Print page numbers"));
	gtk_box_pack_start(GTK_BOX(page), w->check_print_pagenumbers, FALSE, FALSE, 0);
	gtk_widget_set_tooltip_text(w->check_print_pagenumbers, _("Add page numbers at the bottom of each page. It takes 2 lines of the page."));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pagenumbers), printing_prefs.print_page_numbers);

	w->check_print_pageheader = gtk_check_button_new_with_mnemonic(_("Print page header"));
	gtk_box_pack_start(GTK_BOX(page), w->check_print_pageheader, FALSE, FALSE, 0);
	gtk_widget_set_tooltip_text(w->check_print_pageheader, _("Add a little header to every page containing the page number, the filename and the current date (see below). It takes 3 lines of the page."));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pageheader), printing_prefs.print_page_header);
	g_signal_connect(w->check_print_pageheader, "toggled", G_CALLBACK(on_page_header_toggled), w);

	frame33 = gtk_frame_new(NULL);
	gtk_box_pack_start(GTK_BOX(page), frame33, FALSE, FALSE, 0);
	gtk_frame_set_label_align(GTK_FRAME(frame33), 0, 0);
	gtk_frame_set_shadow_type(GTK_FRAME(frame33), GTK_SHADOW_NONE);

	alignment36 = gtk_alignment_new(0, 0.5, 1, 1);
	gtk_container_add(GTK_CONTAINER(frame33), alignment36);
	gtk_alignment_set_padding(GTK_ALIGNMENT(alignment36), 0, 0, 12, 0);

	vbox30 = gtk_vbox_new(FALSE, 1);
	gtk_container_add(GTK_CONTAINER(alignment36), vbox30);

	w->check_print_basename = gtk_check_button_new_with_mnemonic(_("Use the basename of the printed file"));
	gtk_box_pack_start(GTK_BOX(vbox30), w->check_print_basename, FALSE, FALSE, 0);
	gtk_widget_set_tooltip_text(w->check_print_basename, _("Print only the basename(without the path) of the printed file"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_basename), printing_prefs.page_header_basename);

	hbox10 = gtk_hbox_new(FALSE, 5);
	gtk_box_pack_start(GTK_BOX(vbox30), hbox10, TRUE, TRUE, 0);

	label203 = gtk_label_new(_("Date format:"));
	gtk_box_pack_start(GTK_BOX(hbox10), label203, FALSE, FALSE, 0);

	w->entry_print_dateformat = gtk_entry_new();
	ui_entry_add_clear_icon(GTK_ENTRY(w->entry_print_dateformat));
	gtk_box_pack_start(GTK_BOX(hbox10), w->entry_print_dateformat, TRUE, TRUE, 0);
	gtk_widget_set_tooltip_text(w->entry_print_dateformat, _("Specify a format for the date and time stamp which is added to the page header on each page. You can use any conversion specifiers which can be used with the ANSI C strftime function."));
	gtk_entry_set_text(GTK_ENTRY(w->entry_print_dateformat), printing_prefs.page_header_datefmt);

	on_page_header_toggled(GTK_TOGGLE_BUTTON(w->check_print_pageheader), w);
	gtk_widget_show_all(page);
	return page;
}
Exemplo n.º 16
0
void gui_animate_dialog(void)
{
    gchar *tmp, *title;
    gpointer dialog;
    GtkWidget *window, *frame, *vbox, *hbox, *hbox2, *anim_box;
    GtkWidget *notebook, *page, *button, *label, *entry, *scale;
    GSList *group=NULL;
    struct model_pak *data;

    /* checks */
    data = sysenv.active_model;
    if (!data)
        return;
    if (!data->animation)
        return;

    /* CURRENT */
    /*
    anim_read_all_frames(data);
    */

    /* prevent recording whilst in animation */
    gui_mode_switch(FREE);

    /* dialog setup */
    title = g_strdup_printf("Animation: %s", data->basename);
    dialog = dialog_request(ANIM, title, NULL, animate_cleanup, data);
    g_free(title);
    if (!dialog)
        return;
    window = dialog_window(dialog);

    /* notebook frame */
    frame = gtk_frame_new(NULL);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), frame, FALSE, FALSE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(frame), PANEL_SPACING);

    /* create notebook */
    notebook = gtk_notebook_new();
    gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
    gtk_container_add(GTK_CONTAINER(frame), notebook);
    gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), TRUE);

    /* page 1 */
    page = gtk_vbox_new(FALSE, PANEL_SPACING);
    label = gtk_label_new("Control");
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);

    /* general animation stuff */
    frame = gtk_frame_new(NULL);
    gtk_box_pack_start(GTK_BOX(page),frame,FALSE,FALSE,0);
    /* create a vbox in the frame */
    vbox = gtk_vbox_new(TRUE, PANEL_SPACING);
    gtk_container_add(GTK_CONTAINER(frame), vbox);

    /* num frames */
    hbox = gtk_hbox_new(FALSE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(hbox), PANEL_SPACING);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
    label = gtk_label_new("Number of frames:");
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
    tmp = g_strdup_printf("%9d", data->num_frames);
    label = gtk_label_new(tmp);
    g_free(tmp);
    gtk_box_pack_end(GTK_BOX(hbox), label, FALSE, FALSE, 0);

    /* desired delay */
    gui_direct_spin("Animation delay", &data->anim_speed,
                    1.0, 40.0, 1.0, NULL, NULL, vbox);

    gui_direct_spin("Animation step size ", &data->anim_step,
                    1.0, data->num_frames, 1.0, NULL, NULL, vbox);

    gui_direct_check("Don't recalculate connectivity", &data->anim_fix, NULL, NULL, vbox);

    gui_direct_check("Don't recalculate scale", &data->anim_noscale, NULL, NULL, vbox);

    gui_direct_check("Loop", &data->anim_loop, NULL, NULL, vbox);


    /* page 2 */
    page = gtk_vbox_new(FALSE, PANEL_SPACING);
    label = gtk_label_new("Processing");
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);

    /* cycle options */
    frame = gtk_frame_new(NULL);
    gtk_box_pack_start(GTK_BOX(page),frame,FALSE,FALSE,0);

    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(frame), vbox);
    gtk_container_set_border_width(GTK_CONTAINER(vbox), PANEL_SPACING);

    /* actions at start of each cycle */
    new_radio_group(0, vbox, FF);

    button = add_radio_button("Confine atoms to PBC", (gpointer) atom_pbc, data);
    if (data->anim_confine == PBC_CONFINE_ATOMS)
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);

    button = add_radio_button("Confine mols to PBC", (gpointer) mol_pbc, data);
    if (data->anim_confine == PBC_CONFINE_MOLS)
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);

    button = add_radio_button("Cell confinement off", (gpointer) no_pbc, data);
    if (data->anim_confine == PBC_CONFINE_NONE)
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);


    /* page 3 */
    page = gtk_vbox_new(FALSE, PANEL_SPACING);
    label = gtk_label_new("Rendering");
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);

    /* cycle options */
    frame = gtk_frame_new(NULL);
    gtk_box_pack_start(GTK_BOX(page), frame, FALSE, FALSE, 0);

    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(frame), vbox);
    gtk_container_set_border_width(GTK_CONTAINER(vbox), PANEL_SPACING);


    anim_box = gtk_vbox_new(TRUE, 0);
    gui_direct_check("Create movie", &sysenv.render.animate,
                     anim_render, anim_box, vbox);
    gtk_box_pack_end(GTK_BOX(vbox), anim_box, TRUE, TRUE, 0);


    /* sensitive box */
    vbox = gtk_vbox_new(FALSE,0);
    gtk_box_pack_start(GTK_BOX(anim_box), vbox, TRUE, TRUE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(vbox), PANEL_SPACING);


    /* start off with a button */
    button = gtk_radio_button_new_with_label (NULL, "Animated GIF");
    g_signal_connect(GTK_OBJECT(button), "clicked",
                     GTK_SIGNAL_FUNC(event_render_modify), (gpointer) button);
    gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, TRUE, 0);
    g_object_set_data(G_OBJECT(button), "id", (gpointer) ANIM_GIF);

    /* make a radio group */
    group = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
    /* do the rest of the buttons */
    button = gtk_radio_button_new_with_label(group, "MPEG");
    g_signal_connect(GTK_OBJECT(button), "clicked",
                     GTK_SIGNAL_FUNC(event_render_modify), (gpointer) button);
    gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, TRUE, 0);
    g_object_set_data(G_OBJECT(button), "id", (gpointer) ANIM_MPEG);

    /* movie creation parameters */
    gui_direct_spin("MPEG quality",
                    &sysenv.render.mpeg_quality, 1, 100, 1,
                    NULL, NULL, vbox);
    gui_direct_spin("Delay (ms)",
                    &sysenv.render.delay, 0, 100, 5,
                    NULL, NULL, vbox);

    /* file entry */
    hbox = gtk_hbox_new (FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,0);
    label = gtk_label_new("Filename ");
    gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
    entry = gtk_entry_new();
    gtk_box_pack_end(GTK_BOX (hbox), entry, FALSE, TRUE, 0);
    gtk_entry_set_text(GTK_ENTRY(entry), sysenv.render.animate_file);

    /* update hook */
    g_signal_connect(GTK_OBJECT(entry), "changed",
                     GTK_SIGNAL_FUNC(event_render_modify), (gpointer) entry);
    g_object_set_data(G_OBJECT(entry), "id", (gpointer) ANIM_NAME);

    /* misc options */
    /*
    gui_direct_check("Create povray input files then stop",
                       &sysenv.render.no_povray_exec,
                       NULL, NULL, vbox);
    gui_direct_check("Delete intermediate input/image files",
                       &sysenv.render.no_keep_tempfiles,
                       NULL, NULL, vbox);
    */


    /* set initial state */
    if (!sysenv.render.animate)
        gtk_widget_set_sensitive(anim_box, FALSE);


    /* NEW - slider for current frame */
    frame = gtk_frame_new(NULL);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), frame, FALSE, FALSE, 0);

    vbox = gtk_vbox_new(FALSE, PANEL_SPACING);
    gtk_container_add(GTK_CONTAINER(frame), vbox);

    scale = gui_direct_hscale(0, data->num_frames-1, 1, &data->cur_frame, select_frame, data, vbox);
    gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS);

    /* control buttons */
    hbox2 = gtk_hbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, PANEL_SPACING);
    hbox = gtk_hbox_new(TRUE, PANEL_SPACING);
    gtk_box_pack_start(GTK_BOX(hbox2), hbox, TRUE, FALSE, 0);

    gui_icon_button("GDIS_REWIND", NULL,
                    anim_rewind, dialog,
                    hbox);

    gui_icon_button("GDIS_STEP_BACKWARD", NULL,
                    anim_step_backward, dialog,
                    hbox);

    gui_icon_button("GDIS_PLAY", NULL,
                    anim_start, dialog,
                    hbox);

    gui_icon_button("GDIS_PAUSE", NULL,
                    anim_stop, dialog,
                    hbox);

    gui_icon_button("GDIS_STEP_FORWARD", NULL,
                    anim_step_forward, dialog,
                    hbox);

    gui_icon_button("GDIS_FASTFORWARD", NULL,
                    anim_fastforward, dialog,
                    hbox);

    gui_stock_button(GTK_STOCK_CLOSE, dialog_destroy, dialog,
                     GTK_DIALOG(window)->action_area);

    /* display the dialog */
    gtk_widget_show_all(window);

    gui_relation_update(data);
}
Exemplo n.º 17
0
static void
op_configure(void)
{
	GtkWidget *dev_vbox;
	GtkWidget *adevice_frame, *adevice_text, *adevice_vbox;
	GtkWidget *bbox, *ok, *cancel;

	if (configure_win) {
		gdk_window_raise(configure_win->window);
		return;
	}
	configure_win = gtk_window_new(GTK_WINDOW_DIALOG);
	gtk_signal_connect(GTK_OBJECT(configure_win), "destroy",
	    GTK_SIGNAL_FUNC(configure_win_destroy), NULL);

	gtk_window_set_title(GTK_WINDOW(configure_win), _("sndio device"));
	gtk_window_set_policy(GTK_WINDOW(configure_win), FALSE, FALSE, FALSE);
	gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE);
	gtk_container_border_width(GTK_CONTAINER(configure_win), 10);

	dev_vbox = gtk_vbox_new(FALSE, 5);
	gtk_container_add(GTK_CONTAINER(configure_win), dev_vbox);
	gtk_container_set_border_width(GTK_CONTAINER(dev_vbox), 5);

	adevice_frame = gtk_frame_new(_("Audio device:"));
	gtk_box_pack_start(GTK_BOX(dev_vbox), adevice_frame, FALSE, FALSE, 0);

	adevice_vbox = gtk_vbox_new(FALSE, 5);
	gtk_container_set_border_width(GTK_CONTAINER(adevice_vbox), 5);
	gtk_container_add(GTK_CONTAINER(adevice_frame), adevice_vbox);

	adevice_text = gtk_label_new(_("(empty means default)"));
	gtk_box_pack_start_defaults(GTK_BOX(adevice_vbox), adevice_text);

	adevice_entry = gtk_entry_new();
	gtk_entry_set_text(GTK_ENTRY(adevice_entry), audiodev);
	gtk_box_pack_start_defaults(GTK_BOX(adevice_vbox), adevice_entry);

	bbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
	gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
	gtk_box_pack_start(GTK_BOX(dev_vbox), bbox, FALSE, FALSE, 0);

	ok = gtk_button_new_with_label(_("OK"));
	gtk_signal_connect(GTK_OBJECT(ok), "clicked",
	    GTK_SIGNAL_FUNC(configure_win_ok_cb), NULL);

	GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
	gtk_widget_grab_default(ok);

	cancel = gtk_button_new_with_label(_("Cancel"));
	gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked",
	    GTK_SIGNAL_FUNC(configure_win_cancel_cb),
	    GTK_OBJECT(configure_win));

	GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);

	gtk_widget_show_all(configure_win);
}
Exemplo n.º 18
0
GtkWidget *build_joystick_status_widget(app_shell_type *as, GdkWindow *window)
{
    GtkWidget *joystick_box, *frame;
    int i = 0;
    char *empty = util_concat("<", _("empty"), ">", NULL);

    joystick_box = gtk_hbox_new(FALSE, 0);
    for (i = 0; i < JOYSTICK_NUM; i++)
    {
        /* skip port 2 for machines that only have one joystick port */
        if (((machine_class == VICE_MACHINE_VIC20) ||
             (machine_class == VICE_MACHINE_CBM6x0) ||
             (machine_class == VICE_MACHINE_PET)
            ) && (i == 1)) {
            as->joystick_status[i].led = NULL;
            continue;
        }
        /* skip port 3 and 4 for machines with no user port */
        if (((machine_class == VICE_MACHINE_CBM5x0)
            ) && (i > 1)) {
            as->joystick_status[i].led = NULL;
            continue;
        }
        /* skip port 4 */
        if (((machine_class == VICE_MACHINE_PLUS4)
            ) && (i > 2)) {
            as->joystick_status[i].led = NULL;
            continue;
        }

        as->joystick_status[i].event_box = gtk_event_box_new();

        frame = gtk_frame_new(NULL);
        gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);

        as->joystick_status[i].box = gtk_hbox_new(FALSE, 0);

        gtk_container_add(GTK_CONTAINER(frame), as->joystick_status[i].box);
        gtk_widget_show(as->joystick_status[i].box);

        gtk_container_add(GTK_CONTAINER(as->joystick_status[i].event_box), frame);
        gtk_widget_show(frame);
#if 0   /* FIXME */
        gtk_widget_set_tooltip_text(GTK_WIDGET(gtk_widget_get_parent(gtk_widget_get_parent(as->joystick_status[i].box))), empty);
#endif
        /* Single Led */
#if !defined(HAVE_CAIRO)
        as->joystick_status[i].led_pixmap = gdk_pixmap_new(window, JOY_AREA_WIDTH, JOY_AREA_HEIGHT, -1);
        as->joystick_status[i].led = gtk_image_new_from_pixmap(as->joystick_status[i].led_pixmap, NULL);
#else
        as->joystick_status[i].led = gtk_drawing_area_new();
#endif
        gtk_widget_set_size_request(as->joystick_status[i].led, JOY_AREA_WIDTH, JOY_AREA_HEIGHT);
        gtk_box_pack_start(GTK_BOX(as->joystick_status[i].box), (GtkWidget *)as->joystick_status[i].led, FALSE, FALSE, 4);
        gtk_widget_show(as->joystick_status[i].led);

        /* Pack everything together */
        gtk_box_pack_start(GTK_BOX(joystick_box), as->joystick_status[i].event_box, FALSE, FALSE, 0);

        gtk_widget_set_events(as->joystick_status[i].event_box, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK);
        g_signal_connect(G_OBJECT(as->joystick_status[i].event_box), "button-press-event", G_CALLBACK(joystick_popup_cb), (gpointer)(int_to_void_ptr(i)));
        gtk_widget_show(as->joystick_status[i].event_box);

#if defined(HAVE_CAIRO)
#if GTK_CHECK_VERSION(3, 0, 0)
        g_signal_connect(G_OBJECT(as->joystick_status[i].led), "draw", G_CALLBACK(joys_draw), int_to_void_ptr(i));
#else
        g_signal_connect(G_OBJECT(as->joystick_status[i].led), "expose-event", G_CALLBACK(joys_draw), int_to_void_ptr(i));
#endif
#endif
    }
    lib_free(empty);
    return joystick_box;
}
void
sp_text_edit_dialog (void)
{
    if (!dlg) {

        gchar title[500];
        sp_ui_dialog_title_string (Inkscape::Verb::get(SP_VERB_DIALOG_TEXT), title);
        Inkscape::Preferences *prefs = Inkscape::Preferences::get();

        dlg = sp_window_new (title, TRUE);
        if (x == -1000 || y == -1000) {
            x = prefs->getInt(prefs_path + "x", -1000);
            y = prefs->getInt(prefs_path + "y", -1000);
        }
        if (w ==0 || h == 0) {
            w = prefs->getInt(prefs_path + "w", 0);
            h = prefs->getInt(prefs_path + "h", 0);
        }

//        if (x<0) x=0;
//        if (y<0) y=0;

        if (w && h)
            gtk_window_resize ((GtkWindow *) dlg, w, h);
        if (x >= 0 && y >= 0 && (x < (gdk_screen_width()-MIN_ONSCREEN_DISTANCE)) && (y < (gdk_screen_height()-MIN_ONSCREEN_DISTANCE))) {
            gtk_window_move ((GtkWindow *) dlg, x, y);
        } else {
            gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
        }


        sp_transientize (dlg);
        wd.win = dlg;
        wd.stop = 0;
        g_signal_connect ( G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd );

        gtk_signal_connect ( GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg );

        gtk_signal_connect ( GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_text_edit_dialog_destroy), dlg );
        gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg );
        g_signal_connect ( G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg );

        g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg );
        g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg );

        gtk_window_set_policy (GTK_WINDOW (dlg), TRUE, TRUE, FALSE);

        GtkTooltips *tt = gtk_tooltips_new();

        // box containing the notebook and the bottom buttons
        GtkWidget *mainvb = gtk_vbox_new (FALSE, 0);
        gtk_container_add (GTK_CONTAINER (dlg), mainvb);

        // notebook
        GtkWidget *nb = gtk_notebook_new ();
        gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0);
        g_object_set_data (G_OBJECT (dlg), "notebook", nb);



        // Font tab
        {
            GtkWidget *l = gtk_label_new (_("Font"));
            GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN);
            gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN);
            gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);

            /* HBox containing font selection and layout */
            GtkWidget *hb = gtk_hbox_new (FALSE, 0);
            gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0);

            // font and style selector
            GtkWidget *fontsel = sp_font_selector_new ();
            g_signal_connect ( G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg );

            g_signal_connect_swapped ( G_OBJECT (g_object_get_data (G_OBJECT(fontsel), "family-treeview")),
                                      "row-activated",
                                      G_CALLBACK (gtk_window_activate_default),
                                      dlg);

            gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0);
            g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel);

            // Layout
            {
                GtkWidget *f = gtk_frame_new (_("Layout"));
                gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4);
                GtkWidget *l_vb = gtk_vbox_new (FALSE, VB_MARGIN);
                gtk_container_add (GTK_CONTAINER (f), l_vb);

                {
                    GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
                    GtkWidget *group;

                    // align left
                    {
                        // TODO - replace with Inkscape-specific call
                        GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR );
                        GtkWidget *b = group = gtk_radio_button_new (NULL);
                        gtk_tooltips_set_tip (tt, b, _("Align lines left"), NULL);
                        gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
                        g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
                        gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE );
                        gtk_container_add (GTK_CONTAINER (b), px);
                        gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
                        g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b);
                    }

                    // align center
                    {
                        // TODO - replace with Inkscape-specific call
                        GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR );
                        GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
                        /* TRANSLATORS: `Center' here is a verb. */
                        gtk_tooltips_set_tip (tt, b, _("Center lines"), NULL);
                        gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
                        g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
                        gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
                        gtk_container_add (GTK_CONTAINER (b), px);
                        gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
                        g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b);
                    }

                    // align right
                    {
                        // TODO - replace with Inkscape-specific call
                        GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR );
                        GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
                        gtk_tooltips_set_tip (tt, b, _("Align lines right"), NULL);
                        gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
                        g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
                        gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
                        gtk_container_add (GTK_CONTAINER (b), px);
                        gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
                        g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b);
                    }

                    // align justify
                    {
                        // TODO - replace with Inkscape-specific call
                        GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_LARGE_TOOLBAR );
                        GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
                        gtk_tooltips_set_tip (tt, b, _("Justify lines"), NULL);
                        gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
                        g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
                        gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
                        gtk_container_add (GTK_CONTAINER (b), px);
                        gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
                        g_object_set_data (G_OBJECT (dlg), "text_anchor_justify", b);
                    }

                    gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
                }


                {
                    GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
                    GtkWidget *group;

                    // horizontal
                    {
                        GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
                                                      INKSCAPE_STOCK_WRITING_MODE_LR );
                        GtkWidget *b = group = gtk_radio_button_new (NULL);
                        gtk_tooltips_set_tip (tt, b, _("Horizontal text"), NULL);
                        gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
                        g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
                        gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
                        gtk_container_add (GTK_CONTAINER (b), px);
                        gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
                        g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_LR, b);
                    }

                    // vertical
                    {
                        GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
                                                      INKSCAPE_STOCK_WRITING_MODE_TB );
                        GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
                        gtk_tooltips_set_tip (tt, b, _("Vertical text"), NULL);
                        gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
                        g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
                        gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
                        gtk_container_add (GTK_CONTAINER (b), px);
                        gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
                        g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_TB, b);
                    }

                    gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
                }

                {
                    GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);

                    l = gtk_label_new (_("Line spacing:"));
                    gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
                    gtk_box_pack_start (GTK_BOX (row), l, FALSE, FALSE, VB_MARGIN);

                    gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
                }

                {
                    GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);

                    GtkWidget *c = gtk_combo_new ();
                    gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE);
                    gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE);
                    gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE);
                    gtk_widget_set_size_request (c, 90, -1);

                    { /* Setup strings */
                        GList *sl = NULL;
                        for (int i = 0; spacings[i]; i++) {
                            sl = g_list_prepend (sl, (void *) spacings[i]);
                        }
                        sl = g_list_reverse (sl);
                        gtk_combo_set_popdown_strings ((GtkCombo *) c, sl);
                        g_list_free (sl);
                    }

                    g_signal_connect ( (GObject *) ((GtkCombo *) c)->entry,
                                       "changed",
                                       (GCallback) sp_text_edit_dialog_line_spacing_changed,
                                       dlg );
                    gtk_box_pack_start (GTK_BOX (row), c, FALSE, FALSE, VB_MARGIN);
                    g_object_set_data (G_OBJECT (dlg), "line_spacing", c);

                    gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, VB_MARGIN);
                }
            }

            /* Font preview */
            GtkWidget *preview = sp_font_preview_new ();
            gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4);
            g_object_set_data (G_OBJECT (dlg), "preview", preview);
        }


        // Text tab
        {
            GtkWidget *l = gtk_label_new (_("Text"));
            GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN);
            gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN);
            gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);

            GtkWidget *scroller = gtk_scrolled_window_new ( NULL, NULL );
            gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scroller),
                                             GTK_POLICY_AUTOMATIC,
                                             GTK_POLICY_AUTOMATIC );
            gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW(scroller), GTK_SHADOW_IN );
            gtk_widget_show (scroller);

            GtkTextBuffer *tb = gtk_text_buffer_new (NULL);
            GtkWidget *txt = gtk_text_view_new_with_buffer (tb);
            gtk_text_view_set_wrap_mode ((GtkTextView *) txt, GTK_WRAP_WORD);
#ifdef WITH_GTKSPELL
            GError *error = NULL;
            char *errortext = NULL;
            /* todo: Use computed xml:lang attribute of relevant element, if present, to specify the
               language (either as 2nd arg of gtkspell_new_attach, or with explicit
               gtkspell_set_language call in; see advanced.c example in gtkspell docs).
               sp_text_edit_dialog_read_selection looks like a suitable place. */
            if (gtkspell_new_attach(GTK_TEXT_VIEW(txt), NULL, &error) == NULL) {
                g_print("gtkspell error: %s\n", error->message);
                errortext = g_strdup_printf("GtkSpell was unable to initialize.\n"
                                            "%s", error->message);
                g_error_free(error);
            }
#endif
            gtk_widget_set_size_request (txt, -1, 64);
            gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE);
            gtk_container_add (GTK_CONTAINER (scroller), txt);
            gtk_box_pack_start (GTK_BOX (vb), scroller, TRUE, TRUE, 0);
            g_signal_connect ( G_OBJECT (tb), "changed",
                               G_CALLBACK (sp_text_edit_dialog_text_changed), dlg );
            g_signal_connect (G_OBJECT (txt), "focus-in-event", G_CALLBACK (text_view_focus_in), dlg);
            g_signal_connect (G_OBJECT (txt), "focus-out-event", G_CALLBACK (text_view_focus_out), dlg);
            g_object_set_data (G_OBJECT (dlg), "text", tb);
            g_object_set_data (G_OBJECT (dlg), "textw", txt);
        }

        /* Buttons */
        GtkWidget *hb = gtk_hbox_new (FALSE, VB_MARGIN);
        gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
        gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0);

        {
            GtkWidget *b = gtk_button_new_with_label (_("Set as default"));
            g_signal_connect ( G_OBJECT (b), "clicked",
                               G_CALLBACK (sp_text_edit_dialog_set_default),
                               dlg );
            gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
            g_object_set_data (G_OBJECT (dlg), "default", b);
        }

        {
            GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
            g_signal_connect ( G_OBJECT (b), "clicked",
                               G_CALLBACK (sp_text_edit_dialog_close), dlg );
            gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
        }

        {
            GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_APPLY);
            GTK_WIDGET_SET_FLAGS (b, GTK_CAN_DEFAULT | GTK_HAS_DEFAULT);
            g_signal_connect ( G_OBJECT (b), "clicked",
                               G_CALLBACK (sp_text_edit_dialog_apply), dlg );
            gtk_box_pack_end ( GTK_BOX (hb), b, FALSE, FALSE, 0 );
            g_object_set_data (G_OBJECT (dlg), "apply", b);
        }

        g_signal_connect ( G_OBJECT (INKSCAPE), "modify_selection",
                           G_CALLBACK (sp_text_edit_dialog_selection_modified), dlg);
        g_signal_connect ( G_OBJECT (INKSCAPE), "change_selection",
                           G_CALLBACK (sp_text_edit_dialog_selection_changed), dlg);
        g_signal_connect (INKSCAPE, "change_subselection", G_CALLBACK (sp_text_edit_dialog_subselection_changed), dlg);

        gtk_widget_show_all (dlg);

        sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE);
    }

    gtk_window_present ((GtkWindow *) dlg);

} // end of sp_text_edit_dialog()
//==============================================================================
// GOBJECT RELATED FUNCTIONS						       =
//==============================================================================
static void gebr_gui_sequence_edit_set_property (GObject *object,
						 guint property_id,
						 const GValue *value,
						 GParamSpec *param_spec)
{
	GebrGuiSequenceEdit *self;

	self = GEBR_GUI_SEQUENCE_EDIT (object);

	switch (property_id) {
	case VALUE_WIDGET:
		self->widget = g_value_get_pointer(value);
		gtk_box_pack_start(GTK_BOX(self->widget_hbox), self->widget, TRUE, TRUE, 0);
		break;
	case LIST_STORE: {
		GtkWidget *container;
		GtkWidget *tree_view;

		self->list_store = g_value_get_pointer(value);

		if (self->list_store == NULL)
			self->list_store = gtk_list_store_new(1, G_TYPE_STRING, -1);

		tree_view = GEBR_GUI_SEQUENCE_EDIT_GET_CLASS (self)->create_tree_view (self);

		self->priv->keypress_handler =
				g_signal_connect(tree_view, "key-release-event",
				                 G_CALLBACK (on_tree_view_key_release), self);

		gebr_gui_gtk_tree_view_set_reorder_callback(GTK_TREE_VIEW(tree_view),
							    (GebrGuiGtkTreeViewReorderCallback)
							    on_reorder, NULL,
							    self);
		self->tree_view = tree_view;

		if (self->has_scroll) {
			container = gtk_scrolled_window_new(NULL, NULL);
			gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (container), GTK_SHADOW_IN);
			gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (container),
							GTK_POLICY_AUTOMATIC,
							GTK_POLICY_AUTOMATIC);
		} else {
			container = gtk_frame_new(NULL);
			gtk_frame_set_shadow_type(GTK_FRAME(container), GTK_SHADOW_IN);
			g_signal_connect(tree_view, "size-request",
					 G_CALLBACK(on_tree_view_size_request), NULL);
		}
		gtk_container_add(GTK_CONTAINER(container), tree_view);
		gtk_box_pack_start(GTK_BOX(self), container, TRUE, TRUE, 0);
		gtk_widget_show_all(container);
		gebr_gui_gtk_tree_view_set_popup_callback(GTK_TREE_VIEW(tree_view), (GebrGuiGtkPopupCallback)
							  popup_menu, self);

		break;
	}
	case MAY_RENAME:
		self->may_rename = g_value_get_boolean(value);
		g_object_set(self->renderer, "editable", self->may_rename, NULL);
		break;
	case HAS_SCROLL:
		self->has_scroll = g_value_get_boolean(value);
		break;
	default:
		/*We don't have any other property... */
		G_OBJECT_WARN_INVALID_PROPERTY_ID(self, property_id, param_spec);
		break;
	}
}
Exemplo n.º 21
0
void cartesianMover::cartesian_table_open(GtkButton *button, cartesianMover *cm)
{

    //int *joint = currentClassData->indexPointer;
    /*ipos = currentPart->pos;
    iiencs = currentPart->iencs;
    iamp   = currentPart->amp;
    ipid   = currentPart->pid;
    */
    GtkWidget *winTable = NULL;

    //adding a popup window
    winTable = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW (winTable), cm->partLabel);
    gtk_window_set_default_size((GtkWindow*) winTable, 300, 300);

    //creating a new box
    GtkWidget *bottom_hbox = gtk_hbox_new (FALSE, 8);
    gtk_container_set_border_width (GTK_CONTAINER (bottom_hbox), 10);
    gtk_container_add (GTK_CONTAINER (winTable), bottom_hbox);

    //In the bottom frame there is:
    //1) the list of the cards
    GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL);
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_start (GTK_BOX (bottom_hbox), sw, TRUE, TRUE, 0);

    //GtkTreeModel *myModel = currentPart->model;
    //GtkWidget *myTreeview = currentPart->treeview;
    GtkTreeModel *myModel = refresh_cartesian_list_model(cm);

    //create tree view
    GtkTreeSelection *treeSelection2 	= NULL;
    GtkWidget *myTreeview = gtk_tree_view_new_with_model (myModel);
    cm->treeview=myTreeview;

    gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (myTreeview), TRUE);
    treeSelection2 = gtk_tree_view_get_selection(GTK_TREE_VIEW(myTreeview));
    gtk_tree_selection_set_mode(treeSelection2, GTK_SELECTION_SINGLE);
    g_signal_connect (myTreeview, "row-activated", G_CALLBACK (cm->cartesian_line_click), cm);

    //g_object_unref (myModel);
    gtk_container_add (GTK_CONTAINER (sw), myTreeview);

    // add columns to the tree view
    add_cartesian_columns (GTK_TREE_VIEW (myTreeview), cm);

    //creating a new box
    GtkWidget *inv1 = gtk_fixed_new();
    GtkWidget *frame1 = gtk_frame_new ("Commands");
    gtk_container_add (GTK_CONTAINER (bottom_hbox), inv1);
    gtk_widget_set_size_request 	(frame1, 150, 400);
    gtk_fixed_put (GTK_FIXED (inv1), frame1, 10, 10);
    //GtkWidget *bottom_box = gtk_vbox_new (FALSE, 8);
    //gtk_container_set_border_width (GTK_CONTAINER (bottom_box), 10);
    //gtk_container_add (GTK_CONTAINER (bottom_hbox), bottom_box);

    //Button Go! in the panel
    cm->buttonGo = gtk_button_new_with_mnemonic ("Go!");
    gtk_widget_set_size_request 	(cm->buttonGo, 100, 30);
    gtk_fixed_put (GTK_FIXED (inv1), cm->buttonGo, 30, 30);
    g_signal_connect (cm->buttonGo, "clicked", G_CALLBACK (go_click), cm);

    //Button "Save Sequence" in the panel
    cm->buttonSave = gtk_button_new_with_mnemonic ("Save");
    gtk_widget_set_size_request 	(cm->buttonSave, 100, 30);
    gtk_fixed_put (GTK_FIXED (inv1), cm->buttonSave, 30, 130);
    g_signal_connect (cm->buttonSave, "clicked", G_CALLBACK (sequence_save), cm);

    //Button "Load Sequence" in the panel
    cm->buttonLoad = gtk_file_chooser_button_new ("Load Seqeunce", GTK_FILE_CHOOSER_ACTION_OPEN);
    gtk_widget_set_size_request 	(cm->buttonLoad, 100, 30);
    gtk_fixed_put (GTK_FIXED (inv1), cm->buttonLoad, 30, 180);
    g_signal_connect (cm->buttonLoad, "selection-changed", G_CALLBACK (sequence_load), cm);
    //g_signal_connect (button4, "clicked", G_CALLBACK (sequence_load),this);

    //Button "Cycle Sequence (time)" in the panel
    cm->buttonCycTim = gtk_button_new_with_mnemonic ("Cycle (time)");
    gtk_widget_set_size_request 	(cm->buttonCycTim, 100, 30);
    gtk_fixed_put (GTK_FIXED (inv1), cm->buttonCycTim, 30, 280);
    g_signal_connect (cm->buttonCycTim, "clicked", G_CALLBACK (cm->sequence_cycle_time), cm);


    //Button "Stop Sequence" in the panel
    cm->buttonStp = gtk_button_new_with_mnemonic ("Stop");
    gtk_widget_set_size_request 	(cm->buttonStp, 100, 30);
    gtk_fixed_put (GTK_FIXED (inv1), cm->buttonStp, 30, 330);
    g_signal_connect (cm->buttonStp, "clicked", G_CALLBACK (cm->sequence_stop),cm);


    //connection to the destroyer
    //g_signal_connect (winTable, "destroy",G_CALLBACK (destroy_main), &winTable);
    g_signal_connect (winTable, "destroy",G_CALLBACK (destroy_main), cm);
    //make it visible
    if (!GTK_WIDGET_VISIBLE (winTable))
        gtk_widget_show_all (winTable);
    else
    {
        //fprintf(stderr, "Reinitializing all pointers\n");
        //currentPart->button8 = NULL;
        gtk_widget_destroy (winTable);
        winTable = NULL;
    }

    gtk_main ();

    return;
}
Exemplo n.º 22
0
/*****************************************************************************
  Create citizens dialog
*****************************************************************************/
static struct citizens_dialog
  *citizens_dialog_create(const struct city *pcity)
{
  GtkWidget *frame, *sw;
  struct citizens_dialog *pdialog = fc_malloc(sizeof(struct citizens_dialog));
  int i;

  pdialog->pcity = pcity;
  pdialog->store = citizens_dialog_store_new();
  pdialog->sort
    = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(pdialog->store));
  g_object_unref(pdialog->store);

  gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(pdialog->sort),
                                       citizens_dialog_default_sort_column(),
                                       GTK_SORT_DESCENDING);

  pdialog->list
    = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pdialog->sort));
  gtk_widget_set_halign(pdialog->list, GTK_ALIGN_CENTER);
  g_object_unref(pdialog->sort);

  for (i = 0; i < num_citizens_cols; i++) {
    struct citizens_column *pcol;
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *col;

    pcol = &citizens_cols[i];
    col = NULL;

    switch (pcol->type) {
    case COL_FLAG:
      renderer = gtk_cell_renderer_pixbuf_new();
      col = gtk_tree_view_column_new_with_attributes(_(pcol->title), renderer,
              "pixbuf", i, NULL);
      break;
    case COL_TEXT:
      renderer = gtk_cell_renderer_text_new();
      g_object_set(renderer, "style-set", TRUE, "weight-set", TRUE, NULL);

      col = gtk_tree_view_column_new_with_attributes(_(pcol->title), renderer,
              "text", i,
              "style", CITIZENS_DLG_COL_STYLE,
              "weight", CITIZENS_DLG_COL_WEIGHT,
              NULL);
      gtk_tree_view_column_set_sort_column_id(col, i);
      break;
    case COL_RIGHT_TEXT:
      renderer = gtk_cell_renderer_text_new();
      g_object_set(renderer, "style-set", TRUE, "weight-set", TRUE, NULL);

      col = gtk_tree_view_column_new_with_attributes(_(pcol->title), renderer,
              "text", i,
              "style", CITIZENS_DLG_COL_STYLE,
              "weight", CITIZENS_DLG_COL_WEIGHT,
              NULL);
      gtk_tree_view_column_set_sort_column_id(col, i);
      g_object_set(renderer, "xalign", 1.0, NULL);
      gtk_tree_view_column_set_alignment(col, 1.0);
      break;
    case COL_COLOR:
    case COL_BOOLEAN:
      /* These are not used. */
      fc_assert(pcol->type != COL_COLOR && pcol->type != COL_BOOLEAN);
      continue;
    }

    if (col) {
      gtk_tree_view_append_column(GTK_TREE_VIEW(pdialog->list), col);
    }
  }

  gtk_widget_set_hexpand(GTK_WIDGET(pdialog->list), TRUE);
  gtk_widget_set_vexpand(GTK_WIDGET(pdialog->list), TRUE);

  sw = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
                                 GTK_POLICY_AUTOMATIC,
                                 GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
                                      GTK_SHADOW_NONE);
  gtk_container_add(GTK_CONTAINER(sw), pdialog->list);

  frame = gtk_frame_new(_("Citizens"));
  gtk_container_add(GTK_CONTAINER(frame), sw);

  pdialog->shell = frame;

  dialog_list_prepend(dialog_list, pdialog);

  citizens_dialog_refresh(pcity);

  return pdialog;
}
Exemplo n.º 23
0
static GtkWidget *
do_image (const char *filename)
{
  GtkWidget *frame;
  GtkWidget *vbox;
  GtkWidget *image;
  GtkWidget *label;
  GtkWidget *align;
  GtkWidget *window;
  gchar *str, *escaped;
  LoadContext *lc;
  
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), "Image Loading");

  gtk_container_set_border_width (GTK_CONTAINER (window), 8);

  vbox = gtk_vbox_new (FALSE, 8);
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
  gtk_container_add (GTK_CONTAINER (window), vbox);

  label = gtk_label_new (NULL);
  gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
  escaped = g_markup_escape_text (filename, -1);
  str = g_strdup_printf ("Progressively loading: <b>%s</b>", escaped);
  gtk_label_set_markup (GTK_LABEL (label),
                        str);
  g_free (escaped);
  g_free (str);
  
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
      
  frame = gtk_frame_new (NULL);
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  /* The alignment keeps the frame from growing when users resize
   * the window
   */
  align = gtk_alignment_new (0.5, 0.5, 0, 0);
  gtk_container_add (GTK_CONTAINER (align), frame);
  gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0);      

  image = gtk_image_new_from_pixbuf (NULL);
  gtk_container_add (GTK_CONTAINER (frame), image);

  lc = get_load_context (image);

  lc->window = window;
  lc->filename = g_strdup (filename);
  
  start_progressive_loading (image);

  g_signal_connect (window, "destroy",
		    G_CALLBACK (gtk_main_quit), NULL);
  
  g_signal_connect (window, "delete_event",
		    G_CALLBACK (gtk_main_quit), NULL);

  gtk_widget_show_all (window);

  return window;
}
Exemplo n.º 24
0
static void
scrollable_policy (void)
{
  GtkWidget *window, *swindow, *hbox, *vbox, *frame, *cntl, *listbox;
  GtkWidget *viewport, *label, *expander, *widget, *popover;

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  hbox   = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
  vbox   = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

  gtk_container_set_border_width (GTK_CONTAINER (window), 8);

  gtk_widget_show (vbox);
  gtk_widget_show (hbox);
  gtk_container_add (GTK_CONTAINER (window), hbox);
  gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);

  frame = gtk_frame_new ("Scrolled Window");
  gtk_widget_show (frame);
  gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);

  swindow = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  
  gtk_widget_show (swindow);
  gtk_container_add (GTK_CONTAINER (frame), swindow);

  viewport = gtk_viewport_new (NULL, NULL);
  label = gtk_label_new ("Here is a wrapping label with a minimum width-chars of 40 and "
			 "a natural max-width-chars of 100 to demonstrate the usage of "
			 "scrollable widgets \"hscroll-policy\" and \"vscroll-policy\" "
			 "properties. Note also that when playing with the window height, "
			 "one can observe that the vscrollbar disappears as soon as there "
			 "is enough height to fit the content vertically if the window were "
			 "to be allocated a width without a vscrollbar present");

  gtk_label_set_line_wrap  (GTK_LABEL (label), TRUE);
  gtk_label_set_width_chars  (GTK_LABEL (label), 40);
  gtk_label_set_max_width_chars  (GTK_LABEL (label), 100);

  gtk_widget_show (label);
  gtk_widget_show (viewport);
  gtk_container_add (GTK_CONTAINER (viewport), label);
  gtk_container_add (GTK_CONTAINER (swindow), viewport);

  /* Add controls here */
  expander = gtk_expander_new ("Controls");
  gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
  cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
  gtk_widget_show (cntl);
  gtk_widget_show (expander);
  gtk_container_add (GTK_CONTAINER (expander), cntl);
  gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);

  /* Add Horizontal policy control here */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
  gtk_widget_show (hbox);

  widget = gtk_label_new ("hscroll-policy");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);

  widget = gtk_combo_box_text_new ();
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Minimum");
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Natural");
  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
  gtk_widget_show (widget);

  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0);

  g_signal_connect (G_OBJECT (widget), "changed",
                    G_CALLBACK (horizontal_policy_changed), viewport);

  /* Add Vertical policy control here */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
  gtk_widget_show (hbox);

  widget = gtk_label_new ("vscroll-policy");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);

  widget = gtk_combo_box_text_new ();
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Minimum");
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Natural");
  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
  gtk_widget_show (widget);

  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0);

  g_signal_connect (G_OBJECT (widget), "changed",
                    G_CALLBACK (vertical_policy_changed), viewport);

  /* Content size controls */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);

  widget = gtk_label_new ("min-content-width");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);

  widget = gtk_spin_button_new_with_range (100.0, 1000.0, 10.0);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0);
  gtk_widget_show (widget);
  gtk_widget_show (hbox);

  g_signal_connect (G_OBJECT (widget), "value-changed",
                    G_CALLBACK (content_width_changed), swindow);

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);

  widget = gtk_label_new ("min-content-height");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);

  widget = gtk_spin_button_new_with_range (100.0, 1000.0, 10.0);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0);
  gtk_widget_show (widget);
  gtk_widget_show (hbox);

  g_signal_connect (G_OBJECT (widget), "value-changed",
                    G_CALLBACK (content_height_changed), swindow);

  /* Add Label orientation control here */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
  gtk_widget_show (hbox);

  widget = gtk_label_new ("label-flip");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);

  widget = gtk_combo_box_text_new ();
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
  gtk_widget_show (widget);

  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (cntl), hbox, FALSE, FALSE, 0);

  g_signal_connect (G_OBJECT (widget), "changed",
                    G_CALLBACK (label_flip_changed), label);

  /* Add Kinetic scrolling control here */
  widget = gtk_check_button_new_with_label ("Kinetic scrolling");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (cntl), widget, TRUE, TRUE, 0);
  g_signal_connect (G_OBJECT (widget), "toggled",
                    G_CALLBACK (kinetic_scrolling_changed), swindow);

  gtk_widget_show (window);

  /* Popover */
  popover = gtk_popover_new (NULL);

  widget = gtk_menu_button_new ();
  gtk_menu_button_set_popover (GTK_MENU_BUTTON (widget), popover);
  gtk_container_add (GTK_CONTAINER (widget), gtk_label_new ("Popover"));
  gtk_box_pack_start (GTK_BOX (cntl), widget, FALSE, FALSE, 0);
  gtk_widget_show_all (widget);

  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
  gtk_container_add (GTK_CONTAINER (popover), vbox);
  gtk_widget_show (vbox);

  /* Popover's scrolled window */
  swindow = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

  gtk_box_pack_end (GTK_BOX (vbox), swindow, FALSE, FALSE, 0);
  gtk_widget_show (swindow);
  gtk_widget_show (hbox);

  /* Listbox */
  listbox = gtk_list_box_new ();
  gtk_container_add (GTK_CONTAINER (swindow), listbox);
  gtk_widget_show (listbox);

  /* Min content */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);

  widget = gtk_label_new ("min-content-width");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);

  widget = gtk_spin_button_new_with_range (0.0, 150.0, 10.0);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_widget_show (widget);
  gtk_widget_show (hbox);

  g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)),
                          "value",
                          swindow,
                          "min-content-width",
                          G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);

  widget = gtk_label_new ("min-content-height");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);


  widget = gtk_spin_button_new_with_range (0.0, 150.0, 10.0);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  gtk_widget_show (widget);
  gtk_widget_show (hbox);

  g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)),
                          "value",
                          swindow,
                          "min-content-height",
                          G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);

  /* Max content */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);

  widget = gtk_label_new ("max-content-width");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);

  widget = gtk_spin_button_new_with_range (250.0, 1000.0, 10.0);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_widget_show (widget);
  gtk_widget_show (hbox);

  g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)),
                          "value",
                          swindow,
                          "max-content-width",
                          G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);

  widget = gtk_label_new ("max-content-height");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);

  widget = gtk_spin_button_new_with_range (250.0, 1000.0, 10.0);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  gtk_widget_show (widget);
  gtk_widget_show (hbox);

  g_object_bind_property (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)),
                          "value",
                          swindow,
                          "max-content-height",
                          G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);

  /* Add and Remove buttons */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);

  widget = gtk_button_new_with_label ("Remove");
  gtk_widget_show (widget);
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);

  g_signal_connect (widget, "clicked",
                    G_CALLBACK (remove_row), listbox);

  widget = gtk_button_new_with_label ("Add");
  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  gtk_widget_show (widget);
  gtk_widget_show (hbox);

  g_signal_connect (widget, "clicked",
                    G_CALLBACK (add_row), listbox);
}
Exemplo n.º 25
0
int main(int argc, char *argv[]) {
	gtk_init(&argc, &argv);

	GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
	gtk_window_set_title(GTK_WINDOW(window), "Label Demo");

	GtkWidget *hbox = gtk_hbox_new(FALSE, 5);
	gtk_container_add(GTK_CONTAINER(window), hbox);
	gtk_widget_show(hbox);

	GtkWidget *vbox = gtk_vbox_new(FALSE, 5);
	gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
	gtk_widget_show(vbox);

	GtkWidget *frame;
	GtkWidget *label;

	frame = gtk_frame_new("Normal Label");
	label = gtk_label_new("This is a normal label.");
	gtk_container_add(GTK_CONTAINER(frame), label);
	gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
	
	frame = gtk_frame_new("Multi-line Label");
	label = gtk_label_new("This is a Multi-line \n label.");
	gtk_container_add(GTK_CONTAINER(frame), label);
	gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
	
	frame = gtk_frame_new("Left Justed Label");
	label = gtk_label_new("Left?.\nThis is the second line.");
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
	gtk_container_add(GTK_CONTAINER(frame), label);
	gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
	
	frame = gtk_frame_new("Right Justed Label");
	label = gtk_label_new("Right?.\nThis is the second line.");
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT);
	gtk_container_add(GTK_CONTAINER(frame), label);
	gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
	
	vbox = gtk_vbox_new(FALSE, 5);
	gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);

	frame = gtk_frame_new("Line wrapped label");
	label = gtk_label_new("This is an example of a line-warpped label. It should not be taking up the entire width allocated to it, but automatically wraps the words to fit.");
	gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
	gtk_container_add(GTK_CONTAINER(frame), label);
	gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);

	frame = gtk_frame_new("Filled, wrapped label");
	label = gtk_label_new("This is an example of a line-warpped label. It should not be taking up the entire width allocated to it, but automatically wraps the words to fit.");
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_FILL);
	gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
	gtk_container_add(GTK_CONTAINER(frame), label);
	gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);

	frame = gtk_frame_new("Filled, wrapped label");
	label = gtk_label_new("This is an example of a line-warpped \nlabel. It should not be taking up the entire width allocated to it, but automatically wraps the words to fit.");
	gtk_label_set_pattern(GTK_LABEL(label), "_ _ ");
	gtk_container_add(GTK_CONTAINER(frame), label);
	gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);

	gtk_widget_show_all(window);
	gtk_main();
	return 0;
}
Exemplo n.º 26
0
/* Create actual buttons */
GtkWidget *
create_zoom_buttons (void)
{
GtkWidget *table;
GtkWidget *table2;
GtkWidget *frame;
GtkWidget *main_vbox;
GtkWidget *b1;
GtkWidget *b2;
GtkWidget *b3;
GtkWidget *b4;
GtkWidget *b5;
GtkWidget *b6;
GtkWidget *pixmapzout, *pixmapzin, *pixmapzfit, *pixmapzundo;
GtkWidget *pixmapzleft, *pixmapzright;

GtkTooltips *tooltips;

tooltips=gtk_tooltips_new_2();
gtk_tooltips_set_delay_2(tooltips,1500);

pixmapzin=gtk_pixmap_new(GLOBALS->zoomin_pixmap, GLOBALS->zoomin_mask);
gtk_widget_show(pixmapzin);
pixmapzout=gtk_pixmap_new(GLOBALS->zoomout_pixmap, GLOBALS->zoomout_mask);
gtk_widget_show(pixmapzout);
pixmapzfit=gtk_pixmap_new(GLOBALS->zoomfit_pixmap, GLOBALS->zoomfit_mask);
gtk_widget_show(pixmapzfit);
pixmapzundo=gtk_pixmap_new(GLOBALS->zoomundo_pixmap, GLOBALS->zoomundo_mask);
gtk_widget_show(pixmapzundo);

pixmapzleft=gtk_pixmap_new(GLOBALS->zoom_larrow_pixmap, GLOBALS->zoom_larrow_mask);
gtk_widget_show(pixmapzleft);
pixmapzright=gtk_pixmap_new(GLOBALS->zoom_rarrow_pixmap, GLOBALS->zoom_rarrow_mask);
gtk_widget_show(pixmapzright);


/* Create a table to hold the text widget and scrollbars */
table = gtk_table_new (1, 1, FALSE);

main_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_border_width (GTK_CONTAINER (main_vbox), 1);
gtk_container_add (GTK_CONTAINER (table), main_vbox);

frame = gtk_frame_new ("Zoom ");
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
gtk_widget_show (main_vbox);

table2 = gtk_table_new (2, 3, FALSE);

b1 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b1), pixmapzin);
gtk_table_attach (GTK_TABLE (table2), b1, 0, 1, 0, 1,
		      	GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b1), "clicked", GTK_SIGNAL_FUNC(service_zoom_out), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b1, "Zoom Out", NULL);
gtk_widget_show(b1);

b2 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b2), pixmapzout);
gtk_table_attach (GTK_TABLE (table2), b2, 0, 1, 1, 2,
		      	GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b2), "clicked", GTK_SIGNAL_FUNC(service_zoom_in), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b2, "Zoom In", NULL);
gtk_widget_show(b2);

b3 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b3), pixmapzfit);
gtk_table_attach (GTK_TABLE (table2), b3, 1, 2, 0, 1,
		      	GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b3), "clicked", GTK_SIGNAL_FUNC(service_zoom_fit), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b3, "Zoom Best Fit", NULL);
gtk_widget_show(b3);

b4 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b4), pixmapzundo);
gtk_table_attach (GTK_TABLE (table2), b4, 1, 2, 1, 2,
		      	GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b4), "clicked", GTK_SIGNAL_FUNC(service_zoom_undo), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b4, "Undo Last Zoom", NULL);
gtk_widget_show(b4);

b5 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b5), pixmapzleft);
gtk_table_attach (GTK_TABLE (table2), b5, 2, 3, 0, 1,
		      	GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b5), "clicked", GTK_SIGNAL_FUNC(service_zoom_left), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b5, "Zoom To Start", NULL);
gtk_widget_show(b5);

b6 = gtk_button_new();
gtk_container_add(GTK_CONTAINER(b6), pixmapzright);
gtk_table_attach (GTK_TABLE (table2), b6, 2, 3, 1, 2,
		      	GTK_FILL | GTK_EXPAND,
		      	GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1);
gtk_signal_connect_object (GTK_OBJECT (b6), "clicked", GTK_SIGNAL_FUNC(service_zoom_right), GTK_OBJECT (table2));
gtk_tooltips_set_tip_2(tooltips, b6, "Zoom To End", NULL);
gtk_widget_show(b6);


gtk_container_add (GTK_CONTAINER (frame), table2);

gtk_widget_show(table2);

return table;
}
Exemplo n.º 27
0
void
create_brushpage (GtkNotebook *notebook)
{
  GtkWidget        *box1, *box2, *box3, *thispage;
  GtkWidget        *view;
  GtkWidget        *tmpw, *grid;
  GtkWidget        *frame;
  GtkWidget        *combo;
  GtkWidget        *label;
  GtkSizeGroup     *group;
  GtkTreeSelection *selection;

  label = gtk_label_new_with_mnemonic (_("_Brush"));

  thispage = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
  gtk_container_set_border_width (GTK_CONTAINER (thispage), 12);
  gtk_widget_show (thispage);

  box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
  gtk_box_pack_start (GTK_BOX (thispage), box1, TRUE,TRUE,0);
  gtk_widget_show (box1);

  view = create_one_column_list (box1, brush_select_file);
  brush_list = view;
  brush_list_store =
      GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (view)));

  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));

  box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
  gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
  gtk_widget_show (box2);

  frame = gtk_frame_new (NULL);
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0);
  gtk_widget_show (frame);

  brush_preview = tmpw = gimp_preview_area_new ();
  gtk_widget_set_size_request (brush_preview, 100, 100);
  gtk_container_add (GTK_CONTAINER (frame), tmpw);
  gtk_widget_show (tmpw);
  g_signal_connect (brush_preview, "size-allocate",
                    G_CALLBACK (brush_preview_size_allocate), NULL);

  box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
  gtk_box_pack_end (GTK_BOX (box2), box3, FALSE, FALSE,0);
  gtk_widget_show (box3);

  tmpw = gtk_label_new (_("Gamma:"));
  gtk_label_set_xalign (GTK_LABEL (tmpw), 0.0);
  gtk_box_pack_start (GTK_BOX (box3), tmpw, FALSE, FALSE,0);
  gtk_widget_show (tmpw);

  brush_gamma_adjust = gtk_adjustment_new (pcvals.brushgamma,
                                           0.5, 3.0, 0.1, 0.1, 1.0);
  tmpw = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, brush_gamma_adjust);
  gtk_widget_set_size_request (GTK_WIDGET (tmpw), 100, 30);
  gtk_scale_set_draw_value (GTK_SCALE (tmpw), FALSE);
  gtk_scale_set_digits (GTK_SCALE (tmpw), 2);
  gtk_box_pack_start (GTK_BOX (box3), tmpw, FALSE, FALSE, 0);
  gtk_widget_show (tmpw);
  g_signal_connect_swapped (brush_gamma_adjust, "value-changed",
                            G_CALLBACK (update_brush_preview),
                            pcvals.selected_brush);

  gimp_help_set_help_data
    (tmpw, _("Changes the gamma (brightness) of the selected brush"), NULL);

  box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
  gtk_box_pack_start (GTK_BOX (thispage), box3, FALSE, FALSE,0);
  gtk_widget_show (box3);

  group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);

  tmpw = gtk_label_new (_("Select:"));
  gtk_label_set_xalign (GTK_LABEL (tmpw), 0.0);
  gtk_box_pack_start (GTK_BOX (box3), tmpw, FALSE, FALSE, 0);
  gtk_widget_show (tmpw);

  gtk_size_group_add_widget (group, tmpw);
  g_object_unref (group);

  combo = gimp_drawable_combo_box_new (validdrawable, NULL);
  gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), -1,
                              G_CALLBACK (brushdmenuselect),
                              NULL);

  gtk_box_pack_start (GTK_BOX (box3), combo, TRUE, TRUE, 0);
  gtk_widget_show (combo);

  tmpw = gtk_button_new_with_mnemonic (_("Save _as"));
  gtk_box_pack_start (GTK_BOX (box3),tmpw, FALSE, FALSE, 0);
  g_signal_connect (tmpw, "clicked", G_CALLBACK (savebrush), NULL);
  gtk_widget_show (tmpw);

  grid = gtk_grid_new ();
  gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
  gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
  gtk_box_pack_start (GTK_BOX (thispage), grid, FALSE, FALSE, 0);
  gtk_widget_show (grid);

  brush_aspect_adjust =
    gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
                          _("Aspect ratio:"),
                          150, -1, pcvals.brush_aspect,
                          -1.0, 1.0, 0.1, 0.1, 2,
                          TRUE, 0, 0,
                          _("Specifies the aspect ratio of the brush"),
                          NULL);
  gtk_size_group_add_widget (group,
                             GIMP_SCALE_ENTRY_LABEL (brush_aspect_adjust));
  g_signal_connect (brush_aspect_adjust, "value-changed",
                    G_CALLBACK (brush_asepct_adjust_cb),
                    &pcvals.brush_aspect);

  brush_relief_adjust =
    gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
                          _("Relief:"),
                          150, -1, pcvals.brush_relief,
                          0.0, 100.0, 1.0, 10.0, 1,
                          TRUE, 0, 0,
                          _("Specifies the amount of embossing to apply to the image (in percent)"),
                          NULL);
  gtk_size_group_add_widget (group,
                             GIMP_SCALE_ENTRY_LABEL (brush_relief_adjust));
  g_signal_connect (brush_relief_adjust, "value-changed",
                    G_CALLBACK (gimp_double_adjustment_update),
                    &pcvals.brush_relief);

  brush_select (selection, FALSE);
  readdirintolist ("Brushes", view, pcvals.selected_brush);

  /*
   * This is so the "changed signal won't get sent to the brushes' list
   * and reset the gamma and stuff.
   * */
  gtk_widget_grab_focus (brush_list);

  gtk_notebook_append_page_menu (notebook, thispage, label, NULL);
}
Exemplo n.º 28
0
GtkWidget *plugin_configure(GtkDialog *dialog)
{
	GtkWidget *vbox, *check_openuri, *check_tasks, *check_systray;
	GtkWidget *check_doclist, *vbox_doclist, *frame_doclist;
	GtkWidget *radio_doclist_name, *radio_doclist_occurrence;
	GtkWidget *check_bookmarklist, *check_markword, *frame_tasks, *vbox_tasks;
	GtkWidget *check_tasks_scan_mode, *entry_tasks_tokens, *label_tasks_tokens, *tokens_hbox;
	GtkWidget *check_blanklines, *check_xmltagging;

	vbox = gtk_vbox_new(FALSE, 6);

	check_doclist = gtk_check_button_new_with_label(
		_("Show toolbar item to show a list of currently open documents"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_doclist), ao_info->enable_doclist);
	g_signal_connect(check_doclist, "toggled", G_CALLBACK(ao_configure_doclist_toggled_cb), dialog);

	radio_doclist_name = gtk_radio_button_new_with_mnemonic(NULL, _("Sort documents by _name"));
	ui_widget_set_tooltip_text(radio_doclist_name,
		_("Sort the documents in the list by their filename"));

	radio_doclist_occurrence = gtk_radio_button_new_with_mnemonic_from_widget(
		GTK_RADIO_BUTTON(radio_doclist_name), _("Sort documents by _occurrence"));
	ui_widget_set_tooltip_text(radio_doclist_name,
		_("Sort the documents in the order of the document tabs"));

	if (ao_info->doclist_sort_mode == DOCLIST_SORT_BY_NAME)
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_doclist_name), TRUE);
	else
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_doclist_occurrence), TRUE);

	vbox_doclist = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox_doclist), radio_doclist_name, FALSE, FALSE, 3);
	gtk_box_pack_start(GTK_BOX(vbox_doclist), radio_doclist_occurrence, TRUE, TRUE, 3);

	frame_doclist = gtk_frame_new(NULL);
	gtk_frame_set_label_widget(GTK_FRAME(frame_doclist), check_doclist);
	gtk_container_add(GTK_CONTAINER(frame_doclist), vbox_doclist);
	gtk_box_pack_start(GTK_BOX(vbox), frame_doclist, FALSE, FALSE, 3);

	check_openuri = gtk_check_button_new_with_label(
		/* TODO fix the string */
		_("Show a 'Open URI' menu item in the editor menu"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_openuri),
		ao_info->enable_openuri);
	gtk_box_pack_start(GTK_BOX(vbox), check_openuri, FALSE, FALSE, 3);

	check_tasks = gtk_check_button_new_with_label(
		_("Show available Tasks in the Messages Window"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tasks),
		ao_info->enable_tasks);
	g_signal_connect(check_tasks, "toggled", G_CALLBACK(ao_configure_tasks_toggled_cb), dialog);

	check_tasks_scan_mode = gtk_check_button_new_with_label(
		_("Show tasks of all documents"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tasks_scan_mode),
		ao_info->tasks_scan_all_documents);
	ui_widget_set_tooltip_text(check_tasks_scan_mode,
		_("Whether to show the tasks of all open documents in the list or only those of the current document."));

	entry_tasks_tokens = gtk_entry_new();
	if (NZV(ao_info->tasks_token_list))
		gtk_entry_set_text(GTK_ENTRY(entry_tasks_tokens), ao_info->tasks_token_list);
	ui_entry_add_clear_icon(GTK_ENTRY(entry_tasks_tokens));
	ui_widget_set_tooltip_text(entry_tasks_tokens,
		_("Specify a semicolon separated list of search tokens."));

	label_tasks_tokens = gtk_label_new_with_mnemonic(_("Search tokens:"));
	gtk_label_set_mnemonic_widget(GTK_LABEL(label_tasks_tokens), entry_tasks_tokens);

	tokens_hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(tokens_hbox), label_tasks_tokens, FALSE, FALSE, 3);
	gtk_box_pack_start(GTK_BOX(tokens_hbox), entry_tasks_tokens, TRUE, TRUE, 3);

	vbox_tasks = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox_tasks), check_tasks_scan_mode, FALSE, FALSE, 3);
	gtk_box_pack_start(GTK_BOX(vbox_tasks), tokens_hbox, TRUE, TRUE, 3);

	frame_tasks = gtk_frame_new(NULL);
	gtk_frame_set_label_widget(GTK_FRAME(frame_tasks), check_tasks);
	gtk_container_add(GTK_CONTAINER(frame_tasks), vbox_tasks);
	gtk_box_pack_start(GTK_BOX(vbox), frame_tasks, FALSE, FALSE, 3);

	check_systray = gtk_check_button_new_with_label(
		_("Show status icon in the Notification Area"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_systray),
		ao_info->enable_systray);
	gtk_box_pack_start(GTK_BOX(vbox), check_systray, FALSE, FALSE, 3);

	check_bookmarklist = gtk_check_button_new_with_label(
		_("Show defined bookmarks (marked lines) in the sidebar"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_bookmarklist),
		ao_info->enable_bookmarklist);
	gtk_box_pack_start(GTK_BOX(vbox), check_bookmarklist, FALSE, FALSE, 3);

	check_markword = gtk_check_button_new_with_label(
		_("Mark all occurrences of a word when double-clicking it"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_markword),
		ao_info->enable_markword);
	gtk_box_pack_start(GTK_BOX(vbox), check_markword, FALSE, FALSE, 3);

	check_blanklines = gtk_check_button_new_with_label(
		_("Strip trailing blank lines"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_blanklines),
		ao_info->strip_trailing_blank_lines);
	gtk_box_pack_start(GTK_BOX(vbox), check_blanklines, FALSE, FALSE, 3);

	check_xmltagging = gtk_check_button_new_with_label(
		_("XML tagging for selection"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_xmltagging),
		ao_info->enable_xmltagging);
	gtk_box_pack_start(GTK_BOX(vbox), check_xmltagging, FALSE, FALSE, 3);

	g_object_set_data(G_OBJECT(dialog), "check_doclist", check_doclist);
	g_object_set_data(G_OBJECT(dialog), "radio_doclist_name", radio_doclist_name);
	g_object_set_data(G_OBJECT(dialog), "radio_doclist_occurrence", radio_doclist_occurrence);
	g_object_set_data(G_OBJECT(dialog), "check_openuri", check_openuri);
	g_object_set_data(G_OBJECT(dialog), "check_tasks", check_tasks);
	g_object_set_data(G_OBJECT(dialog), "entry_tasks_tokens", entry_tasks_tokens);
	g_object_set_data(G_OBJECT(dialog), "check_tasks_scan_mode", check_tasks_scan_mode);
	g_object_set_data(G_OBJECT(dialog), "check_systray", check_systray);
	g_object_set_data(G_OBJECT(dialog), "check_bookmarklist", check_bookmarklist);
	g_object_set_data(G_OBJECT(dialog), "check_markword", check_markword);
	g_object_set_data(G_OBJECT(dialog), "check_blanklines", check_blanklines);
	g_object_set_data(G_OBJECT(dialog), "check_xmltagging", check_xmltagging);
	g_signal_connect(dialog, "response", G_CALLBACK(ao_configure_response_cb), NULL);

	ao_configure_tasks_toggled_cb(GTK_TOGGLE_BUTTON(check_tasks), dialog);
	ao_configure_doclist_toggled_cb(GTK_TOGGLE_BUTTON(check_doclist), dialog);

	gtk_widget_show_all(vbox);

#if ! GTK_CHECK_VERSION(2, 10, 0)
	gtk_widget_hide(check_systray);
#endif

	return vbox;
}
Exemplo n.º 29
0
static gboolean
avatar_image_button_press_event (GtkWidget *widget, GdkEventButton *event)
{
	EmpathyAvatarImagePriv *priv;
	GtkWidget             *popup;
	GtkWidget             *frame;
	GtkWidget             *image;
	gint                   x, y;
	gint                   popup_width, popup_height;
	gint                   width, height;
	GdkPixbuf             *pixbuf;
	GtkAllocation          allocation;

	priv = GET_PRIV (widget);

	if (priv->popup) {
		gtk_widget_destroy (priv->popup);
		priv->popup = NULL;
	}

	if (event->button != 1 || event->type != GDK_BUTTON_PRESS || !priv->pixbuf) {
		return FALSE;
	}

	popup_width = gdk_pixbuf_get_width (priv->pixbuf);
	popup_height = gdk_pixbuf_get_height (priv->pixbuf);

	gtk_widget_get_allocation (priv->image, &allocation);
	width = allocation.width;
	height = allocation.height;

	/* Don't show a popup if the popup is smaller then the currently avatar
	 * image.
	 */
	if (popup_height <= height && popup_width <= width) {
		return TRUE;
	}

	pixbuf = tpaw_pixbuf_scale_down_if_necessary (priv->pixbuf, MAX_LARGE);
	popup_width = gdk_pixbuf_get_width (pixbuf);
	popup_height = gdk_pixbuf_get_height (pixbuf);

	popup = gtk_window_new (GTK_WINDOW_POPUP);

	frame = gtk_frame_new (NULL);
	gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);

	gtk_container_add (GTK_CONTAINER (popup), frame);

	image = gtk_image_new ();
	gtk_container_add (GTK_CONTAINER (frame), image);

	gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
	g_object_unref (pixbuf);

	gdk_window_get_origin (gtk_widget_get_window (priv->image), &x, &y);

	x = x - (popup_width - width) / 2;
	y = y - (popup_height - height) / 2;

	gtk_window_move (GTK_WINDOW (popup), x, y);

	priv->popup = popup;

	gtk_widget_show_all (popup);

	return TRUE;
}
Exemplo n.º 30
0
static void
gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool)
{
  GimpTool         *tool = GIMP_TOOL (picker_tool);
  GimpDisplayShell *shell;
  GtkWidget        *hbox;
  GtkWidget        *frame;
  GimpRGB           color;

  g_return_if_fail (tool->display != NULL);
  g_return_if_fail (tool->drawable != NULL);

  shell = gimp_display_get_shell (tool->display);

  picker_tool->gui = gimp_tool_gui_new (tool->tool_info,
                                        _("Color Picker Information"),
                                        gtk_widget_get_screen (GTK_WIDGET (shell)),
                                        gimp_widget_get_monitor (GTK_WIDGET (shell)),
                                        TRUE,

                                        GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,

                                        NULL);

  gimp_tool_gui_set_auto_overlay (picker_tool->gui, TRUE);
  gimp_tool_gui_set_focus_on_map (picker_tool->gui, FALSE);
  gimp_tool_gui_set_viewable (picker_tool->gui,
                              GIMP_VIEWABLE (tool->drawable));

  g_signal_connect (picker_tool->gui, "response",
                    G_CALLBACK (gimp_color_picker_tool_info_response),
                    picker_tool);

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
  gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (picker_tool->gui)),
                      hbox, FALSE, FALSE, 0);
  gtk_widget_show (hbox);

  picker_tool->color_frame1 = gimp_color_frame_new ();
  gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1),
                             GIMP_COLOR_FRAME_MODE_PIXEL);
  gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1,
                      FALSE, FALSE, 0);
  gtk_widget_show (picker_tool->color_frame1);

  picker_tool->color_frame2 = gimp_color_frame_new ();
  gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2),
                             GIMP_COLOR_FRAME_MODE_RGB);
  gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2,
                      FALSE, FALSE, 0);
  gtk_widget_show (picker_tool->color_frame2);

  frame = gtk_frame_new (NULL);
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
  gtk_widget_show (frame);

  gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0);
  picker_tool->color_area =
    gimp_color_area_new (&color,
                         gimp_drawable_has_alpha (tool->drawable) ?
                         GIMP_COLOR_AREA_LARGE_CHECKS :
                         GIMP_COLOR_AREA_FLAT,
                         GDK_BUTTON1_MASK | GDK_BUTTON2_MASK);
  gtk_widget_set_size_request (picker_tool->color_area, 48, -1);
  gtk_drag_dest_unset (picker_tool->color_area);
  gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area);
  gtk_widget_show (picker_tool->color_area);
}