GtkWidget* ctk_color_correction_page_new(CtrlTarget *ctrl_target, CtkConfig *ctk_config, ParsedAttribute *p, CtkEvent *ctk_event) { CtkColorCorrectionPage *ctk_color_correction_page; ReturnStatus ret; GObject *object; GtkWidget *banner; GtkWidget *ctk_color_correction; gint val; /* check if the VidMode extension is present */ ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ATTR_EXT_VM_PRESENT, &val); if ((ret != NvCtrlSuccess) || (val == FALSE)) { return NULL; } /* check if the noScanout mode enabled */ ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_NO_SCANOUT, &val); if ((ret == NvCtrlSuccess) && (val == NV_CTRL_NO_SCANOUT_ENABLED)) { return NULL; } /* allocate the color correction widget */ ctk_color_correction = ctk_color_correction_new(ctrl_target, ctk_config, p, ctk_event); if (ctk_color_correction == NULL) { return NULL; } /* create the new page */ object = g_object_new(CTK_TYPE_COLOR_CORRECTION_PAGE, NULL); ctk_color_correction_page = CTK_COLOR_CORRECTION_PAGE(object); gtk_box_set_spacing(GTK_BOX(ctk_color_correction_page), 10); /* * pack the banner at the top of the page, followed by the color * correction widget */ banner = ctk_banner_image_new(BANNER_ARTWORK_COLOR); gtk_box_pack_start(GTK_BOX(ctk_color_correction_page), banner, FALSE, FALSE, 0); gtk_widget_show_all(GTK_WIDGET(object)); gtk_box_pack_start(GTK_BOX(ctk_color_correction_page), ctk_color_correction, TRUE, TRUE, 0); return GTK_WIDGET(object); }
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); }
GtkWidget* ctk_help_new(GtkWidget *toggle_button, GtkTextTagTable *tag_table) { GObject *object; CtkHelp *ctk_help; GtkWidget *vbox, *hbox; GtkWidget *hseparator; GtkWidget *alignment; GtkWidget *button; GtkWidget *sw; GtkWidget *banner; GtkWidget *frame; GtkWidget *textview; object = g_object_new(CTK_TYPE_HELP, NULL); ctk_help = CTK_HELP(object); ctk_help->toggle_button = toggle_button; gtk_window_set_title(GTK_WINDOW(ctk_help), "NVIDIA X Server Settings Help"); gtk_window_set_default_size(GTK_WINDOW(ctk_help), -1, 400); gtk_container_set_border_width(GTK_CONTAINER(ctk_help), CTK_WINDOW_PAD); vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(ctk_help), vbox); /* create the banner */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); banner = ctk_banner_image_new(BANNER_ARTWORK_HELP); gtk_box_pack_start(GTK_BOX(hbox), banner, TRUE, TRUE, 0); /* create the scroll window to hold the text viewer */ frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(frame), sw); /* create the text viewer */ textview = gtk_text_view_new(); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE); ctk_help->text_viewer = textview; gtk_container_add(GTK_CONTAINER(sw), ctk_help->text_viewer); g_object_set(G_OBJECT(ctk_help->text_viewer), "pixels-inside-wrap", 10, NULL); /* save the tag table */ ctk_help->tag_table = tag_table; /* create the default help text */ ctk_help->default_help = create_default_help(ctk_help); gtk_text_view_set_buffer (GTK_TEXT_VIEW(ctk_help->text_viewer), ctk_help->default_help); /* place a horizontal separator */ hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vbox), hseparator, FALSE, FALSE, 0); /* create and place the close button */ hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), button); gtk_box_pack_start(GTK_BOX(hbox), alignment, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(close_button_clicked), (gpointer) ctk_help); /* handle destructive events to the window */ g_signal_connect(G_OBJECT(ctk_help), "destroy-event", G_CALLBACK(window_destroy), (gpointer) ctk_help); g_signal_connect(G_OBJECT(ctk_help), "delete-event", G_CALLBACK(window_destroy), (gpointer) ctk_help); return GTK_WIDGET(ctk_help); }
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_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() */
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() */
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() */
/* * 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; 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); }
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() */
/***** * * 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() */
/* * CTK VCS (Visual Computing System) widget creation * */ GtkWidget* ctk_vcs_new(NvCtrlAttributeHandle *handle, CtkConfig *ctk_config) { GObject *object; CtkVcs *ctk_object; GtkWidget *label; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *event; GtkWidget *banner; GtkWidget *hseparator; GtkWidget *table; GtkWidget *scrollWin; GtkWidget *checkbutton; gchar *product_name; gchar *serial_number; gchar *build_date; gchar *product_id; gchar *firmware_version; gchar *hardware_version; gint current_row; gboolean high_perf_mode; ReturnStatus ret; gchar *s; char *psu_str = NULL; PSUEntry psuEntry; GtkWidget *vbox_scroll, *hbox_scroll; /* * get the static string data that we will display below */ /* Product Name */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_PRODUCT_NAME, &product_name); if (ret != NvCtrlSuccess) { product_name = g_strdup("Unable to determine"); } /* Serial Number */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_SERIAL_NUMBER, &serial_number); if (ret != NvCtrlSuccess) { serial_number = g_strdup("Unable to determine"); } /* Build Date */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_BUILD_DATE, &build_date); if (ret != NvCtrlSuccess) { build_date = g_strdup("Unable to determine"); } /* Product ID */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_PRODUCT_ID, &product_id); if (ret != NvCtrlSuccess) { product_id = g_strdup("Unable to determine"); } /* Firmware Version */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_FIRMWARE_VERSION, &firmware_version); if (ret != NvCtrlSuccess) { firmware_version = g_strdup("Unable to determine"); } /* Hardware Version */ ret = NvCtrlGetStringAttribute(handle, NV_CTRL_STRING_VCSC_HARDWARE_VERSION, &hardware_version); if (ret != NvCtrlSuccess) { hardware_version = g_strdup("Unable to determine"); } /* now, create the object */ object = g_object_new(CTK_TYPE_VCS, NULL); ctk_object = CTK_VCS(object); /* cache the attribute handle */ ctk_object->handle = handle; ctk_object->ctk_config = ctk_config; /* set container properties of the object */ gtk_box_set_spacing(GTK_BOX(ctk_object), 10); /* banner */ banner = ctk_banner_image_new(BANNER_ARTWORK_VCS); gtk_box_pack_start(GTK_BOX(ctk_object), banner, FALSE, FALSE, 0); /* * This displays basic System information, including * display name, Operating system type and the NVIDIA driver version. */ vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(ctk_object), vbox, TRUE, TRUE, 0); /* General purpose error dialog */ ctk_object->error_dialog = create_error_dialog(ctk_object); if (NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE, &high_perf_mode) == NvCtrlSuccess) { hbox = gtk_hbox_new(FALSE, 0); checkbutton = gtk_check_button_new_with_label("Enable High Performance Mode"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), high_perf_mode); g_signal_connect(G_OBJECT(checkbutton), "toggled", G_CALLBACK(vcs_perf_checkbox_toggled), (gpointer) ctk_object); gtk_box_pack_start(GTK_BOX(hbox), checkbutton, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); } /* Create the Scrolling Window */ scrollWin = gtk_scrolled_window_new(NULL, NULL); hbox_scroll = gtk_hbox_new(FALSE, 0); vbox_scroll = gtk_vbox_new(FALSE, 5); event = gtk_event_box_new(); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollWin), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_modify_fg(event, GTK_STATE_NORMAL, &(event->style->text[GTK_STATE_NORMAL])); gtk_widget_modify_bg(event, GTK_STATE_NORMAL, &(event->style->base[GTK_STATE_NORMAL])); gtk_container_add(GTK_CONTAINER(event), hbox_scroll); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollWin), event); gtk_box_pack_start(GTK_BOX(hbox_scroll), vbox_scroll, TRUE, TRUE, 5); gtk_widget_set_size_request(scrollWin, -1, 50); gtk_box_pack_start(GTK_BOX(vbox), scrollWin, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); label = gtk_label_new("VCS Information"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); table = gtk_table_new(5, 2, FALSE); gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(table), 3); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); add_table_row(table, 0, 0, 0.5, "Product Name:", 0, 0.5, product_name); add_table_row(table, 1, 0, 0.5, "Serial Number:", 0, 0.5, serial_number); add_table_row(table, 2, 0, 0.5, "Build Date:", 0, 0.5, build_date); add_table_row(table, 3, 0, 0.5, "Product ID:", 0, 0.5, product_id); add_table_row(table, 4, 0, 0.5, "Firmware version:", 0, 0.5, firmware_version); add_table_row(table, 5, 0, 0.5, "Hardware version:", 0, 0.5, hardware_version); g_free(product_name); g_free(serial_number); g_free(build_date); g_free(product_id); g_free(firmware_version); g_free(hardware_version); /* Query Canoas 2.0 specific details */ if ((NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE, &high_perf_mode) == NvCtrlSuccess) && (NvCtrlGetStringAttribute(ctk_object->handle, NV_CTRL_STRING_VCSC_PSU_INFO, &psu_str) == NvCtrlSuccess)) { GtkWidget *vbox_padding; /* Show the additonal queried information */ /* Populate scrolling window with data */ vbox_padding = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); label = gtk_label_new("VCS Thermal Information"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); table = gtk_table_new(3, 2, FALSE); gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(table), 3); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); label = gtk_label_new("Intake Temperature:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->intake_temp = label; label = gtk_label_new("Exhaust Temperature:"); /* This is the current largest label. Get its size */ gtk_widget_size_request(label, &ctk_object->req); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->exhaust_temp = label; label = gtk_label_new("Board Temperature:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 2, 3, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->board_temp = label; /* Populate table for PSU information */ psuEntry.psu_current = -1; psuEntry.psu_power = -1; psuEntry.psu_voltage = -1; psuEntry.psu_state = -1; if (psu_str) { parse_token_value_pairs(psu_str, apply_psu_entry_token, &psuEntry); } vbox_padding = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); label = gtk_label_new("VCS Power Supply Unit Information"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); table = gtk_table_new(4, 2, FALSE); gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(table), 3); gtk_table_set_col_spacings(GTK_TABLE(table), 15); gtk_container_set_border_width(GTK_CONTAINER(table), 5); label = gtk_label_new("PSU State:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->psu_state = label; label = gtk_label_new("PSU Current:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->psu_current = label; current_row = 2; if (psuEntry.psu_power != -1) { label = gtk_label_new("PSU Power:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->psu_power = label; current_row++; } if (psuEntry.psu_voltage != -1) { label = gtk_label_new("PSU Voltage:"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_widget_set_size_request(label, ctk_object->req.width, -1); gtk_table_attach(GTK_TABLE(table), label, 0, 1, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f); gtk_table_attach(GTK_TABLE(table), label, 1, 2, current_row, current_row + 1, GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0); ctk_object->psu_voltage = label; } /* Create container for fan status table */ vbox_padding = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); label = gtk_label_new("VCS Fan Status"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0); ctk_object->fan_status_container = hbox; /* Register a timer callback to update the dynamic information */ s = g_strdup_printf("VCS Monitor (VCS %d)", NvCtrlGetTargetId(ctk_object->handle)); ctk_config_add_timer(ctk_object->ctk_config, DEFAULT_UPDATE_VCS_INFO_TIME_INTERVAL, s, (GSourceFunc) update_vcs_info, (gpointer) ctk_object); g_free(s); update_vcs_info(ctk_object); } gtk_widget_show_all(GTK_WIDGET(object)); return GTK_WIDGET(object); }