static GtkWidget *add_table_int_row(CtkConfig *ctk_config, GtkWidget *table, const gchar *help, gchar *label1, uint64_t val, gint row, gboolean ecc_enabled) { GtkWidget *hbox2, *label, *eventbox; gtk_table_resize(GTK_TABLE(table), row+1, 2); hbox2 = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox2, 0, 1, row, row+1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(label1); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); gtk_widget_set_sensitive(label, ecc_enabled); eventbox = gtk_event_box_new(); gtk_table_attach(GTK_TABLE(table), eventbox, 1, 2, row, row+1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); set_label_value(label, val); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_container_add(GTK_CONTAINER(eventbox), label); ctk_config_set_tooltip(ctk_config, eventbox, help); gtk_widget_set_sensitive(label, ecc_enabled); return label; } /* add_table_int_row() */
static GtkWidget * add_scale(CtkConfig *ctk_config, int attribute, char *name, const char *help, gint value_type, gint default_value, gpointer callback_data) { GtkObject *adj; GtkWidget *scale; adj = gtk_adjustment_new(0, 0, 10, 1, 1, 0); g_object_set_data(G_OBJECT(adj), "attribute", GINT_TO_POINTER(attribute)); g_object_set_data(G_OBJECT(adj), "attribute name", name); g_object_set_data(G_OBJECT(adj), "attribute default value", GINT_TO_POINTER(default_value)); g_signal_connect(G_OBJECT(adj), "value_changed", G_CALLBACK(scale_value_changed), (gpointer) callback_data); scale = ctk_scale_new(GTK_ADJUSTMENT(adj), name, ctk_config, value_type); ctk_config_set_tooltip(ctk_config, CTK_SCALE_TOOLTIP_WIDGET(scale), help); return scale; } /* add_scale() */
static GtkWidget *create_check_button(CtkXVideo *ctk_xvideo, GtkWidget *vbox, GtkWidget *button, const gchar *name, const char *help, gint attribute, unsigned int bit) { GtkWidget *check_button; ReturnStatus ret; int val; /* get the attribute value */ ret = NvCtrlGetAttribute(ctk_xvideo->handle, attribute, &val); if (ret != NvCtrlSuccess) return NULL; check_button = gtk_check_button_new_with_label(name); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), val); g_signal_connect(G_OBJECT(check_button), "toggled", G_CALLBACK(check_button_toggled), (gpointer) ctk_xvideo); g_signal_connect_swapped(G_OBJECT(check_button), "toggled", G_CALLBACK(set_button_sensitive), (gpointer) button); g_object_set_data(G_OBJECT(check_button), "xvideo_attribute", GINT_TO_POINTER(attribute)); ctk_config_set_tooltip(ctk_xvideo->ctk_config, check_button, name); gtk_box_pack_start(GTK_BOX(vbox), check_button, FALSE, FALSE, 0); ctk_xvideo->active_attributes |= bit; ctk_config_set_tooltip(ctk_xvideo->ctk_config, check_button, help); return check_button; } /* create_check_button() */
/* * Helper function to add a tooltip to a widget *and* append a section to the * help text for that widget, for pages which use CtkHelpDataItem lists */ void ctk_config_set_tooltip_and_add_help_data(CtkConfig *config, GtkWidget *widget, GList **help_data_list, const gchar *label, const gchar *help_text, const gchar *extended_help_text) { ctk_help_data_list_prepend(help_data_list, label, help_text, extended_help_text); ctk_config_set_tooltip(config, widget, help_text); }
/* * xv_sync_to_display_radio_button_enabled_add() */ static void xv_sync_to_display_radio_button_enabled_add(CtkXVideo *ctk_xvideo, gint add_device_mask) { GtkWidget *radio[24], *prev_radio = NULL, *b1, *b2; int n; ReturnStatus ret; char *name, *type; gchar *name_str; /* Get the previous radio button. */ for (n = 0; n < 24; n++) { b1 = ctk_xvideo->xv_sync_to_display_buttons[n]; if (b1 != NULL) { prev_radio = b1; break; } } /* Get the next index where to add button. */ for (n = 0; n < 24; n++) { b2 = ctk_xvideo->xv_sync_to_display_buttons[n]; if (b2 == NULL) break; } ret = NvCtrlGetStringDisplayAttribute(ctk_xvideo->handle, add_device_mask, NV_CTRL_STRING_DISPLAY_DEVICE_NAME, &name); if ((ret != NvCtrlSuccess) || (!name)) { name = g_strdup("Unknown"); } /* get the display device type */ type = display_device_mask_to_display_device_name(add_device_mask); name_str = g_strdup_printf("%s (%s)", name, type); XFree(name); free(type); radio[n] = xv_sync_to_display_radio_button_add(ctk_xvideo, prev_radio, name_str, add_device_mask, n); g_free(name_str); ctk_config_set_tooltip(ctk_xvideo->ctk_config, radio[n], __xv_sync_to_display_help); } /* xv_sync_to_display_radio_button_enabled_add() */
/* * xv_sync_to_display_radio_button_add() - create a radio button and plug it * into the xv_sync_display_buttons radio group. */ static GtkWidget *xv_sync_to_display_radio_button_add(CtkXVideo *ctk_xvideo, GtkWidget *last_button, gint display_id) { gchar *label; GtkWidget *button; GSList *slist; if (display_id == NV_CTRL_XV_SYNC_TO_DISPLAY_ID_AUTO) { label = g_strdup("Auto"); } else { label = xv_sync_to_display_radio_button_label(ctk_xvideo, display_id); } if (last_button) { slist = gtk_radio_button_get_group(GTK_RADIO_BUTTON(last_button)); } else { slist = NULL; } button = gtk_radio_button_new_with_label(slist, label); g_free(label); gtk_box_pack_start(GTK_BOX(ctk_xvideo->xv_sync_to_display_button_box), button, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(button), "display_id", GINT_TO_POINTER(display_id)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE); g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(xv_sync_to_display_id_toggled), (gpointer) ctk_xvideo); ctk_config_set_tooltip(ctk_xvideo->ctk_config, button, __xv_sync_to_display_help); return button; }
static GtkWidget * add_scale(CtkDisplayDeviceTv *ctk_display_device_tv, int attribute, char *name, const char *help) { GtkObject *adj; GtkWidget *scale; adj = gtk_adjustment_new(0, 0, 10, 1, 1, 0); g_object_set_data(G_OBJECT(adj), "attribute", GINT_TO_POINTER(attribute)); g_object_set_data(G_OBJECT(adj), "attribute name", name); g_object_set_data(G_OBJECT(adj), "attribute active", GINT_TO_POINTER(0)); g_signal_connect(G_OBJECT(adj), "value_changed", G_CALLBACK(adjustment_value_changed), (gpointer) ctk_display_device_tv); scale = ctk_scale_new(GTK_ADJUSTMENT(adj), name, ctk_display_device_tv->ctk_config, G_TYPE_INT); if (help) { ctk_config_set_tooltip(ctk_display_device_tv->ctk_config, CTK_SCALE_TOOLTIP_WIDGET(scale), help); } gtk_box_pack_start(GTK_BOX(ctk_display_device_tv), scale, FALSE, FALSE, 0); return scale; } /* add_scale() */
GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target, CtkConfig *ctk_config, CtkEvent *ctk_event) { GObject *object; CtkEcc *ctk_ecc; GtkWidget *hbox, *hbox2, *vbox, *hsep, *hseparator, *table; GtkWidget *banner, *label, *eventbox; int64_t sbit_error; int64_t aggregate_sbit_error; int64_t dbit_error; int64_t aggregate_dbit_error; gint ecc_config_supported; gint val, row = 0; gboolean sbit_error_available; gboolean aggregate_sbit_error_available; gboolean dbit_error_available; gboolean aggregate_dbit_error_available; gboolean ecc_enabled; gboolean ecc_default_status; ReturnStatus ret; gchar *ecc_enabled_string; gchar *str = NULL; /* make sure we have a handle */ g_return_val_if_fail((ctrl_target != NULL) && (ctrl_target->h != NULL), NULL); /* * check if ECC support available. */ ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_ECC_SUPPORTED, &val); if (ret != NvCtrlSuccess || val != NV_CTRL_GPU_ECC_SUPPORTED_TRUE) { return NULL; } /* create the CtkEcc object */ object = g_object_new(CTK_TYPE_ECC, NULL); ctk_ecc = CTK_ECC(object); ctk_ecc->ctrl_target = ctrl_target; ctk_ecc->ctk_config = ctk_config; ctk_ecc->ecc_toggle_warning_dlg_shown = FALSE; sbit_error_available = TRUE; dbit_error_available = TRUE; aggregate_sbit_error_available = TRUE; aggregate_dbit_error_available = TRUE; sbit_error = 0; dbit_error = 0; aggregate_sbit_error = 0; aggregate_dbit_error = 0; /* Query ECC Status */ ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_ECC_STATUS, &val); if (ret != NvCtrlSuccess || val == NV_CTRL_GPU_ECC_STATUS_DISABLED) { ecc_enabled = FALSE; ecc_enabled_string = "Disabled"; } else { ecc_enabled = TRUE; ecc_enabled_string = "Enabled"; } ctk_ecc->ecc_enabled = ecc_enabled; /* Query ECC Configuration */ ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_ECC_CONFIGURATION, &val); if (ret != NvCtrlSuccess || val == NV_CTRL_GPU_ECC_CONFIGURATION_DISABLED) { ctk_ecc->ecc_configured = FALSE; } else { ctk_ecc->ecc_configured = TRUE; } /* get default status */ ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION, &val); if (ret != NvCtrlSuccess || val == NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION_DISABLED) { ecc_default_status = FALSE; } else { ecc_default_status = TRUE; } /* Query ECC errors */ ret = NvCtrlGetAttribute64(ctrl_target, NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS, &sbit_error); if (ret != NvCtrlSuccess) { sbit_error_available = FALSE; } ret = NvCtrlGetAttribute64(ctrl_target, NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS, &dbit_error); if (ret != NvCtrlSuccess) { dbit_error_available = FALSE; } ret = NvCtrlGetAttribute64(ctrl_target, NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS, &aggregate_sbit_error); if (ret != NvCtrlSuccess) { aggregate_sbit_error_available = FALSE; } ret = NvCtrlGetAttribute64(ctrl_target, NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS, &aggregate_dbit_error); if (ret != NvCtrlSuccess) { aggregate_dbit_error_available = FALSE; } ctk_ecc->sbit_error_available = sbit_error_available; ctk_ecc->aggregate_sbit_error_available = aggregate_sbit_error_available; ctk_ecc->dbit_error_available = dbit_error_available; ctk_ecc->aggregate_dbit_error_available = aggregate_dbit_error_available; /* Query ECC configuration supported */ ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED, &ecc_config_supported); if (ret != NvCtrlSuccess) { ecc_config_supported = 0; } /* set container properties for the CtkEcc widget */ gtk_box_set_spacing(GTK_BOX(ctk_ecc), 5); /* banner */ banner = ctk_banner_image_new(BANNER_ARTWORK_GPU); gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(object), vbox, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new("ECC Status"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); table = gtk_table_new(1, 2, FALSE); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(table), 3); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); /* ECC Status */ hbox2 = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox2, 0, 1, row, row+1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new("ECC:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); eventbox = gtk_event_box_new(); gtk_table_attach(GTK_TABLE(table), eventbox, 1, 2, row, row+1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(ecc_enabled_string); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_container_add(GTK_CONTAINER(eventbox), label); ctk_config_set_tooltip(ctk_config, eventbox, __ecc_status_help); ctk_ecc->status = label; row += 3; /* Add ECC Errors */ if (sbit_error_available && dbit_error_available) { ctk_ecc->sbit_error = add_table_int_row(ctk_config, table, __sbit_error_help, "Single-bit ECC Errors:", sbit_error, row, ecc_enabled); row += 1; // add vertical padding between rows ctk_ecc->dbit_error = add_table_int_row(ctk_config, table, __dbit_error_help, "Double-bit ECC Errors:", dbit_error, row, ecc_enabled); row += 3; // add vertical padding between rows } if (aggregate_sbit_error_available && aggregate_dbit_error_available) { ctk_ecc->aggregate_sbit_error = add_table_int_row(ctk_config, table, __aggregate_sbit_error_help, "Aggregate Single-bit ECC Errors:", aggregate_sbit_error, row, ecc_enabled); row += 1; // add vertical padding between rows ctk_ecc->aggregate_dbit_error = add_table_int_row(ctk_config, table, __aggregate_dbit_error_help, "Aggregate Double-bit ECC Errors:", aggregate_dbit_error, row, ecc_enabled); } /* ECC configuration settings */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new("ECC Configuration"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hsep = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hsep, TRUE, TRUE, 5); hbox2 = gtk_hbox_new(FALSE, 0); ctk_ecc->configuration_status = gtk_check_button_new_with_label("Enable ECC"); gtk_box_pack_start(GTK_BOX(hbox2), ctk_ecc->configuration_status, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbox2), 5); gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ctk_ecc->configuration_status), ctk_ecc->ecc_configured); ctk_config_set_tooltip(ctk_config, ctk_ecc->configuration_status, __configuration_status_help); g_signal_connect(G_OBJECT(ctk_ecc->configuration_status), "clicked", G_CALLBACK(ecc_config_button_toggled), (gpointer) ctk_ecc); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_GPU_ECC_CONFIGURATION), G_CALLBACK(ecc_configuration_update_received), (gpointer) ctk_ecc); gtk_widget_set_sensitive(ctk_ecc->configuration_status, ecc_config_supported); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(ctk_ecc), hbox, FALSE, FALSE, 0); /* Add buttons */ if (sbit_error_available && dbit_error_available) { ctk_ecc->clear_button = gtk_button_new_with_label("Clear ECC Errors"); gtk_box_pack_end(GTK_BOX(hbox), ctk_ecc->clear_button, FALSE, FALSE, 0); ctk_config_set_tooltip(ctk_config, ctk_ecc->clear_button, __clear_button_help); gtk_widget_set_sensitive(ctk_ecc->clear_button, ecc_enabled); g_signal_connect(G_OBJECT(ctk_ecc->clear_button), "clicked", G_CALLBACK(clear_ecc_errors_button_clicked), (gpointer) ctk_ecc); } if (aggregate_sbit_error_available && aggregate_dbit_error_available) { ctk_ecc->clear_aggregate_button = gtk_button_new_with_label("Clear Aggregate ECC Errors"); gtk_box_pack_end(GTK_BOX(hbox), ctk_ecc->clear_aggregate_button, FALSE, FALSE, 0); ctk_config_set_tooltip(ctk_config, ctk_ecc->clear_button, __clear_aggregate_button_help); gtk_widget_set_sensitive(ctk_ecc->clear_aggregate_button, ecc_enabled); g_signal_connect(G_OBJECT(ctk_ecc->clear_aggregate_button), "clicked", G_CALLBACK(clear_aggregate_ecc_errors_button_clicked), (gpointer) ctk_ecc); } ctk_ecc->reset_default_config_button = gtk_button_new_with_label("Reset Default Configuration"); eventbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(eventbox), ctk_ecc->reset_default_config_button); gtk_box_pack_end(GTK_BOX(hbox), eventbox, FALSE, FALSE, 5); ctk_config_set_tooltip(ctk_config, ctk_ecc->reset_default_config_button, __reset_default_config_button_help); gtk_widget_set_sensitive(ctk_ecc->reset_default_config_button, ecc_config_supported && (ecc_enabled != ecc_default_status)); g_signal_connect(G_OBJECT(ctk_ecc->reset_default_config_button), "clicked", G_CALLBACK(reset_default_config_button_clicked), (gpointer) ctk_ecc); /* Register a timer callback to update Ecc status info */ str = g_strdup_printf("ECC Settings (GPU %d)", NvCtrlGetTargetId(ctrl_target)); ctk_config_add_timer(ctk_ecc->ctk_config, DEFAULT_UPDATE_ECC_STATUS_INFO_TIME_INTERVAL, str, (GSourceFunc) update_ecc_info, (gpointer) ctk_ecc); g_free(str); gtk_widget_show_all(GTK_WIDGET(ctk_ecc)); update_ecc_info(ctk_ecc); return GTK_WIDGET(ctk_ecc); }
/**** * * Updates sensitivity of widgets in relation to the state * of overclocking. * */ static void sync_gui_sensitivity(CtkClocks *ctk_object) { gboolean enabled = ctk_object->overclocking_enabled; gboolean probing = ctk_object->probing_optimal; gboolean modified = ctk_object->clocks_modified; gboolean moved = ctk_object->clocks_moved; /* Update the enable checkbox */ g_signal_handlers_block_by_func(G_OBJECT(ctk_object->enable_checkbox), G_CALLBACK(overclocking_state_toggled), (gpointer) ctk_object); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ctk_object->enable_checkbox), enabled); g_signal_handlers_unblock_by_func(G_OBJECT(ctk_object->enable_checkbox), G_CALLBACK(overclocking_state_toggled), (gpointer) ctk_object); gtk_widget_set_sensitive(ctk_object->enable_checkbox, !probing); /* Update the clock selection dropdown */ gtk_widget_set_sensitive(ctk_object->clock_menu, enabled && !probing); /* Update the Graphics clock slider */ gtk_widget_set_sensitive(ctk_object->gpu_clk_scale, enabled && !probing); /* Update the Memory clock slider */ gtk_widget_set_sensitive(ctk_object->mem_clk_scale, enabled && !probing); /* Update the Apply button */ gtk_widget_set_sensitive(ctk_object->apply_button, enabled && !probing && moved); /* Enable the Auto Detect button for 3D clocks only */ if ( probing ) { gtk_button_set_label(GTK_BUTTON(ctk_object->detect_button), "Cancel Detection"); gtk_widget_set_sensitive(ctk_object->detect_button, True); ctk_config_set_tooltip(ctk_object->ctk_config, ctk_object->detect_button, __cancel_button_help); } else { gboolean set_sensitive; gtk_button_set_label(GTK_BUTTON(ctk_object->detect_button), "Auto Detect"); set_sensitive = ((ctk_object->auto_detection_available) && (ctk_object->clocks_being_modified == CLOCKS_3D)) ? enabled : False; gtk_widget_set_sensitive(ctk_object->detect_button, set_sensitive); ctk_config_set_tooltip(ctk_object->ctk_config, ctk_object->detect_button, __detect_button_help); } /* Update the Reset hardware defaults button */ gtk_widget_set_sensitive(ctk_object->reset_button, enabled && !probing && (moved || modified)); } /* sync_gui_sensitivity() */
static GtkWidget *create_timer_list(CtkConfig *ctk_config) { GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *sw; GtkWidget *vbox; GtkWidget *label; GtkWidget *alignment; sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); ctk_config->list_store = gtk_list_store_new(NUM_COLUMNS, G_TYPE_POINTER, /* TIMER_CONFIG_COLUMN */ G_TYPE_POINTER, /* FUNCTION_COLUMN */ G_TYPE_POINTER, /* DATA_COLUMN */ G_TYPE_UINT, /* HANDLE_COLUMN */ G_TYPE_BOOLEAN); /* OWNER_ENABLE_COLUMN */ model = GTK_TREE_MODEL(ctk_config->list_store); treeview = gtk_tree_view_new_with_model(model); g_object_unref(ctk_config->list_store); /* Enable */ renderer = gtk_cell_renderer_toggle_new(); g_signal_connect(renderer, "toggled", G_CALLBACK(timer_enable_toggled), ctk_config); column = gtk_tree_view_column_new_with_attributes("Enabled", renderer, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, enabled_renderer_func, GINT_TO_POINTER (TIMER_CONFIG_COLUMN), NULL); /* Description */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Description", renderer, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, description_renderer_func, GINT_TO_POINTER (TIMER_CONFIG_COLUMN), NULL); /* Time interval */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Time Interval", renderer, NULL); g_signal_connect(renderer, "edited", G_CALLBACK(time_interval_edited), ctk_config); gtk_tree_view_column_set_cell_data_func(column, renderer, time_interval_renderer_func, GINT_TO_POINTER (TIMER_CONFIG_COLUMN), NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); gtk_tree_view_column_set_resizable(column, FALSE); gtk_container_add(GTK_CONTAINER(sw), treeview); vbox = gtk_vbox_new(FALSE, 5); label = gtk_label_new("Active Timers:"); alignment = gtk_alignment_new(0.0, 0.0, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), label); gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); /* create the tooltip for the treeview (can't do it per column) */ ctk_config_set_tooltip(ctk_config, treeview, "The Active Timers describe operations that " "nvidia-settings will perform at regular " "intervals."); return vbox; } /* create_timer_list() */
GtkWidget* ctk_config_new(ConfigProperties *conf, CtrlSystem *pCtrlSystem) { gint i; GObject *object; CtkConfig *ctk_config; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *banner; GtkWidget *label; GtkWidget *hseparator; GtkWidget *check_button; GtkWidget *alignment; gboolean b; struct { const char *label; unsigned int mask; GCallback toggled_callback; const char *help_text; } config_check_button_entries[] = { { "Display Status Bar", CONFIG_PROPERTIES_DISPLAY_STATUS_BAR, G_CALLBACK(display_status_bar_toggled), __status_bar_help }, { "Slider Text Entries", CONFIG_PROPERTIES_SLIDER_TEXT_ENTRIES, G_CALLBACK(slider_text_entries_toggled), __slider_text_entries_help }, { "Include X Display Names in the Config File", CONFIG_PROPERTIES_INCLUDE_DISPLAY_NAME_IN_CONFIG_FILE, G_CALLBACK(display_name_toggled), __x_display_names_help }, { "Show \"Really Quit?\" Dialog", CONFIG_PROPERTIES_SHOW_QUIT_DIALOG, G_CALLBACK(show_quit_dialog_toggled), __show_quit_dialog_help }, { "Update Rules when an Application Profile Name changes", CONFIG_PROPERTIES_UPDATE_RULES_ON_PROFILE_NAME_CHANGE, G_CALLBACK(update_rules_on_profile_name_change_toggled), __update_rules_on_profile_name_change_help }, }; object = g_object_new(CTK_TYPE_CONFIG, NULL); ctk_config = CTK_CONFIG(object); ctk_config->conf = conf; ctk_config->pCtrlSystem = pCtrlSystem; gtk_box_set_spacing(GTK_BOX(ctk_config), 10); /* initialize the statusbar widget */ ctk_statusbar_init(&ctk_config->status_bar); #ifndef CTK_GTK3 /* initialize the tooltips widget */ ctk_config->tooltips.object = gtk_tooltips_new(); #endif /* banner */ banner = ctk_banner_image_new(BANNER_ARTWORK_CONFIG); gtk_box_pack_start(GTK_BOX(ctk_config), banner, FALSE, FALSE, 0); /* "nvidia-settings Configuration" */ hbox = gtk_hbox_new (FALSE, 5); gtk_box_pack_start(GTK_BOX(ctk_config), hbox, FALSE, FALSE, 0); label = gtk_label_new("nvidia-settings Configuration"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 0); /* check buttons: Enable tooltips, Display statusbar, and Display slider text entries */ vbox = gtk_vbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(ctk_config), vbox, FALSE, FALSE, 0); ctk_config->help_data = NULL; for (i = 0; i < ARRAY_LEN(config_check_button_entries); i++) { label = gtk_label_new(config_check_button_entries[i].label); check_button = gtk_check_button_new(); gtk_container_add(GTK_CONTAINER(check_button), label); b = !!(ctk_config->conf->booleans & config_check_button_entries[i].mask); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), b); gtk_box_pack_start(GTK_BOX(vbox), check_button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(check_button), "toggled", config_check_button_entries[i].toggled_callback, ctk_config); ctk_config_set_tooltip_and_add_help_data(ctk_config, check_button, &ctk_config->help_data, config_check_button_entries[i].label, config_check_button_entries[i].help_text, NULL); } ctk_config->help_data = g_list_reverse(ctk_config->help_data); /* timer list */ ctk_config->timer_list_box = gtk_hbox_new(FALSE, 0); ctk_config->timer_list = create_timer_list(ctk_config); g_object_ref(ctk_config->timer_list); ctk_config->timer_list_visible = FALSE; gtk_box_pack_start(GTK_BOX(ctk_config), ctk_config->timer_list_box, TRUE, TRUE, 0); /* "Save Current Configuration" button */ label = gtk_label_new("Save Current Configuration"); hbox = gtk_hbox_new(FALSE, 0); ctk_config->button_save_rc = gtk_button_new(); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15); gtk_container_add(GTK_CONTAINER(ctk_config->button_save_rc), hbox); gtk_container_add(GTK_CONTAINER(alignment), ctk_config->button_save_rc); gtk_box_pack_start(GTK_BOX(ctk_config), alignment, TRUE, TRUE, 0); /* Create the file selector for rc file */ g_signal_connect(G_OBJECT(ctk_config->button_save_rc), "clicked", G_CALLBACK(save_rc_clicked), (gpointer) ctk_config); ctk_config_set_tooltip(ctk_config, ctk_config->button_save_rc, __save_current_config_help); ctk_config->rc_filename = NULL; gtk_widget_show_all(GTK_WIDGET(ctk_config)); return GTK_WIDGET(ctk_config); }
GtkWidget* ctk_gvo_sync_new(NvCtrlAttributeHandle *handle, GtkWidget *parent_window, CtkConfig *ctk_config, CtkEvent *ctk_event, CtkGvo *gvo_parent) { GObject *object; CtkGvoSync *ctk_gvo_sync; GtkWidget *frame; GtkWidget *hbox; GtkWidget *label; GtkWidget *alignment; GtkWidget *button; GtkWidget *table, *menu; gint val, i; NVCTRLAttributeValidValuesRec valid; ReturnStatus ret; gint row; const char *help_text; /* make sure we have a handle */ g_return_val_if_fail(handle != NULL, NULL); /* create and initialize the object */ object = g_object_new(CTK_TYPE_GVO_SYNC, NULL); ctk_gvo_sync = CTK_GVO_SYNC(object); ctk_gvo_sync->handle = handle; ctk_gvo_sync->parent_window = parent_window; ctk_gvo_sync->ctk_config = ctk_config; ctk_gvo_sync->ctk_event = ctk_event; ctk_gvo_sync->gvo_parent = gvo_parent; /* Query the current GVO state */ if ( !query_init_gvo_sync_state(ctk_gvo_sync) ) { // Free the object g_object_ref(object); gtk_object_sink(GTK_OBJECT(object)); g_object_unref(object); return NULL; } /* set container properties for the widget */ gtk_box_set_spacing(GTK_BOX(object), 10); /* banner */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0); ctk_gvo_sync->banner_box = hbox; /* * Sync options */ frame = gtk_frame_new("Sync Options"); ctk_gvo_sync->frame = frame; gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0); table = gtk_table_new(6, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 0); gtk_table_set_col_spacings(GTK_TABLE(table), 0); gtk_container_add(GTK_CONTAINER(frame), table); /* input video format */ label = gtk_label_new("Input Video Format: "); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING); hbox = gtk_hbox_new(FALSE, 5); ctk_gvo_sync->input_video_format_text_entry = gtk_entry_new(); ctk_config_set_tooltip(ctk_config, ctk_gvo_sync->input_video_format_text_entry, __input_video_format_help); gtk_entry_set_width_chars (GTK_ENTRY(ctk_gvo_sync->input_video_format_text_entry), max_input_video_format_text_entry_length()); gtk_widget_set_sensitive(ctk_gvo_sync->input_video_format_text_entry, FALSE); update_input_video_format_text_entry(ctk_gvo_sync); gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->input_video_format_text_entry, TRUE, TRUE, 0); /* Input video format detect button */ button = gtk_toggle_button_new_with_label("Detect"); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), button); ctk_gvo_sync->input_video_format_detect_button = button; ctk_config_set_tooltip(ctk_config, button, __input_video_format_detect_help); g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(detect_input_toggled), ctk_gvo_sync); gtk_box_pack_start(GTK_BOX(hbox), alignment, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL, TABLE_PADDING, TABLE_PADDING); /* Composite Termination */ if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_COMPOSITE_TERMINATION) { button = gtk_check_button_new_with_label("Enable Composite Termination"); ctk_config_set_tooltip(ctk_config, button, __composite_termination_help); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), button); gtk_table_attach(GTK_TABLE(table), alignment, 0, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL, TABLE_PADDING, TABLE_PADDING); ctk_gvo_sync->composite_termination_button = button; init_composite_termination(ctk_gvo_sync); g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(composite_termination_toggled), ctk_gvo_sync); row = 3; } else { ctk_gvo_sync->composite_termination_button = NULL; row = 2; } /* Sync Mode */ menu = start_menu("Sync Mode: ", table, row); ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "Free Running", NV_CTRL_GVO_SYNC_MODE_FREE_RUNNING); ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "GenLock", NV_CTRL_GVO_SYNC_MODE_GENLOCK); ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "FrameLock", NV_CTRL_GVO_SYNC_MODE_FRAMELOCK); finish_menu(menu, table, row); row++; ctk_gvo_sync->sync_mode_menu = menu; ctk_drop_down_menu_set_tooltip(ctk_config, CTK_DROP_DOWN_MENU(menu), __sync_mode_help); ctk_drop_down_menu_set_current_value (CTK_DROP_DOWN_MENU(ctk_gvo_sync->sync_mode_menu), ctk_gvo_sync->sync_mode); g_signal_connect(G_OBJECT(ctk_gvo_sync->sync_mode_menu), "changed", G_CALLBACK(sync_mode_changed), (gpointer) ctk_gvo_sync); /* Sync Format */ menu = start_menu("Sync Format: ", table, row); for (i = 0; syncFormatNames[i].name; i++) { ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), syncFormatNames[i].name, syncFormatNames[i].format); } finish_menu(menu, table, row); row++; ctk_gvo_sync->sync_format_menu = menu; ctk_drop_down_menu_set_tooltip(ctk_config, CTK_DROP_DOWN_MENU(menu), __sync_format_help); init_sync_format_menu(ctk_gvo_sync); g_signal_connect(G_OBJECT(ctk_gvo_sync->sync_format_menu), "changed", G_CALLBACK(sync_format_changed), (gpointer) ctk_gvo_sync); /* Sync Status */ label = gtk_label_new("Sync Status:"); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING); ctk_gvo_sync->sync_lock_status_text = gtk_label_new(""); update_sync_lock_status_text(ctk_gvo_sync); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->sync_lock_status_text, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, row, row+1, GTK_FILL /*| GTK_EXPAND*/, GTK_FILL, TABLE_PADDING, TABLE_PADDING); row++; /* * Synchronization Skew (Delay/Advance) */ /* NV_CTRL_GVO_SYNC_DELAY_PIXELS */ ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GVO_SYNC_DELAY_PIXELS, &valid); if ((ret == NvCtrlSuccess) && (valid.type == ATTRIBUTE_TYPE_RANGE)) { ret = NvCtrlGetAttribute(handle, NV_CTRL_GVO_SYNC_DELAY_PIXELS, &val); if (ret != NvCtrlSuccess) val = 0; if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW) { label = gtk_label_new("HSync Advance:"); help_text = __hsync_advance_help; } else { label = gtk_label_new("HSync Delay:"); help_text = __hsync_delay_help; } gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING); ctk_gvo_sync->hsync_delay_spin_button = gtk_spin_button_new_with_range(valid.u.range.min, valid.u.range.max, 1); ctk_config_set_tooltip(ctk_config, ctk_gvo_sync->hsync_delay_spin_button, help_text); gtk_spin_button_set_value (GTK_SPIN_BUTTON(ctk_gvo_sync->hsync_delay_spin_button), val); g_signal_connect(G_OBJECT(ctk_gvo_sync->hsync_delay_spin_button), "value-changed", G_CALLBACK(hsync_delay_changed), ctk_gvo_sync); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->hsync_delay_spin_button, FALSE, FALSE, 0); label = gtk_label_new("(pixels)"); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, row, row+1, GTK_FILL /*| GTK_EXPAND*/, GTK_FILL, TABLE_PADDING, TABLE_PADDING); row++; } /* NV_CTRL_GVO_SYNC_DELAY_LINES */ ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GVO_SYNC_DELAY_LINES, &valid); if ((ret == NvCtrlSuccess) && (valid.type == ATTRIBUTE_TYPE_RANGE)) { ret = NvCtrlGetAttribute(handle, NV_CTRL_GVO_SYNC_DELAY_LINES, &val); if (ret != NvCtrlSuccess) val = 0; if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW) { label = gtk_label_new("VSync Advance:"); help_text = __vsync_advance_help; } else { label = gtk_label_new("VSync Delay:"); help_text = __vsync_delay_help; } gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING); ctk_gvo_sync->vsync_delay_spin_button = gtk_spin_button_new_with_range(valid.u.range.min, valid.u.range.max, 1); ctk_config_set_tooltip(ctk_config, ctk_gvo_sync->vsync_delay_spin_button, help_text); gtk_spin_button_set_value (GTK_SPIN_BUTTON(ctk_gvo_sync->vsync_delay_spin_button), val); g_signal_connect(G_OBJECT(ctk_gvo_sync->vsync_delay_spin_button), "value-changed", G_CALLBACK(vsync_delay_changed), ctk_gvo_sync); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->vsync_delay_spin_button, FALSE, FALSE, 0); label = gtk_label_new("(lines)"); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, row, row+1, GTK_FILL /*| GTK_EXPAND*/, GTK_FILL, TABLE_PADDING, TABLE_PADDING); row++; } /* create the watch cursor (for use when the "Detect" button is toggled" */ ctk_gvo_sync->wait_cursor = gdk_cursor_new(GDK_WATCH); /* Set UI sensitivity */ update_gvo_sync_sensitivity(ctk_gvo_sync); /* Start listening for events */ register_for_gvo_sync_events(ctk_gvo_sync); /* show the page */ gtk_widget_show_all(GTK_WIDGET(object)); return GTK_WIDGET(object); } /* ctk_gvo_sync_new() */
GtkWidget* ctk_dithering_controls_new(NvCtrlAttributeHandle *handle, CtkConfig *ctk_config, CtkEvent *ctk_event, GtkWidget *reset_button, char *name) { GObject *object; CtkDitheringControls *ctk_dithering_controls; GtkWidget *frame, *vbox, *hbox, *label; GtkWidget *menu, *table, *menu_item = NULL, *separator; /* create the object */ object = g_object_new(CTK_TYPE_DITHERING_CONTROLS, NULL); if (!object) { return NULL; } ctk_dithering_controls = CTK_DITHERING_CONTROLS(object); ctk_dithering_controls->handle = handle; ctk_dithering_controls->ctk_config = ctk_config; ctk_dithering_controls->reset_button = reset_button; ctk_dithering_controls->name = strdup(name); /* create main dithering box & frame */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, FRAME_PADDING); ctk_dithering_controls->dithering_controls_box = hbox; frame = gtk_frame_new("Dithering Controls"); gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0); table = gtk_table_new(5, 4, FALSE); gtk_container_add(GTK_CONTAINER(frame), table); gtk_table_set_row_spacings(GTK_TABLE(table), 5); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); /* Build Dithering widgets & pack them in table */ /* dropdown list for dithering configuration */ menu = gtk_menu_new(); menu_item = gtk_menu_item_new_with_label("Auto"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); gtk_widget_show(menu_item); menu_item = gtk_menu_item_new_with_label("Enabled"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); gtk_widget_show(menu_item); menu_item = gtk_menu_item_new_with_label("Disabled"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); gtk_widget_show(menu_item); ctk_dithering_controls->dithering_config_menu = gtk_option_menu_new(); gtk_option_menu_set_menu (GTK_OPTION_MENU(ctk_dithering_controls->dithering_config_menu), menu); ctk_config_set_tooltip(ctk_config, ctk_dithering_controls->dithering_config_menu, __dithering_config_help); g_signal_connect(G_OBJECT(ctk_dithering_controls->dithering_config_menu), "changed", G_CALLBACK(dithering_config_menu_changed), (gpointer) ctk_dithering_controls); /* Packing label & dropdown */ hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new("Dithering: "); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); gtk_box_pack_start(GTK_BOX(hbox), ctk_dithering_controls->dithering_config_menu, FALSE, FALSE, 0); /* Build CurrentDithering widget */ hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 2, 3, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new("Current Dithering: "); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 3, 4, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); ctk_dithering_controls->dithering_config_txt = label; gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); /* H-bar 1 */ vbox = gtk_vbox_new(FALSE, 0); separator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), vbox, 0, 4, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); /* dropdown list for dithering modes - populated in setup */ ctk_dithering_controls->dithering_mode_menu = gtk_option_menu_new(); ctk_config_set_tooltip(ctk_config, ctk_dithering_controls->dithering_mode_menu, __dithering_mode_help); g_signal_connect(G_OBJECT(ctk_dithering_controls->dithering_mode_menu), "changed", G_CALLBACK(dithering_mode_menu_changed), (gpointer) ctk_dithering_controls); /* pack the label & drop down */ hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 2, 3, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new("Mode: "); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); ctk_dithering_controls->dithering_mode_box = hbox; gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 2, 3, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); gtk_box_pack_start(GTK_BOX(hbox), ctk_dithering_controls->dithering_mode_menu, FALSE, FALSE, 0); /* Build CurrentMode widget */ hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 2, 3, 2, 3, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new("Current Mode: "); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 3, 4, 2, 3, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); ctk_dithering_controls->dithering_mode_txt = label; gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); /* H-bar 2 */ vbox = gtk_vbox_new(FALSE, 0); separator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), vbox, 0, 4, 3, 4, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); /* dithering depth */ menu = gtk_menu_new(); menu_item = gtk_menu_item_new_with_label("Auto"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); gtk_widget_show(menu_item); menu_item = gtk_menu_item_new_with_label("6 bpc"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); gtk_widget_show(menu_item); menu_item = gtk_menu_item_new_with_label("8 bpc"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); gtk_widget_show(menu_item); ctk_dithering_controls->dithering_depth_menu = gtk_option_menu_new(); gtk_option_menu_set_menu (GTK_OPTION_MENU(ctk_dithering_controls->dithering_depth_menu), menu); ctk_config_set_tooltip(ctk_config, ctk_dithering_controls->dithering_depth_menu, __dithering_depth_help); g_signal_connect(G_OBJECT(ctk_dithering_controls->dithering_depth_menu), "changed", G_CALLBACK(dithering_depth_menu_changed), (gpointer) ctk_dithering_controls); /* Packing label & dropdown */ hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 4, 5, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new("Depth: "); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); ctk_dithering_controls->dithering_depth_box = hbox; gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 4, 5, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); gtk_box_pack_start(GTK_BOX(hbox), ctk_dithering_controls->dithering_depth_menu, FALSE, FALSE, 0); /* Build CurrentDitheringDepth widget */ hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 2, 3, 4, 5, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new("Current Depth: "); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 3, 4, 4, 5, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); ctk_dithering_controls->dithering_depth_txt = label; gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_widget_show_all(GTK_WIDGET(object)); ctk_dithering_controls_setup(ctk_dithering_controls); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_DITHERING), G_CALLBACK(dithering_update_received), (gpointer) ctk_dithering_controls); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_DITHERING_MODE), G_CALLBACK(dithering_update_received), (gpointer) ctk_dithering_controls); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_DITHERING_DEPTH), G_CALLBACK(dithering_update_received), (gpointer) ctk_dithering_controls); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_CURRENT_DITHERING), G_CALLBACK(dithering_update_received), (gpointer) ctk_dithering_controls); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_CURRENT_DITHERING_MODE), G_CALLBACK(dithering_update_received), (gpointer) ctk_dithering_controls); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_CURRENT_DITHERING_DEPTH), G_CALLBACK(dithering_update_received), (gpointer) ctk_dithering_controls); return GTK_WIDGET(object); } /* ctk_dithering_controls_new() */
GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle, CtkConfig *ctk_config, CtkEvent *ctk_event, unsigned int display_device_mask, char *name) { GObject *object; CtkDisplayDeviceDfp *ctk_display_device_dfp; GtkWidget *banner; GtkWidget *frame; GtkWidget *hbox, *vbox, *tmpbox; GtkWidget *eventbox; GtkWidget *button; GtkWidget *radio0; GtkWidget *radio1; GtkWidget *radio2; GtkWidget *alignment; GtkWidget *table; ReturnStatus ret1, ret2; gint val_target, val_method; object = g_object_new(CTK_TYPE_DISPLAY_DEVICE_DFP, NULL); if (!object) return NULL; ctk_display_device_dfp = CTK_DISPLAY_DEVICE_DFP(object); ctk_display_device_dfp->handle = handle; ctk_display_device_dfp->ctk_event = ctk_event; ctk_display_device_dfp->ctk_config = ctk_config; ctk_display_device_dfp->display_device_mask = display_device_mask; ctk_display_device_dfp->name = g_strdup(name); /* cache the default scaling target & method values */ ret1 = NvCtrlGetDisplayAttribute(ctk_display_device_dfp->handle, ctk_display_device_dfp->display_device_mask, NV_CTRL_GPU_SCALING_DEFAULT_TARGET, &val_target); ret2 = NvCtrlGetDisplayAttribute(ctk_display_device_dfp->handle, ctk_display_device_dfp->display_device_mask, NV_CTRL_GPU_SCALING_DEFAULT_METHOD, &val_method); if (ret1 != NvCtrlSuccess || ret2 != NvCtrlSuccess || val_target == NV_CTRL_GPU_SCALING_TARGET_INVALID || val_method == NV_CTRL_GPU_SCALING_METHOD_INVALID) { val_target = NV_CTRL_GPU_SCALING_TARGET_FLATPANEL_BEST_FIT; val_method = NV_CTRL_GPU_SCALING_METHOD_STRETCHED; } ctk_display_device_dfp->default_scaling_target = val_target; ctk_display_device_dfp->default_scaling_method = val_method; gtk_box_set_spacing(GTK_BOX(object), 10); /* banner */ banner = ctk_banner_image_new(BANNER_ARTWORK_DFP); gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0); /* * create the reset button (which we need while creating the * controls in this page so that we can set the button's * sensitivity), though we pack it at the bottom of the page */ ctk_display_device_dfp->reset_button = gtk_button_new_with_label("Reset Hardware Defaults"); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), ctk_display_device_dfp->reset_button); gtk_box_pack_end(GTK_BOX(object), alignment, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(ctk_display_device_dfp->reset_button), "clicked", G_CALLBACK(reset_button_clicked), (gpointer) ctk_display_device_dfp); ctk_config_set_tooltip(ctk_config, ctk_display_device_dfp->reset_button, "The Reset Hardware Defaults button restores " "the DFP settings to their default values."); /* create the hbox to store dfp info, scaling */ hbox = gtk_hbox_new(FALSE, FRAME_PADDING); gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, FRAME_PADDING); /* DFP info */ frame = gtk_frame_new("Flat Panel Information"); gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0); /* * insert a vbox between the frame and the widgets, so that the * widgets don't expand to fill all of the space within the * frame */ tmpbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(frame), tmpbox); /* Make the txt widgets that will get updated */ ctk_display_device_dfp->txt_chip_location = gtk_label_new(""); ctk_display_device_dfp->txt_link = gtk_label_new(""); ctk_display_device_dfp->txt_signal = gtk_label_new(""); ctk_display_device_dfp->txt_native_resolution = gtk_label_new(""); ctk_display_device_dfp->txt_best_fit_resolution = gtk_label_new(""); ctk_display_device_dfp->txt_frontend_resolution = gtk_label_new(""); ctk_display_device_dfp->txt_backend_resolution = gtk_label_new(""); ctk_display_device_dfp->txt_refresh_rate = gtk_label_new(""); /* Add information widget lines */ { typedef struct { GtkWidget *label; GtkWidget *txt; const gchar *tooltip; } TextLineInfo; TextLineInfo lines[] = { { gtk_label_new("Chip location:"), ctk_display_device_dfp->txt_chip_location, NULL }, { gtk_label_new("Connection link:"), ctk_display_device_dfp->txt_link, NULL }, { gtk_label_new("Signal:"), ctk_display_device_dfp->txt_signal, NULL }, { gtk_label_new("Native Resolution:"), ctk_display_device_dfp->txt_native_resolution, __native_res_help, }, { gtk_label_new("Best Fit Resolution:"), ctk_display_device_dfp->txt_best_fit_resolution, __best_fit_res_help, }, { gtk_label_new("Frontend Resolution:"), ctk_display_device_dfp->txt_frontend_resolution, __frontend_res_help, }, { gtk_label_new("Backend Resolution:"), ctk_display_device_dfp->txt_backend_resolution, __backend_res_help, }, { gtk_label_new("Refresh Rate:"), ctk_display_device_dfp->txt_refresh_rate, __refresh_rate_help, }, { NULL, NULL, NULL } }; int i; GtkRequisition req; int max_width; /* Compute max width of lables and setup text alignments */ max_width = 0; for (i = 0; lines[i].label; i++) { gtk_misc_set_alignment(GTK_MISC(lines[i].label), 0.0f, 0.5f); gtk_misc_set_alignment(GTK_MISC(lines[i].txt), 0.0f, 0.5f); gtk_widget_size_request(lines[i].label, &req); if (max_width < req.width) { max_width = req.width; } } /* Pack labels */ for (i = 0; lines[i].label; i++) { GtkWidget *tmphbox; /* Add separators */ if (i == 3 || i == 5 || i == 7) { GtkWidget *separator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(tmpbox), separator, FALSE, FALSE, 0); } /* Set the label's width */ gtk_widget_set_size_request(lines[i].label, max_width, -1); /* add the widgets for this line */ tmphbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(tmphbox), lines[i].label, FALSE, TRUE, 5); gtk_box_pack_start(GTK_BOX(tmphbox), lines[i].txt, FALSE, TRUE, 5); /* Include tooltips */ if (!lines[i].tooltip) { gtk_box_pack_start(GTK_BOX(tmpbox), tmphbox, FALSE, FALSE, 0); } else { eventbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(eventbox), tmphbox); ctk_config_set_tooltip(ctk_config, eventbox, lines[i].tooltip); gtk_box_pack_start(GTK_BOX(tmpbox), eventbox, FALSE, FALSE, 0); } } } /* Flat Panel Scaling */ frame = gtk_frame_new("Flat Panel Scaling"); eventbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(eventbox), frame); gtk_box_pack_start(GTK_BOX(hbox), eventbox, FALSE, FALSE, 0); ctk_display_device_dfp->scaling_frame = eventbox; ctk_config_set_tooltip(ctk_config, eventbox, __scaling_help); vbox = gtk_vbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), vbox); button = gtk_check_button_new_with_label("Force Full GPU Scaling"); ctk_display_device_dfp->scaling_gpu_button = button; ctk_config_set_tooltip(ctk_config, button, __force_gpu_scaling_help); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); table = gtk_table_new(1, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 6); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); ctk_display_device_dfp->txt_scaling = add_table_row(table, 0, 0, 0.5, "Scaling:", 0, 0.5, ""); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); frame = gtk_frame_new("GPU Scaling Method"); gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), vbox); g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(dfp_scaling_changed), (gpointer) ctk_display_device_dfp); radio0 = make_scaling_radio_button (ctk_display_device_dfp, vbox, NULL, "Stretched", NV_CTRL_GPU_SCALING_METHOD_STRETCHED); radio1 = make_scaling_radio_button (ctk_display_device_dfp, vbox, radio0, "Centered", NV_CTRL_GPU_SCALING_METHOD_CENTERED); radio2 = make_scaling_radio_button (ctk_display_device_dfp, vbox, radio1, "Aspect Ratio Scaled", NV_CTRL_GPU_SCALING_METHOD_ASPECT_SCALED); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_GPU_SCALING), G_CALLBACK(dfp_update_received), (gpointer) ctk_display_device_dfp); /* pack the color controls */ ctk_display_device_dfp->color_controls = ctk_color_controls_new(handle, ctk_config, ctk_event, ctk_display_device_dfp->reset_button, display_device_mask, name); if (ctk_display_device_dfp->color_controls) { gtk_box_pack_start(GTK_BOX(object), ctk_display_device_dfp->color_controls, FALSE, FALSE, 0); } /* pack the dithering controls */ ctk_display_device_dfp->dithering_controls = ctk_dithering_controls_new(handle, ctk_config, ctk_event, ctk_display_device_dfp->reset_button, display_device_mask, name); if (ctk_display_device_dfp->dithering_controls) { gtk_box_pack_start(GTK_BOX(object), ctk_display_device_dfp->dithering_controls, FALSE, FALSE, 0); } /* pack the image sliders */ ctk_display_device_dfp->image_sliders = ctk_image_sliders_new(handle, ctk_config, ctk_event, ctk_display_device_dfp->reset_button, display_device_mask, name); if (ctk_display_device_dfp->image_sliders) { gtk_box_pack_start(GTK_BOX(object), ctk_display_device_dfp->image_sliders, FALSE, FALSE, 0); } /* pack the EDID button */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0); ctk_display_device_dfp->edid_box = hbox; /* show the page */ gtk_widget_show_all(GTK_WIDGET(object)); /* Update the GUI */ update_display_enabled_flag(ctk_display_device_dfp->handle, &ctk_display_device_dfp->display_enabled, ctk_display_device_dfp->display_device_mask); ctk_display_device_dfp_setup(ctk_display_device_dfp); /* handle enable/disable events on the display device */ g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS), G_CALLBACK(enabled_displays_received), (gpointer) ctk_display_device_dfp); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_GPU_SCALING_ACTIVE), G_CALLBACK(info_update_received), (gpointer) ctk_display_device_dfp); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_DFP_SCALING_ACTIVE), G_CALLBACK(info_update_received), (gpointer) ctk_display_device_dfp); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_FRONTEND_RESOLUTION), G_CALLBACK(info_update_received), (gpointer) ctk_display_device_dfp); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_FLATPANEL_BEST_FIT_RESOLUTION), G_CALLBACK(info_update_received), (gpointer) ctk_display_device_dfp); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_BACKEND_RESOLUTION), G_CALLBACK(info_update_received), (gpointer) ctk_display_device_dfp); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_REFRESH_RATE), G_CALLBACK(info_update_received), (gpointer) ctk_display_device_dfp); return GTK_WIDGET(object); } /* ctk_display_device_dfp_new() */
/***** * * 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() */
void ctk_drop_down_menu_set_tooltip(CtkConfig *ctk_config, CtkDropDownMenu *d, const gchar *text) { ctk_config_set_tooltip(ctk_config, GTK_WIDGET(d->combo_box), text); }
static GtkWidget *create_slider(CtkXVideo *ctk_xvideo, GtkWidget *vbox, GtkWidget *button, const gchar *name, const char *help, gint attribute, unsigned int bit) { GtkObject *adjustment; GtkWidget *scale, *widget; gint min, max, val, step_incr, page_incr; NVCTRLAttributeValidValuesRec range; ReturnStatus ret; /* get the attribute value */ ret = NvCtrlGetAttribute(ctk_xvideo->handle, attribute, &val); if (ret != NvCtrlSuccess) return NULL; /* get the range for the attribute */ NvCtrlGetValidAttributeValues(ctk_xvideo->handle, attribute, &range); if (range.type != ATTRIBUTE_TYPE_RANGE) return NULL; min = range.u.range.min; max = range.u.range.max; step_incr = ((max) - (min))/250; if (step_incr <= 0) step_incr = 1; page_incr = ((max) - (min))/25; if (page_incr <= 0) page_incr = 1; /* create the slider */ adjustment = gtk_adjustment_new(val, min, max, step_incr, page_incr, 0.0); g_object_set_data(G_OBJECT(adjustment), "xvideo_attribute", GINT_TO_POINTER(attribute)); g_signal_connect(G_OBJECT(adjustment), "value_changed", G_CALLBACK(slider_changed), (gpointer) ctk_xvideo); g_signal_connect_swapped(G_OBJECT(adjustment), "value_changed", G_CALLBACK(set_button_sensitive), (gpointer) button); scale = ctk_scale_new(GTK_ADJUSTMENT(adjustment), name, ctk_xvideo->ctk_config, G_TYPE_INT); gtk_box_pack_start(GTK_BOX(vbox), scale, TRUE, TRUE, 0); ctk_xvideo->active_attributes |= bit; widget = CTK_SCALE(scale)->gtk_scale; ctk_config_set_tooltip(ctk_xvideo->ctk_config, widget, help); return scale; } /* create_slider() */
GtkWidget* ctk_xvideo_new(NvCtrlAttributeHandle *handle, CtkConfig *ctk_config, CtkEvent *ctk_event) { GObject *object; CtkXVideo *ctk_xvideo; GtkWidget *banner; GtkWidget *frame; GtkWidget *alignment; GtkWidget *hbox; GtkWidget *label; GtkWidget *vbox; GtkWidget *button; int sync_mask; int xv_overlay_present, xv_texture_present, xv_blitter_present; ReturnStatus ret; /* * before we do anything else, determine if any of the Xv adapters * are present */ ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_OVERLAY_PRESENT, &xv_overlay_present); if (ret != NvCtrlSuccess) xv_overlay_present = FALSE; ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_TEXTURE_PRESENT, &xv_texture_present); if (ret != NvCtrlSuccess) xv_texture_present = FALSE; ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_BLITTER_PRESENT, &xv_blitter_present); if (ret != NvCtrlSuccess) xv_blitter_present = FALSE; if (!xv_overlay_present && !xv_texture_present && !xv_blitter_present) { return NULL; } /* create the XVideo widget */ object = g_object_new(CTK_TYPE_XVIDEO, NULL); ctk_xvideo = CTK_XVIDEO(object); ctk_xvideo->handle = handle; ctk_xvideo->ctk_config = ctk_config; ctk_xvideo->active_attributes = 0; gtk_box_set_spacing(GTK_BOX(ctk_xvideo), 10); /* Create button, but don't pack it, yet */ label = gtk_label_new("Reset Hardware Defaults"); hbox = gtk_hbox_new(FALSE, 0); button = gtk_button_new(); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15); gtk_container_add(GTK_CONTAINER(button), hbox); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(reset_defaults), (gpointer) ctk_xvideo); ctk_config_set_tooltip(ctk_config, button, __reset_button_help); /* Video film banner */ banner = ctk_banner_image_new(BANNER_ARTWORK_XVIDEO); gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0); /* XVideo Overlay sliders */ if (xv_overlay_present) { frame = gtk_frame_new("Video Overlay Adaptor"); gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), vbox); ctk_xvideo->overlay_saturation = create_slider(ctk_xvideo, vbox, button, "Saturation", __xv_overlay_saturation_help, NV_CTRL_ATTR_XV_OVERLAY_SATURATION, __XV_OVERLAY_SATURATION); ctk_xvideo->overlay_contrast = create_slider(ctk_xvideo, vbox, button, "Contrast", __xv_overlay_contrast_help, NV_CTRL_ATTR_XV_OVERLAY_CONTRAST, __XV_OVERLAY_CONTRAST); ctk_xvideo->overlay_brightness = create_slider(ctk_xvideo, vbox, button, "Brightness", __xv_overlay_brightness_help, NV_CTRL_ATTR_XV_OVERLAY_BRIGHTNESS, __XV_OVERLAY_BRIGHTNESS); ctk_xvideo->overlay_hue = create_slider(ctk_xvideo, vbox, button, "Hue", __xv_overlay_hue_help, NV_CTRL_ATTR_XV_OVERLAY_HUE, __XV_OVERLAY_HUE); } /* XVideo Texture */ if (xv_texture_present) { frame = gtk_frame_new("Video Texture Adaptor"); gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), vbox); ctk_xvideo->texture_sync_to_blank = create_check_button(ctk_xvideo, vbox, button, "Sync to VBlank", __xv_texture_sync_to_vblank_help, NV_CTRL_ATTR_XV_TEXTURE_SYNC_TO_VBLANK, __XV_TEXTURE_SYNC_TO_VBLANK); ctk_xvideo->texture_brightness = create_slider(ctk_xvideo, vbox, button, "Brightness", __xv_texture_brightness_help, NV_CTRL_ATTR_XV_TEXTURE_BRIGHTNESS, __XV_TEXTURE_BRIGHTNESS); ctk_xvideo->texture_contrast = create_slider(ctk_xvideo, vbox, button, "Contrast", __xv_texture_contrast_help, NV_CTRL_ATTR_XV_TEXTURE_CONTRAST, __XV_TEXTURE_CONTRAST); ctk_xvideo->texture_hue = create_slider(ctk_xvideo, vbox, button, "Hue", __xv_texture_hue_help, NV_CTRL_ATTR_XV_TEXTURE_HUE, __XV_TEXTURE_HUE); ctk_xvideo->texture_saturation = create_slider(ctk_xvideo, vbox, button, "Saturation", __xv_texture_saturation_help, NV_CTRL_ATTR_XV_TEXTURE_SATURATION, __XV_TEXTURE_SATURATION); } /* XVideo Blitter */ if (xv_blitter_present) { frame = gtk_frame_new("Video Blitter Adaptor Settings"); gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), vbox); ctk_xvideo->blitter_sync_to_blank = create_check_button(ctk_xvideo, vbox, button, "Sync to VBlank", __xv_blitter_sync_to_vblank_help, NV_CTRL_ATTR_XV_BLITTER_SYNC_TO_VBLANK, __XV_BLITTER_SYNC_TO_VBLANK); } /* Sync to display selection */ if (xv_texture_present || xv_blitter_present) { ret = NvCtrlGetAttribute(handle, NV_CTRL_XV_SYNC_TO_DISPLAY, &sync_mask); if (ret == NvCtrlSuccess) { int enabled; ret = NvCtrlGetAttribute(handle, NV_CTRL_ENABLED_DISPLAYS, &enabled); if (ret == NvCtrlSuccess) { GtkWidget *radio[24], *prev_radio; int i, n, current = -1, mask; char *name, *type; gchar *name_str; frame = gtk_frame_new("Sync to this display device"); gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), vbox); ctk_xvideo->xv_sync_to_display_button_box = vbox; for (n=0, i = 0; i < 24; i++) { mask = 1 << i; if (!(enabled & mask)) continue; /* get the name of the display device */ ret = NvCtrlGetStringDisplayAttribute(handle, mask, NV_CTRL_STRING_DISPLAY_DEVICE_NAME, &name); if ((ret != NvCtrlSuccess) || (!name)) { name = g_strdup("Unknown"); } /* get the display device type */ type = display_device_mask_to_display_device_name(mask); name_str = g_strdup_printf("%s (%s)", name, type); XFree(name); free(type); if (n==0) { prev_radio = NULL; } else { prev_radio = radio[n-1]; } radio[n] = xv_sync_to_display_radio_button_add(ctk_xvideo, prev_radio, name_str, mask, n); g_free(name_str); ctk_config_set_tooltip(ctk_config, radio[n], __xv_sync_to_display_help); if (mask == sync_mask) { current = n; } n++; ctk_xvideo->active_attributes |= __XV_SYNC_TO_DISPLAY; } g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_XV_SYNC_TO_DISPLAY), G_CALLBACK(xv_sync_to_display_update_received), (gpointer) ctk_xvideo); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS), G_CALLBACK(nv_ctrl_enabled_displays), (gpointer) ctk_xvideo); sensitize_radio_buttons(ctk_xvideo); if (current != -1) xv_sync_to_display_update_radio_buttons(ctk_xvideo, current); } } } /* Reset button */ sensitize_radio_buttons(ctk_xvideo); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), button); gtk_box_pack_start(GTK_BOX(object), alignment, TRUE, TRUE, 0); /* finally, show the widget */ gtk_widget_show_all(GTK_WIDGET(ctk_xvideo)); return GTK_WIDGET(ctk_xvideo); } /* ctk_xvideo_new() */
GtkWidget* ctk_display_device_tv_new(NvCtrlAttributeHandle *handle, CtkConfig *ctk_config, CtkEvent *ctk_event, char *name) { GObject *object; CtkDisplayDeviceTv *ctk_display_device_tv; GtkWidget *banner; GtkWidget *frame; GtkWidget *eventbox; GtkWidget *tmpbox; GtkWidget *hbox; GtkWidget *alignment; object = g_object_new(CTK_TYPE_DISPLAY_DEVICE_TV, NULL); if (!object) return NULL; ctk_display_device_tv = CTK_DISPLAY_DEVICE_TV(object); ctk_display_device_tv->handle = handle; ctk_display_device_tv->ctk_config = ctk_config; ctk_display_device_tv->ctk_event = ctk_event; ctk_display_device_tv->name = g_strdup(name); gtk_box_set_spacing(GTK_BOX(object), 10); /* banner */ banner = ctk_banner_image_new(BANNER_ARTWORK_TV); gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0); /* Information */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0); ctk_display_device_tv->info_frame = frame; hbox = gtk_hbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(hbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), hbox); tmpbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(hbox), tmpbox); ctk_display_device_tv->txt_encoder_name = gtk_label_new(""); ctk_display_device_tv->txt_refresh_rate = gtk_label_new(""); /* pack the Refresh Rate Label */ { typedef struct { GtkWidget *label; GtkWidget *txt; const gchar *tooltip; } TextLineInfo; TextLineInfo lines[] = { { gtk_label_new("TV Encoder:"), ctk_display_device_tv->txt_encoder_name, __tv_encoder_name_help, }, { gtk_label_new("TV Refresh Rate:"), ctk_display_device_tv->txt_refresh_rate, __tv_refresh_rate_help, }, { NULL, NULL, NULL } }; int i; GtkRequisition req; int max_width; /* Compute max width of lables and setup text alignments */ max_width = 0; for (i = 0; lines[i].label; i++) { gtk_misc_set_alignment(GTK_MISC(lines[i].label), 0.0f, 0.5f); gtk_misc_set_alignment(GTK_MISC(lines[i].txt), 0.0f, 0.5f); gtk_widget_size_request(lines[i].label, &req); if (max_width < req.width) { max_width = req.width; } } /* Pack labels */ for (i = 0; lines[i].label; i++) { GtkWidget *tmphbox; /* Add separators */ if (i == 1) { GtkWidget *separator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(tmpbox), separator, FALSE, FALSE, 0); } /* Set the label's width */ gtk_widget_set_size_request(lines[i].label, max_width, -1); /* add the widgets for this line */ tmphbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(tmphbox), lines[i].label, FALSE, TRUE, 5); gtk_box_pack_start(GTK_BOX(tmphbox), lines[i].txt, FALSE, TRUE, 5); /* Include tooltips */ if (!lines[i].tooltip) { gtk_box_pack_start(GTK_BOX(tmpbox), tmphbox, FALSE, FALSE, 0); } else { eventbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(eventbox), tmphbox); ctk_config_set_tooltip(ctk_config, eventbox, lines[i].tooltip); gtk_box_pack_start(GTK_BOX(tmpbox), eventbox, FALSE, FALSE, 0); } } } /* NV_CTRL_REFRESH_RATE */ g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_REFRESH_RATE), G_CALLBACK(info_update_received), (gpointer) ctk_display_device_tv); /* NV_CTRL_TV_OVERSCAN */ ctk_display_device_tv->overscan = add_scale(ctk_display_device_tv, NV_CTRL_TV_OVERSCAN, "TV OverScan", __tv_overscan_help); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_TV_OVERSCAN), G_CALLBACK(value_received), (gpointer) ctk_display_device_tv); /* NV_CTRL_TV_FLICKER_FILTER */ ctk_display_device_tv->flicker_filter = add_scale(ctk_display_device_tv, NV_CTRL_TV_FLICKER_FILTER, "TV Flicker Filter", __tv_flicker_filter_help); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_TV_FLICKER_FILTER), G_CALLBACK(value_received), (gpointer) ctk_display_device_tv); /* NV_CTRL_TV_BRIGHTNESS */ ctk_display_device_tv->brightness = add_scale(ctk_display_device_tv, NV_CTRL_TV_BRIGHTNESS, "TV Brightness", __tv_brightness_help); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_TV_BRIGHTNESS), G_CALLBACK(value_received), (gpointer) ctk_display_device_tv); /* NV_CTRL_TV_HUE */ ctk_display_device_tv->hue = add_scale(ctk_display_device_tv, NV_CTRL_TV_HUE, "TV Hue", __tv_hue_help); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_TV_HUE), G_CALLBACK(value_received), (gpointer) ctk_display_device_tv); /* NV_CTRL_TV_CONTRAST */ ctk_display_device_tv->contrast = add_scale(ctk_display_device_tv, NV_CTRL_TV_CONTRAST, "TV Contrast", __tv_contrast_help); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_TV_CONTRAST), G_CALLBACK(value_received), (gpointer) ctk_display_device_tv); /* NV_CTRL_TV_SATURATION */ ctk_display_device_tv->saturation = add_scale(ctk_display_device_tv, NV_CTRL_TV_SATURATION, "TV Saturation", __tv_saturation_help); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_TV_SATURATION), G_CALLBACK(value_received), (gpointer) ctk_display_device_tv); /* Create the reset button here so it can be used by the image sliders */ ctk_display_device_tv->reset_button = gtk_button_new_with_label("Reset TV Hardware Defaults"); /* create and pack the image sliders */ ctk_display_device_tv->image_sliders = ctk_image_sliders_new(handle, ctk_config, ctk_event, ctk_display_device_tv->reset_button, name); if (ctk_display_device_tv->image_sliders) { gtk_box_pack_start(GTK_BOX(object), ctk_display_device_tv->image_sliders, FALSE, FALSE, 0); } /* reset button */ g_signal_connect(G_OBJECT(ctk_display_device_tv->reset_button), "clicked", G_CALLBACK(reset_button_clicked), (gpointer) ctk_display_device_tv); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), ctk_display_device_tv->reset_button); gtk_box_pack_end(GTK_BOX(object), alignment, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_TV_RESET_SETTINGS), G_CALLBACK(value_received), (gpointer) ctk_display_device_tv); ctk_config_set_tooltip(ctk_config, ctk_display_device_tv->reset_button, ctk_help_create_reset_hardware_defaults_text("TV", name)); /* EDID button box */ ctk_display_device_tv->edid = ctk_edid_new(ctk_display_device_tv->handle, ctk_display_device_tv->ctk_config, ctk_display_device_tv->ctk_event, ctk_display_device_tv->name); 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_display_device_tv->edid, TRUE, TRUE, 0); /* finally, display the widget */ gtk_widget_show_all(GTK_WIDGET(object)); /* update the GUI */ update_display_enabled_flag(ctk_display_device_tv->handle, &ctk_display_device_tv->display_enabled); ctk_display_device_tv_setup(ctk_display_device_tv); /* handle enable/disable events on the display device */ g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS), G_CALLBACK(enabled_displays_received), (gpointer) ctk_display_device_tv); return GTK_WIDGET(object); } /* ctk_display_device_tv_new() */
GtkWidget* ctk_display_device_new(CtrlTarget *ctrl_target, CtkConfig *ctk_config, CtkEvent *ctk_event, CtkEvent *ctk_event_gpu, char *name, char *typeBaseName, ParsedAttribute *p) { GObject *object; CtkDisplayDevice *ctk_object; GtkWidget *banner; GtkWidget *hbox, *tmpbox; GtkWidget *alignment; GtkWidget *notebook; GtkWidget *nbox; GtkWidget *align; GtkWidget *label; GtkWidget *hseparator; GtkWidget *button; gchar *str; int i; object = g_object_new(CTK_TYPE_DISPLAY_DEVICE, NULL); if (!object) return NULL; ctk_object = CTK_DISPLAY_DEVICE(object); ctk_object->ctrl_target = ctrl_target; ctk_object->ctk_event = ctk_event; ctk_object->ctk_event_gpu = ctk_event_gpu; ctk_object->ctk_config = ctk_config; ctk_object->name = g_strdup(name); ctk_object->color_correction_available = FALSE; gtk_box_set_spacing(GTK_BOX(object), 10); /* Banner */ if (strcmp(typeBaseName, "CRT") == 0) { banner = ctk_banner_image_new(BANNER_ARTWORK_CRT); } else { banner = ctk_banner_image_new(BANNER_ARTWORK_DFP); } gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0); /* Create tabbed notebook for widget */ notebook = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP); gtk_box_pack_start(GTK_BOX(object), notebook, TRUE, TRUE, 0); /* Create first tab for device info */ nbox = gtk_vbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(nbox), FRAME_PADDING); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nbox, gtk_label_new("Information")); /* Device info */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(nbox), hbox, FALSE, FALSE, 0); label = gtk_label_new("Display Device Information"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); /* create the hbox to store device info */ hbox = gtk_hbox_new(FALSE, FRAME_PADDING); gtk_box_pack_start(GTK_BOX(nbox), hbox, FALSE, FALSE, FRAME_PADDING); /* * insert a vbox between the frame and the widgets, so that the * widgets don't expand to fill all of the space within the * frame */ tmpbox = gtk_vbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(tmpbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(hbox), tmpbox); /* Create and add the information widgets */ ctk_object->num_info_entries = ARRAY_LEN(__info_entry_data); ctk_object->info_entries = calloc(ctk_object->num_info_entries, sizeof(InfoEntry)); if (!ctk_object->info_entries) { ctk_object->num_info_entries = 0; } for (i = 0; i < ctk_object->num_info_entries; i++) { InfoEntryData *entryData = __info_entry_data+i; InfoEntry *entry = ctk_object->info_entries+i; gchar *str; entry->ctk_object = ctk_object; str = g_strconcat(entryData->str, ":", NULL); entry->label = gtk_label_new(str); g_free(str); entry->txt = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(entry->label), 0.0f, 0.5f); gtk_misc_set_alignment(GTK_MISC(entry->txt), 0.0f, 0.5f); ctk_config_set_tooltip(ctk_config, entry->label, *(entryData->tooltip)); ctk_config_set_tooltip(ctk_config, entry->txt, *(entryData->tooltip)); entry->hbox = gtk_hbox_new(FALSE, FRAME_PADDING); gtk_box_pack_start(GTK_BOX(entry->hbox), entry->label, FALSE, TRUE, FRAME_PADDING); gtk_box_pack_start(GTK_BOX(entry->hbox), entry->txt, FALSE, TRUE, FRAME_PADDING); gtk_box_pack_start(GTK_BOX(tmpbox), entry->hbox, FALSE, FALSE, 0); } /* pack the EDID button */ ctk_object->edid = ctk_edid_new(ctrl_target, ctk_object->ctk_config, ctk_object->ctk_event, ctk_object->name); hbox = gtk_hbox_new(FALSE, 0); align = gtk_alignment_new(0, 1, 1, 1); gtk_container_add(GTK_CONTAINER(align), hbox); gtk_box_pack_end(GTK_BOX(nbox), align, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), ctk_object->edid, TRUE, TRUE, 0); /* * Create layout for second tab for controls but don't add the tab until we * make sure it's required */ nbox = gtk_vbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(nbox), FRAME_PADDING); /* pack the reset button */ button = gtk_button_new_with_label("Reset Hardware Defaults"); str = ctk_help_create_reset_hardware_defaults_text(typeBaseName, name); ctk_config_set_tooltip(ctk_config, button, str); ctk_object->reset_button = button; alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), button); gtk_box_pack_end(GTK_BOX(nbox), alignment, FALSE, FALSE, 0); /* pack the color controls */ ctk_object->color_controls = ctk_color_controls_new(ctrl_target, ctk_config, ctk_event, ctk_object->reset_button, name); if (ctk_object->color_controls) { gtk_box_pack_start(GTK_BOX(nbox), ctk_object->color_controls, FALSE, FALSE, 0); } /* pack the dithering controls */ ctk_object->dithering_controls = ctk_dithering_controls_new(ctrl_target, ctk_config, ctk_event, ctk_object->reset_button, name); if (ctk_object->dithering_controls) { gtk_box_pack_start(GTK_BOX(nbox), ctk_object->dithering_controls, FALSE, FALSE, 0); } /* pack the image sliders */ ctk_object->image_sliders = ctk_image_sliders_new(ctrl_target, ctk_config, ctk_event, ctk_object->reset_button, name); if (ctk_object->image_sliders) { gtk_box_pack_start(GTK_BOX(nbox), ctk_object->image_sliders, FALSE, FALSE, 0); } /* If no controls are created, don't add a controls tab */ if (ctk_object->color_controls || ctk_object->dithering_controls || ctk_object->image_sliders) { gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nbox, gtk_label_new("Controls")); } /* * Show all widgets on this page so far. After this, the color correction * tab and other widgets can control their own visibility. */ gtk_widget_show_all(GTK_WIDGET(object)); /* add the color correction tab if RandR is available */ add_color_correction_tab(ctk_object, ctk_config, ctk_event, notebook, p); /* Update the GUI */ display_device_setup(ctk_object); /* Listen to events */ g_signal_connect(G_OBJECT(ctk_object->reset_button), "clicked", G_CALLBACK(reset_button_clicked), (gpointer) ctk_object); g_signal_connect(G_OBJECT(ctk_event_gpu), CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS), G_CALLBACK(enabled_displays_received), (gpointer) ctk_object); for (i = 0; i < ctk_object->num_info_entries; i++) { InfoEntryData *entryData = __info_entry_data+i; InfoEntry *entry = ctk_object->info_entries+i; if (entryData->register_events_func) { entryData->register_events_func(entry); } } return GTK_WIDGET(object); } /* ctk_display_device_new() */
/* * ctk_xvideo_new() - constructor for the XVideo widget */ GtkWidget* ctk_xvideo_new(CtrlTarget *ctrl_target, CtkConfig *ctk_config, CtkEvent *ctk_event) { GObject *object; CtkXVideo *ctk_xvideo; GtkWidget *banner; GtkWidget *frame; GtkWidget *alignment; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *hseparator; int xv_overlay_present, xv_texture_present, xv_blitter_present; int display_id; gboolean show_page; ReturnStatus ret; gchar *current_sync_name; /* * before we do anything else, determine if any of the Xv adapters * are present */ ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ATTR_EXT_XV_OVERLAY_PRESENT, &xv_overlay_present); if (ret != NvCtrlSuccess) { xv_overlay_present = FALSE; } ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ATTR_EXT_XV_TEXTURE_PRESENT, &xv_texture_present); if (ret != NvCtrlSuccess) { xv_texture_present = FALSE; } ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ATTR_EXT_XV_BLITTER_PRESENT, &xv_blitter_present); if (ret != NvCtrlSuccess) { xv_blitter_present = FALSE; } if (!xv_overlay_present && !xv_texture_present && !xv_blitter_present) { return NULL; } /* If nothing to show, bail */ show_page = FALSE; if (xv_texture_present || xv_blitter_present) { ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_XV_SYNC_TO_DISPLAY_ID, &display_id); if (ret == NvCtrlSuccess) { show_page = TRUE; } } if (!show_page) { return NULL; } /* create the XVideo widget */ object = g_object_new(CTK_TYPE_XVIDEO, NULL); ctk_xvideo = CTK_XVIDEO(object); ctk_xvideo->ctrl_target = ctrl_target; ctk_xvideo->ctk_config = ctk_config; ctk_xvideo->active_attributes = 0; gtk_box_set_spacing(GTK_BOX(ctk_xvideo), 10); /* Video film banner */ banner = ctk_banner_image_new(BANNER_ARTWORK_XVIDEO); gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0); /* Top Label */ hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0); label = gtk_label_new("Xvideo Settings"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 0); /* Current Sync Value */ ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_CURRENT_XV_SYNC_TO_DISPLAY_ID, &display_id); if (ret == NvCtrlSuccess) { hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 5); label = gtk_label_new("Currently synced to display:"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); label = gtk_label_new(""); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); current_sync_name = xv_sync_to_display_radio_button_label(ctk_xvideo, display_id); gtk_label_set_text(GTK_LABEL(label), current_sync_name); g_free(current_sync_name); ctk_xvideo->current_xv_sync_to_display_label = label; } else { ctk_xvideo->current_xv_sync_to_display_label = NULL; } /* Sync to display selection */ frame = gtk_frame_new("Sync to this display device"); gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), vbox); ctk_xvideo->xv_sync_to_display_button_box = vbox; ctk_config_set_tooltip(ctk_xvideo->ctk_config, ctk_xvideo->xv_sync_to_display_button_box, __xv_sync_to_display_help); xv_sync_to_display_rebuild_buttons(ctk_xvideo, FALSE); g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_XV_SYNC_TO_DISPLAY_ID), G_CALLBACK(xv_sync_to_display_id_handler), (gpointer) ctk_xvideo); if (ctk_xvideo->current_xv_sync_to_display_label) { g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_CURRENT_XV_SYNC_TO_DISPLAY_ID), G_CALLBACK(current_xv_sync_to_display_id_handler), (gpointer) ctk_xvideo); } g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS), G_CALLBACK(enabled_displays_handler), (gpointer) ctk_xvideo); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_box_pack_start(GTK_BOX(object), alignment, TRUE, TRUE, 0); /* finally, show the widget */ gtk_widget_show_all(GTK_WIDGET(ctk_xvideo)); return GTK_WIDGET(ctk_xvideo); }