From 7b431be3d35cd1e1864ba8e09730498b9dc25a82 Mon Sep 17 00:00:00 2001 From: Aaron Plattner Date: Tue, 12 Feb 2008 21:28:58 -0800 Subject: 1.0-9746 --- src/XF86Config-parser/Generate.c | 2 + src/XF86Config-parser/Monitor.c | 11 +- src/gtk+-2.x/ctkclocks.c | 31 ++- src/gtk+-2.x/ctkclocks.h | 1 + src/gtk+-2.x/ctkdisplayconfig.c | 16 +- src/gtk+-2.x/ctkdisplaydevice-dfp.c | 20 +- src/gtk+-2.x/ctkdisplaydevice-dfp.h | 1 - src/gtk+-2.x/ctkdisplaylayout.c | 15 +- src/gtk+-2.x/ctkevent.c | 3 +- src/gtk+-2.x/ctkmultisample.c | 372 +++++++++++++++++++++++++++++------- src/gtk+-2.x/ctkmultisample.h | 1 + src/gtk+-2.x/ctkopengl.c | 132 +++++++++---- src/libXNVCtrl/NVCtrl.h | 28 ++- src/libXNVCtrl/NVCtrlLib.h | 7 + src/libXNVCtrl/libXNVCtrl.a | Bin 17180 -> 17180 bytes src/parse.c | 7 +- 16 files changed, 506 insertions(+), 141 deletions(-) diff --git a/src/XF86Config-parser/Generate.c b/src/XF86Config-parser/Generate.c index d61771a..3d2da41 100644 --- a/src/XF86Config-parser/Generate.c +++ b/src/XF86Config-parser/Generate.c @@ -405,6 +405,8 @@ static void add_modules(GenerateOptions *gop, XConfigPtr config) XCONFIG_LOAD_MODULE, NULL, FALSE); l = xconfigAddNewLoadDirective(l, xconfigStrdup("bitstream"), XCONFIG_LOAD_MODULE, NULL, FALSE); + l = xconfigAddNewLoadDirective(l, xconfigStrdup("xtsol"), + XCONFIG_LOAD_MODULE, NULL, FALSE); #else l = xconfigAddNewLoadDirective(l, xconfigStrdup("freetype"), XCONFIG_LOAD_MODULE, NULL, FALSE); diff --git a/src/XF86Config-parser/Monitor.c b/src/XF86Config-parser/Monitor.c index 8c273c4..cacc284 100644 --- a/src/XF86Config-parser/Monitor.c +++ b/src/XF86Config-parser/Monitor.c @@ -668,9 +668,14 @@ xconfigPrintMonitorSection (FILE * cf, XConfigMonitorPtr ptr) } for (i = 0; i < ptr->n_vrefresh; i++) { - fprintf (cf, " VertRefresh %2.1f - %2.1f\n", - ptr->vrefresh[i].lo, - ptr->vrefresh[i].hi); + if (ptr->vrefresh[i].lo == ptr->vrefresh[i].hi) { + fprintf (cf, " VertRefresh %2.1f\n", + ptr->vrefresh[i].lo); + } else { + fprintf (cf, " VertRefresh %2.1f - %2.1f\n", + ptr->vrefresh[i].lo, + ptr->vrefresh[i].hi); + } } if (ptr->gamma_red) { if (ptr->gamma_red == ptr->gamma_green diff --git a/src/gtk+-2.x/ctkclocks.c b/src/gtk+-2.x/ctkclocks.c index 139c5a6..8a93a9b 100644 --- a/src/gtk+-2.x/ctkclocks.c +++ b/src/gtk+-2.x/ctkclocks.c @@ -296,7 +296,8 @@ GtkWidget* ctk_clocks_new(NvCtrlAttributeHandle *handle, NVCTRLAttributeValidValuesRec ranges_3D; Bool overclocking_enabled; - Bool probing_optimal; + Bool auto_detection_available = FALSE; + Bool probing_optimal = FALSE; Bool can_access_2d_clocks; Bool can_access_3d_clocks; @@ -318,13 +319,18 @@ GtkWidget* ctk_clocks_new(NvCtrlAttributeHandle *handle, if ( overclocking_enabled ) { ret = NvCtrlGetAttribute(handle, - NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE, + NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION, &value); - if ( ret != NvCtrlSuccess ) - return NULL; - probing_optimal = (value==NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY); - } else { - probing_optimal = FALSE; + 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? */ @@ -365,6 +371,7 @@ GtkWidget* ctk_clocks_new(NvCtrlAttributeHandle *handle, ctk_object->ctk_config = ctk_config; ctk_object->license_accepted = // = overclocking_enabled 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 */ @@ -510,7 +517,8 @@ GtkWidget* ctk_clocks_new(NvCtrlAttributeHandle *handle, gtk_widget_set_sensitive(ctk_object->detect_button, False); } else { gtk_widget_set_sensitive(ctk_object->detect_button, - overclocking_enabled && !probing_optimal); + overclocking_enabled && + auto_detection_available && !probing_optimal); } /* Create the Reset hardware button widget */ @@ -827,9 +835,12 @@ static void sync_gui_sensitivity(CtkClocks *ctk_object) __cancel_button_help); } else { + gboolean set_sensitive; gtk_button_set_label(GTK_BUTTON(ctk_object->detect_button), "Auto Detect"); - gtk_widget_set_sensitive(ctk_object->detect_button, - (ctk_object->clocks_being_modified == CLOCKS_3D)?enabled:False); + 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); } diff --git a/src/gtk+-2.x/ctkclocks.h b/src/gtk+-2.x/ctkclocks.h index da42299..8898452 100644 --- a/src/gtk+-2.x/ctkclocks.h +++ b/src/gtk+-2.x/ctkclocks.h @@ -84,6 +84,7 @@ struct _CtkClocks Bool clocks_moved; /* The clock sliders were moved by the user */ Bool overclocking_enabled; /* Overclocking is enabled */ + Bool auto_detection_available; /* Optimal clock detection is available */ Bool probing_optimal; /* Optimal clocks being probed */ }; diff --git a/src/gtk+-2.x/ctkdisplayconfig.c b/src/gtk+-2.x/ctkdisplayconfig.c index 8cacd6a..18cb851 100644 --- a/src/gtk+-2.x/ctkdisplayconfig.c +++ b/src/gtk+-2.x/ctkdisplayconfig.c @@ -697,6 +697,16 @@ static const char *read_display_name(const char *str, unsigned int *bit) return skip_whitespace(str); } +/* + * read_float_range() + * + * Reads the maximun/minimum information from a string in the + * following format: + * "MIN-MAX" + * or + * "MIN" + */ + static int read_float_range(char *str, float *min, float *max) { if (!str) return 0; @@ -704,7 +714,10 @@ static int read_float_range(char *str, float *min, float *max) str = (char *)skip_whitespace(str); *min = atof(str); str = strstr(str, "-"); - if (!str) return 0; + if (!str) { + *max = *min; + return 1; + } str++; *max = atof(str); @@ -6556,6 +6569,7 @@ static void do_configure_display_for_twinview(CtkDisplayConfig *ctk_object, } screen->scrnum = other->scrnum; screen->handle = other->handle; + screen->ctk_event = other->ctk_event; } else { if (other->handle) { NvCtrlAttributeClose(other->handle); diff --git a/src/gtk+-2.x/ctkdisplaydevice-dfp.c b/src/gtk+-2.x/ctkdisplaydevice-dfp.c index 0c0e3f6..f5ec919 100644 --- a/src/gtk+-2.x/ctkdisplaydevice-dfp.c +++ b/src/gtk+-2.x/ctkdisplaydevice-dfp.c @@ -99,11 +99,12 @@ static void info_update_received(GtkObject *object, gpointer arg1, static const char *__scaling_help = -"A flat panel usually has a single 'native' " -"resolution. If you are using a resolution that is " -"smaller than the flat panel's native resolution, then " -"Flat Panel Scaling can adjust how the image is " -"displayed on the flat panel."; +"A flat panel usually has a single 'native' resolution. If you are " +"using a resolution that is smaller than the flat panel's native " +"resolution, then Flat Panel Scaling can adjust how the image is " +"displayed on the flat panel. This setting will only take effect " +"when GPU scaling is active (This occurs when the frontend and " +"backend resolutions of the current mode are different.)"; static const char *__dithering_help = "Some GeForce2 GPUs required dithering to " @@ -414,7 +415,6 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle, vbox = gtk_vbox_new(FALSE, FRAME_PADDING); gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), vbox); - ctk_display_device_dfp->scaling_method_frame = frame; g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(dfp_scaling_changed), @@ -1256,14 +1256,6 @@ static void dfp_info_setup(CtkDisplayDeviceDfp *ctk_display_device_dfp) } } - if (gpu_scaling) { - gtk_widget_set_sensitive(ctk_display_device_dfp->scaling_method_frame, - TRUE); - } else { - gtk_widget_set_sensitive(ctk_display_device_dfp->scaling_method_frame, - FALSE); - } - gtk_label_set_text (GTK_LABEL(ctk_display_device_dfp->txt_scaling), scaling); diff --git a/src/gtk+-2.x/ctkdisplaydevice-dfp.h b/src/gtk+-2.x/ctkdisplaydevice-dfp.h index 176445f..98b7edf 100644 --- a/src/gtk+-2.x/ctkdisplaydevice-dfp.h +++ b/src/gtk+-2.x/ctkdisplaydevice-dfp.h @@ -78,7 +78,6 @@ struct _CtkDisplayDeviceDfp GtkWidget *scaling_frame; GtkWidget *scaling_gpu_button; - GtkWidget *scaling_method_frame; GtkWidget *scaling_method_buttons[NV_CTRL_GPU_SCALING_METHOD_ASPECT_SCALED]; GtkWidget *dithering_frame; GtkWidget *dithering_buttons[NV_CTRL_FLATPANEL_DITHERING_DISABLED+1]; diff --git a/src/gtk+-2.x/ctkdisplaylayout.c b/src/gtk+-2.x/ctkdisplaylayout.c index 53e2e2a..bbbd562 100644 --- a/src/gtk+-2.x/ctkdisplaylayout.c +++ b/src/gtk+-2.x/ctkdisplaylayout.c @@ -3187,8 +3187,19 @@ void ctk_display_layout_set_display_position(CtkDisplayLayout *ctk_object, /* Set the new positioning type */ - display->cur_mode->position_type = position_type; - display->cur_mode->relative_to = relative_to; + if (ctk_object->advanced_mode) { + display->cur_mode->position_type = position_type; + display->cur_mode->relative_to = relative_to; + + } else { + nvModePtr mode; + + for (mode = display->modes; mode; mode = mode->next) { + mode->position_type = position_type; + mode->relative_to = relative_to; + } + } + switch (position_type) { case CONF_ADJ_ABSOLUTE: diff --git a/src/gtk+-2.x/ctkevent.c b/src/gtk+-2.x/ctkevent.c index ea07840..75cfee5 100644 --- a/src/gtk+-2.x/ctkevent.c +++ b/src/gtk+-2.x/ctkevent.c @@ -241,6 +241,7 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class) MAKE_SIGNAL(NV_CTRL_FLATPANEL_BEST_FIT_RESOLUTION); MAKE_SIGNAL(NV_CTRL_GPU_SCALING_ACTIVE); MAKE_SIGNAL(NV_CTRL_DFP_SCALING_ACTIVE); + MAKE_SIGNAL(NV_CTRL_FSAA_APPLICATION_ENHANCED); #undef MAKE_SIGNAL @@ -251,7 +252,7 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class) * knows about. */ -#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_DFP_SCALING_ACTIVE +#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_FSAA_APPLICATION_ENHANCED #warning "There are attributes that do not emit signals!" #endif diff --git a/src/gtk+-2.x/ctkmultisample.c b/src/gtk+-2.x/ctkmultisample.c index 54b22f8..5bd7b91 100644 --- a/src/gtk+-2.x/ctkmultisample.c +++ b/src/gtk+-2.x/ctkmultisample.c @@ -48,14 +48,19 @@ static gchar *format_fsaa_value(GtkScale *scale, gdouble arg1, static const gchar *get_multisample_mode_name(gint multisample_mode); -static void post_fsaa_app_override_toggled(CtkMultisample *ctk_multisample, - gboolean override); +static GtkWidget *create_fsaa_setting_menu(CtkMultisample *ctk_multisample, + CtkEvent *ctk_event, + gboolean override, + gboolean enhance); -static void fsaa_app_override_toggled(GtkWidget *widget, gpointer user_data); +static void fsaa_setting_checkbox_toggled(GtkWidget *widget, + gpointer user_data); -static void fsaa_app_override_update_received(GtkObject *object, - gpointer arg1, - gpointer user_data); +static void fsaa_setting_menu_changed(GtkWidget *widget, gpointer user_data); + +static void fsaa_setting_update_received(GtkObject *object, + gpointer arg1, + gpointer user_data); static void post_fsaa_value_changed(CtkMultisample *ctk_multisample, gint val); @@ -104,6 +109,11 @@ static const char *__aa_override_app_help = "override any appliation antialiasing setting with the " "value of the slider."; +static const char *__aa_menu_help = +"The Application Antialiasing Settings Menu allows the antialiasing " +"setting of OpenGL applications to be overriden with the value of " +"the slider."; + static const char *__aa_slider_help = "The Antialiasing slider controls the level of antialiasing."; @@ -141,6 +151,10 @@ static const char *__texture_sharpening_help = #define __FSAA_8x (1 << (__FSAA + NV_CTRL_FSAA_MODE_8x)) #define __FSAA_16x (1 << (__FSAA + NV_CTRL_FSAA_MODE_16x)) #define __FSAA_8xS (1 << (__FSAA + NV_CTRL_FSAA_MODE_8xS)) +#define __FSAA_8xQ (1 << (__FSAA + NV_CTRL_FSAA_MODE_8xQ)) +#define __FSAA_16xS (1 << (__FSAA + NV_CTRL_FSAA_MODE_16xS)) +#define __FSAA_16xQ (1 << (__FSAA + NV_CTRL_FSAA_MODE_16xQ)) +#define __FSAA_ENHANCE (1 << (__FSAA + NV_CTRL_FSAA_MODE_MAX +1)) #define FRAME_PADDING 5 @@ -186,9 +200,10 @@ GtkWidget *ctk_multisample_new(NvCtrlAttributeHandle *handle, GtkWidget *banner; GtkWidget *frame; GtkWidget *check_button; + GtkWidget *menu; GtkWidget *scale; - gint val, app_control, override, i; + gint val, app_control, override, enhance, i; NVCTRLAttributeValidValuesRec valid; @@ -251,30 +266,51 @@ GtkWidget *ctk_multisample_new(NvCtrlAttributeHandle *handle, gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING); gtk_container_add(GTK_CONTAINER(frame), vbox); - /* "Override Application Setting" checkbox */ - - check_button = gtk_check_button_new_with_label - ("Override Application Setting"); - - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), - override); - - g_signal_connect(G_OBJECT(check_button), "toggled", - G_CALLBACK(fsaa_app_override_toggled), - (gpointer) ctk_multisample); + /* "Application Setting" widget */ + ret = NvCtrlGetAttribute(ctk_multisample->handle, + NV_CTRL_FSAA_APPLICATION_ENHANCED, + &enhance); + + if (ret == NvCtrlSuccess) { + /* Create a menu */ + + ctk_multisample->active_attributes |= __FSAA_ENHANCE; + + menu = create_fsaa_setting_menu(ctk_multisample, ctk_event, + override, enhance); + + ctk_multisample->fsaa_menu = menu; + + hbox = gtk_hbox_new(FALSE, 0); + gtk_box_pack_start(GTK_BOX(hbox), menu, FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); + + } else { + /* Create a checkbox */ + + check_button = gtk_check_button_new_with_label + ("Override Application Setting"); + + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), + override); + + g_signal_connect(G_OBJECT(check_button), "toggled", + G_CALLBACK(fsaa_setting_checkbox_toggled), + (gpointer) ctk_multisample); + + ctk_config_set_tooltip(ctk_config, check_button, + __aa_override_app_help); + + gtk_box_pack_start(GTK_BOX(vbox), check_button, + FALSE, FALSE, 0); + } + g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME (NV_CTRL_FSAA_APPLICATION_CONTROLLED), - G_CALLBACK(fsaa_app_override_update_received), + G_CALLBACK(fsaa_setting_update_received), (gpointer) ctk_multisample); - - ctk_config_set_tooltip(ctk_config, check_button, - __aa_override_app_help); - - gtk_box_pack_start(GTK_BOX(vbox), check_button, FALSE, FALSE, 0); - - ctk_multisample->fsaa_app_override_check_button = check_button; /* Antialiasing scale */ @@ -590,7 +626,10 @@ static const gchar *get_multisample_mode_name(gint multisample_mode) "4x, 9-tap Gaussian", /* FSAA_MODE_4x_9t */ "8x", /* FSAA_MODE_8x */ "16x", /* FSAA_MODE_16x */ - "8xS" /* FSAA_MODE_8xS */ + "8xS", /* FSAA_MODE_8xS */ + "8xQ", /* FSAA_MODE_8xQ */ + "16xS", /* FSAA_MODE_16xS */ + "16xQ" /* FSAA_MODE_16xQ */ }; if ((multisample_mode < NV_CTRL_FSAA_MODE_NONE) || @@ -605,15 +644,81 @@ static const gchar *get_multisample_mode_name(gint multisample_mode) /* - * post_fsaa_app_override_toggled() - helper function for - * fsaa_app_override_toggled() and fsaa_app_override_update_received(); - * this does whatever work is necessary after the app control check - * button has been toggled -- update the slider's sensitivity and post - * a statusbar message. + * create_fsaa_setting_menu() - Helper function that creates the + * FSAA application control dropdown menu. */ -static void post_fsaa_app_override_toggled(CtkMultisample *ctk_multisample, - gboolean override) +static GtkWidget *create_fsaa_setting_menu(CtkMultisample *ctk_multisample, + CtkEvent *ctk_event, + gboolean override, gboolean enhance) +{ + GtkWidget *omenu; + GtkWidget *menu; + GtkWidget *menu_item; + gint idx; + + /* Create the menu */ + + omenu = gtk_option_menu_new(); + + menu = gtk_menu_new(); + + menu_item = gtk_menu_item_new_with_label("Use Application Settings"); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); + gtk_widget_show(menu_item); + + menu_item = gtk_menu_item_new_with_label("Override Application Settings"); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); + gtk_widget_show(menu_item); + + menu_item = gtk_menu_item_new_with_label("Enhance Application Settings"); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); + gtk_widget_show(menu_item); + + /* Set the state of the menu */ + + if (!override) { + idx = 0; + } else { + if (!enhance) { + idx = 1; + } else { + idx = 2; + } + } + + gtk_option_menu_set_menu(GTK_OPTION_MENU(omenu), menu); + + gtk_option_menu_set_history(GTK_OPTION_MENU(omenu), idx); + + ctk_config_set_tooltip(ctk_multisample->ctk_config, omenu, + __aa_menu_help); + + g_signal_connect(G_OBJECT(omenu), "changed", + G_CALLBACK(fsaa_setting_menu_changed), + (gpointer) ctk_multisample); + + g_signal_connect(G_OBJECT(ctk_event), + CTK_EVENT_NAME + (NV_CTRL_FSAA_APPLICATION_ENHANCED), + G_CALLBACK(fsaa_setting_update_received), + (gpointer) ctk_multisample); + + return omenu; + +} /* create_fsaa_setting_menu() */ + + + +/* + * post_fsaa_setting_changed() - helper function for update_fsaa_setting() + * and fsaa_menu_update_received(); This does whatever work is necessary + * after the dropdown/checkbox has changed -- update the slider's + * sensitivity and post a statusbar message. + */ + +static void post_fsaa_setting_changed(CtkMultisample *ctk_multisample, + gboolean override, gboolean enhance) { if (ctk_multisample->fsaa_scale) { gtk_widget_set_sensitive @@ -621,29 +726,33 @@ static void post_fsaa_app_override_toggled(CtkMultisample *ctk_multisample, } ctk_config_statusbar_message(ctk_multisample->ctk_config, - "Application Antialiasing Override %s.", - override ? "enabled" : "disabled"); + "%s Application's Antialiasing Settings.", + (!override ? "Using" : + (enhance ? "Enhancing" : "Overriding"))); -} /* post_fsaa_app_override_toggled() */ +} /* post_fsaa_setting_changed() */ /* - * fsaa_app_override_toggled() - called when the FSAA Application - * override check button is toggled; update the server and set the - * sensitivity of the fsaa slider. + * update_fsaa_setting() - Helper function for updating the server when the + * user changes the Application's Antialiasing settings. + * */ -static void fsaa_app_override_toggled(GtkWidget *widget, gpointer user_data) +static void update_fsaa_setting(CtkMultisample *ctk_multisample, + gboolean override, gboolean enhance) { - CtkMultisample *ctk_multisample = CTK_MULTISAMPLE(user_data); GtkRange *range = GTK_RANGE(ctk_multisample->fsaa_scale); - gboolean override; - - override = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); NvCtrlSetAttribute(ctk_multisample->handle, NV_CTRL_FSAA_APPLICATION_CONTROLLED, !override); + + if (ctk_multisample->active_attributes & __FSAA_ENHANCE) { + NvCtrlSetAttribute(ctk_multisample->handle, + NV_CTRL_FSAA_APPLICATION_ENHANCED, enhance); + } + if (!override) { NvCtrlSetAttribute(ctk_multisample->handle, NV_CTRL_FSAA_MODE, NV_CTRL_FSAA_MODE_NONE); @@ -659,42 +768,152 @@ static void fsaa_app_override_toggled(GtkWidget *widget, gpointer user_data) (gpointer) ctk_multisample); } - post_fsaa_app_override_toggled(ctk_multisample, override); + post_fsaa_setting_changed(ctk_multisample, override, enhance); -} /* fsaa_app_override_toggled() */ +} /* update_fsaa_setting() */ /* - * fsaa_app_override_update_received() - callback function for when the - * NV_CTRL_FSAA_APPLICATION_CONTROLLED attribute is changed by another + * fsaa_setting_checkbox_toggled() - called when the FSAA Application + * checkbox is changed; update the server and set the sensitivity of + * the fsaa slider. + */ + +static void fsaa_setting_checkbox_toggled(GtkWidget *widget, + gpointer user_data) +{ + CtkMultisample *ctk_multisample = CTK_MULTISAMPLE(user_data); + gboolean override; + + override = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); + + update_fsaa_setting(ctk_multisample, override, FALSE /* enhance */ ); + +} /* fsaa_setting_checkbox_toggled() */ + + + +/* + * fsaa_setting_menu_changed() - called when the FSAA Application + * menu is changed; update the server and set the sensitivity of + * the fsaa slider. + */ + +static void fsaa_setting_menu_changed(GtkWidget *widget, gpointer user_data) +{ + CtkMultisample *ctk_multisample = CTK_MULTISAMPLE(user_data); + gint idx; + gboolean override; + gboolean enhance; + + idx = gtk_option_menu_get_history(GTK_OPTION_MENU(widget)); + + /* The FSAA dropdown menu is setup this way: + * + * 0 == app + * 1 == override + * 2 == enhance + */ + + override = (idx > 0) ? TRUE : FALSE; + enhance = (idx == 2) ? TRUE : FALSE; + + update_fsaa_setting(ctk_multisample, override, enhance); + +} /* fsaa_setting_menu_changed() */ + + + +/* + * fsaa_setting_update_received() - callback function for when the + * NV_CTRL_FSAA_APPLICATION_CONTROLLED/ENHANCE attribute is changed by another * NV-CONTROL client. */ -static void fsaa_app_override_update_received(GtkObject *object, - gpointer arg1, - gpointer user_data) +static void fsaa_setting_update_received(GtkObject *object, + gpointer arg1, + gpointer user_data) { CtkEventStruct *event_struct = (CtkEventStruct *) arg1; CtkMultisample *ctk_multisample = CTK_MULTISAMPLE(user_data); - GtkWidget *check_button; - gboolean override = !event_struct->value; - - check_button = ctk_multisample->fsaa_app_override_check_button; - - g_signal_handlers_block_by_func(G_OBJECT(check_button), - G_CALLBACK(fsaa_app_override_toggled), - (gpointer) ctk_multisample); - - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), override); - - post_fsaa_app_override_toggled(ctk_multisample, override); + gint idx; + gboolean override; + gboolean enhance = FALSE; + + gint val; + ReturnStatus ret; + + + switch (event_struct->attribute) { + case NV_CTRL_FSAA_APPLICATION_CONTROLLED: + override = !event_struct->value; + + if (!override) { + idx = 0; + } else if (ctk_multisample->active_attributes & __FSAA_ENHANCE) { + ret = NvCtrlGetAttribute(ctk_multisample->handle, + NV_CTRL_FSAA_APPLICATION_ENHANCED, + &val); + enhance = val; + idx = enhance ? 2 : 1; + } else { + idx = 1; + } + break; + + case NV_CTRL_FSAA_APPLICATION_ENHANCED: + enhance = event_struct->value; + + ret = NvCtrlGetAttribute(ctk_multisample->handle, + NV_CTRL_FSAA_APPLICATION_CONTROLLED, + &val); + override = !val; /* = !app_controlled */ + + if (override) { + idx = enhance ? 2 : 1; + } else { + idx = 0; + } + break; + + default: + return; + } + + + if (ctk_multisample->fsaa_menu) { + /* Update the dropdown menu */ + GtkWidget *menu = ctk_multisample->fsaa_menu; + + g_signal_handlers_block_by_func + (G_OBJECT(menu), G_CALLBACK(fsaa_setting_menu_changed), + (gpointer) ctk_multisample); + + gtk_option_menu_set_history(GTK_OPTION_MENU(menu), idx); + + g_signal_handlers_unblock_by_func + (G_OBJECT(menu), G_CALLBACK(fsaa_setting_menu_changed), + (gpointer) ctk_multisample); + } else { + /* Update the checkbox */ + GtkWidget *button = ctk_multisample->fsaa_app_override_check_button; + + g_signal_handlers_block_by_func + (G_OBJECT(button), G_CALLBACK(fsaa_setting_checkbox_toggled), + (gpointer) ctk_multisample); - g_signal_handlers_unblock_by_func(G_OBJECT(check_button), - G_CALLBACK(fsaa_app_override_toggled), - (gpointer) ctk_multisample); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), override); + + g_signal_handlers_unblock_by_func + (G_OBJECT(button), G_CALLBACK(fsaa_setting_checkbox_toggled), + (gpointer) ctk_multisample); + } -} /* fsaa_app_override_update_received() */ + post_fsaa_setting_changed(ctk_multisample, override, enhance); + + +} /* fsaa_setting_update_received() */ @@ -1093,9 +1312,22 @@ GtkTextBuffer *ctk_multisample_create_help(GtkTextTagTable *table, "environment variable overrides the value in " "nvidia-settings."); - ctk_help_term(b, &i, "Override Application Setting"); + ctk_help_term(b, &i, "Application Antialiasing Settings"); - ctk_help_para(b, &i, __aa_override_app_help); + if (ctk_multisample->active_attributes & __FSAA_ENHANCE) { + ctk_help_para(b, &i, __aa_menu_help); + ctk_help_para(b, &i, "Use Application Settings will let applications " + "choose the AA mode."); + ctk_help_para(b, &i, "Override Application Settings will override " + "all OpenGL applications to use the mode selected by " + "the slider."); + ctk_help_para(b, &i, "Enhance Application Settings will make " + "applications that are requesting some type of " + "antialiasing to use the mode selected by the " + "slider ."); + } else { + ctk_help_para(b, &i, __aa_override_app_help); + } if (ctk_multisample->active_attributes & __FSAA_NONE) { ctk_help_term(b, &i, "Off"); diff --git a/src/gtk+-2.x/ctkmultisample.h b/src/gtk+-2.x/ctkmultisample.h index 069f1a9..4d20f40 100644 --- a/src/gtk+-2.x/ctkmultisample.h +++ b/src/gtk+-2.x/ctkmultisample.h @@ -60,6 +60,7 @@ struct _CtkMultisample CtkConfig *ctk_config; GtkWidget *fsaa_app_override_check_button; + GtkWidget *fsaa_menu; GtkWidget *fsaa_scale; GtkWidget *log_aniso_app_override_check_button; GtkWidget *log_aniso_scale; diff --git a/src/gtk+-2.x/ctkopengl.c b/src/gtk+-2.x/ctkopengl.c index 0db2aed..2d9471e 100644 --- a/src/gtk+-2.x/ctkopengl.c +++ b/src/gtk+-2.x/ctkopengl.c @@ -34,6 +34,20 @@ static void vblank_sync_button_toggled (GtkWidget *, gpointer); +static void post_vblank_sync_button_toggled(CtkOpenGL *, gboolean); + +static void post_allow_flipping_button_toggled(CtkOpenGL *, gboolean); + +static void post_force_stereo_button_toggled(CtkOpenGL *, gboolean); + +static void post_show_sli_hud_button_toggled(CtkOpenGL *, gboolean); + +static void post_xinerama_stereo_button_toggled(CtkOpenGL *, gboolean); + +static void post_force_generic_cpu_toggled(CtkOpenGL *, gboolean); + +static void post_aa_line_gamma_toggled(CtkOpenGL *, gboolean); + static void allow_flipping_button_toggled(GtkWidget *, gpointer); static void force_stereo_button_toggled (GtkWidget *, gpointer); @@ -279,10 +293,10 @@ GtkWidget* ctk_opengl_new(NvCtrlAttributeHandle *handle, g_signal_connect(G_OBJECT(ctk_event), CTK_EVENT_NAME(NV_CTRL_SYNC_TO_VBLANK), G_CALLBACK(value_changed), (gpointer) ctk_opengl); - + ctk_config_set_tooltip(ctk_config, check_button, __sync_to_vblank_help); - + ctk_opengl->active_attributes |= __SYNC_TO_VBLANK; ctk_opengl->sync_to_vblank_button = check_button; @@ -366,7 +380,7 @@ GtkWidget* ctk_opengl_new(NvCtrlAttributeHandle *handle, (gpointer) ctk_opengl); g_signal_connect(G_OBJECT(ctk_event), - CTK_EVENT_NAME(NV_CTRL_FORCE_STEREO), + CTK_EVENT_NAME(NV_CTRL_XINERAMA_STEREO), G_CALLBACK(value_changed), (gpointer) ctk_opengl); ctk_config_set_tooltip(ctk_config, check_button, __xinerama_stereo_help); @@ -534,6 +548,73 @@ GtkWidget* ctk_opengl_new(NvCtrlAttributeHandle *handle, return GTK_WIDGET(object); } +/* + * Prints status bar message + */ +static void post_vblank_sync_button_toggled(CtkOpenGL *ctk_opengl, + gboolean enabled) +{ + ctk_config_statusbar_message(ctk_opengl->ctk_config, + "OpenGL Sync to VBlank %s.", + enabled ? "enabled" : "disabled"); +} + +static void post_allow_flipping_button_toggled(CtkOpenGL *ctk_opengl, + gboolean enabled) +{ + ctk_config_statusbar_message(ctk_opengl->ctk_config, + "OpenGL Flipping %s.", + enabled ? "allowed" : "not allowed"); +} + +static void post_force_stereo_button_toggled(CtkOpenGL *ctk_opengl, + gboolean enabled) +{ + ctk_config_statusbar_message(ctk_opengl->ctk_config, + "OpenGL Stereo Flipping %s.", + enabled ? "forced" : "not forced"); +} + +static void post_show_sli_hud_button_toggled(CtkOpenGL *ctk_opengl, + gboolean enabled) +{ + ctk_config_statusbar_message(ctk_opengl->ctk_config, + "OpenGL SLI HUD %s.", + enabled ? "enabled" : "disabled"); +} + +static void post_xinerama_stereo_button_toggled(CtkOpenGL *ctk_opengl, + gboolean enabled) +{ + ctk_config_statusbar_message(ctk_opengl->ctk_config, + "OpenGL Xinerama Stereo Flipping %s.", + enabled ? "allowed" : "not allowed"); +} + +static void post_force_generic_cpu_toggled(CtkOpenGL *ctk_opengl, + gboolean enabled) +{ + /* + * XXX the logic is awkward, but correct: when + * NV_CTRL_FORCE_GENERIC_CPU is enabled, use of enhanced CPU + * instructions is disabled, and vice versa. + */ + + ctk_config_statusbar_message(ctk_opengl->ctk_config, + "OpenGL use of enhanced CPU instructions %s.", + enabled ? "disabled" : "enabled"); +} + +static void post_aa_line_gamma_toggled(CtkOpenGL *ctk_opengl, + gboolean enabled) +{ + ctk_config_statusbar_message(ctk_opengl->ctk_config, + "OpenGL gamma correction for antialiased " + "lines %s.", + enabled ? "enabled" : "disabled"); +} + + static void vblank_sync_button_toggled( GtkWidget *widget, gpointer user_data @@ -548,9 +629,7 @@ static void vblank_sync_button_toggled( NvCtrlSetAttribute(ctk_opengl->handle, NV_CTRL_SYNC_TO_VBLANK, enabled); - ctk_config_statusbar_message(ctk_opengl->ctk_config, - "OpenGL Sync to VBlank %s.", - enabled ? "enabled" : "disabled"); + post_vblank_sync_button_toggled(ctk_opengl, enabled); } @@ -563,12 +642,9 @@ static void allow_flipping_button_toggled(GtkWidget *widget, ctk_opengl = CTK_OPENGL(user_data); enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); - - NvCtrlSetAttribute(ctk_opengl->handle, NV_CTRL_FLIPPING_ALLOWED, enabled); - ctk_config_statusbar_message(ctk_opengl->ctk_config, - "OpenGL Flipping %s.", - enabled ? "allowed" : "prohibited"); + NvCtrlSetAttribute(ctk_opengl->handle, NV_CTRL_FLIPPING_ALLOWED, enabled); + post_allow_flipping_button_toggled(ctk_opengl, enabled); } @@ -583,10 +659,7 @@ static void force_stereo_button_toggled(GtkWidget *widget, enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); NvCtrlSetAttribute(ctk_opengl->handle, NV_CTRL_FORCE_STEREO, enabled); - - ctk_config_statusbar_message(ctk_opengl->ctk_config, - "OpenGL Stereo Flipping %s.", - enabled ? "forced" : "not forced"); + post_force_stereo_button_toggled(ctk_opengl, enabled); } static void show_sli_hud_button_toggled(GtkWidget *widget, @@ -600,10 +673,7 @@ static void show_sli_hud_button_toggled(GtkWidget *widget, enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); NvCtrlSetAttribute(ctk_opengl->handle, NV_CTRL_SHOW_SLI_HUD, enabled); - - ctk_config_statusbar_message(ctk_opengl->ctk_config, - "OpenGL SLI HUD %s.", - enabled ? "enabled" : "disabled"); + post_show_sli_hud_button_toggled(ctk_opengl, enabled); } static void xinerama_stereo_button_toggled(GtkWidget *widget, @@ -617,10 +687,7 @@ static void xinerama_stereo_button_toggled(GtkWidget *widget, enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); NvCtrlSetAttribute(ctk_opengl->handle, NV_CTRL_XINERAMA_STEREO, enabled); - - ctk_config_statusbar_message(ctk_opengl->ctk_config, - "OpenGL Xinerama Stereo Flipping %s.", - enabled ? "allowed" : "not allowed"); + post_xinerama_stereo_button_toggled(ctk_opengl, enabled); } static void force_generic_cpu_toggled( @@ -640,16 +707,12 @@ static void force_generic_cpu_toggled( NV_CTRL_FORCE_GENERIC_CPU, enabled); if (ret != NvCtrlSuccess) return; - + post_force_generic_cpu_toggled(ctk_opengl, enabled); /* * XXX the logic is awkward, but correct: when * NV_CTRL_FORCE_GENERIC_CPU is enabled, use of enhanced CPU * instructions is disabled, and vice versa. */ - - ctk_config_statusbar_message(ctk_opengl->ctk_config, - "OpenGL use of enhanced CPU instructions %s.", - enabled ? "disabled" : "enabled"); } static void aa_line_gamma_toggled( @@ -669,11 +732,7 @@ static void aa_line_gamma_toggled( NV_CTRL_OPENGL_AA_LINE_GAMMA, enabled); if (ret != NvCtrlSuccess) return; - - ctk_config_statusbar_message(ctk_opengl->ctk_config, - "OpenGL gamma correction for antialiased " - "lines %s.", - enabled ? "enabled" : "disabled"); + post_aa_line_gamma_toggled(ctk_opengl, enabled); } @@ -697,30 +756,37 @@ static void value_changed(GtkObject *object, gpointer arg1, gpointer user_data) case NV_CTRL_SYNC_TO_VBLANK: button = GTK_TOGGLE_BUTTON(ctk_opengl->sync_to_vblank_button); func = G_CALLBACK(vblank_sync_button_toggled); + post_vblank_sync_button_toggled(ctk_opengl, event_struct->value); break; case NV_CTRL_FLIPPING_ALLOWED: button = GTK_TOGGLE_BUTTON(ctk_opengl->allow_flipping_button); func = G_CALLBACK(allow_flipping_button_toggled); + post_allow_flipping_button_toggled(ctk_opengl, event_struct->value); break; case NV_CTRL_FORCE_STEREO: button = GTK_TOGGLE_BUTTON(ctk_opengl->force_stereo_button); func = G_CALLBACK(force_stereo_button_toggled); + post_force_stereo_button_toggled(ctk_opengl, event_struct->value); break; case NV_CTRL_XINERAMA_STEREO: button = GTK_TOGGLE_BUTTON(ctk_opengl->xinerama_stereo_button); func = G_CALLBACK(xinerama_stereo_button_toggled); + post_xinerama_stereo_button_toggled(ctk_opengl, event_struct->value); break; case NV_CTRL_OPENGL_AA_LINE_GAMMA: button = GTK_TOGGLE_BUTTON(ctk_opengl->aa_line_gamma_button); func = G_CALLBACK(aa_line_gamma_toggled); + post_aa_line_gamma_toggled(ctk_opengl, event_struct->value); break; case NV_CTRL_FORCE_GENERIC_CPU: button = GTK_TOGGLE_BUTTON(ctk_opengl->force_generic_cpu_button); func = G_CALLBACK(force_generic_cpu_toggled); + post_force_generic_cpu_toggled(ctk_opengl, event_struct->value); break; case NV_CTRL_SHOW_SLI_HUD: button = GTK_TOGGLE_BUTTON(ctk_opengl->show_sli_hud_button); func = G_CALLBACK(show_sli_hud_button_toggled); + post_show_sli_hud_button_toggled(ctk_opengl, event_struct->value); break; default: return; diff --git a/src/libXNVCtrl/NVCtrl.h b/src/libXNVCtrl/NVCtrl.h index 83de2f0..c27c2a8 100644 --- a/src/libXNVCtrl/NVCtrl.h +++ b/src/libXNVCtrl/NVCtrl.h @@ -230,7 +230,10 @@ #define NV_CTRL_FSAA_MODE_8x 7 #define NV_CTRL_FSAA_MODE_16x 8 #define NV_CTRL_FSAA_MODE_8xS 9 -#define NV_CTRL_FSAA_MODE_MAX NV_CTRL_FSAA_MODE_8xS +#define NV_CTRL_FSAA_MODE_8xQ 10 +#define NV_CTRL_FSAA_MODE_16xS 11 +#define NV_CTRL_FSAA_MODE_16xQ 12 +#define NV_CTRL_FSAA_MODE_MAX NV_CTRL_FSAA_MODE_16xQ /* @@ -620,6 +623,9 @@ * NV_CTRL_FLIPPING_ALLOWED - when TRUE, OpenGL will swap by flipping * when possible; when FALSE, OpenGL will alway swap by blitting. XXX * can this be enabled dynamically? + * + * This attribute will not be available when flipping is not possible, such + * as when the NoFlip X config file option is enabled. */ #define NV_CTRL_FLIPPING_ALLOWED 40 /* RW-X */ @@ -2805,7 +2811,6 @@ #define NV_CTRL_FRAMELOCK_FPGA_REVISION 242 /* R--F */ - /* * NV_CTRL_MAX_SCREEN_{WIDTH,HEIGHT} - the maximum allowable size, in * pixels, of either the specified X screen (if the target_type of the @@ -2960,7 +2965,24 @@ #define NV_CTRL_DFP_SCALING_ACTIVE 254 /* R-DG */ -#define NV_CTRL_LAST_ATTRIBUTE NV_CTRL_DFP_SCALING_ACTIVE +/* + * NV_CTRL_FSAA_APPLICATION_ENHANCED - Controls how the NV_CTRL_FSAA_MODE + * is applied when NV_CTRL_FSAA_APPLICATION_CONTROLLED is set to + * NV_CTRL_APPLICATION_CONTROLLED_DISABLED. When + * NV_CTRL_FSAA_APPLICATION_ENHANCED is _DISABLED, OpenGL applications will + * be forced to use the FSAA mode specified by NV_CTRL_FSAA_MODE. when set + * to _ENABLED, only those applications that have selected a multisample + * FBConfig will be made to use the NV_CTRL_FSAA_MODE specified. + * + * This attribute is ignored when NV_CTRL_FSAA_APPLICATION_CONTROLLED is + * set to NV_CTRL_FSAA_APPLICATION_CONTROLLED_ENABLED. + */ + +#define NV_CTRL_FSAA_APPLICATION_ENHANCED 255 /* RW-X */ +#define NV_CTRL_FSAA_APPLICATION_ENHANCED_ENABLED 1 +#define NV_CTRL_FSAA_APPLICATION_ENHANCED_DISABLED 0 + +#define NV_CTRL_LAST_ATTRIBUTE NV_CTRL_FSAA_APPLICATION_ENHANCED /**************************************************************************/ diff --git a/src/libXNVCtrl/NVCtrlLib.h b/src/libXNVCtrl/NVCtrlLib.h index 75b07ad..6a6bc28 100644 --- a/src/libXNVCtrl/NVCtrlLib.h +++ b/src/libXNVCtrl/NVCtrlLib.h @@ -3,6 +3,10 @@ #include "NVCtrl.h" +#if defined __cplusplus +extern "C" { +#endif + /* * XNVCTRLQueryExtension - * @@ -769,5 +773,8 @@ typedef union { long pad[24]; } XNVCtrlEventTarget; +#if defined __cplusplus +} /* extern "C" */ +#endif #endif /* __NVCTRLLIB_H */ diff --git a/src/libXNVCtrl/libXNVCtrl.a b/src/libXNVCtrl/libXNVCtrl.a index 61f8c6e..9596949 100644 Binary files a/src/libXNVCtrl/libXNVCtrl.a and b/src/libXNVCtrl/libXNVCtrl.a differ diff --git a/src/parse.c b/src/parse.c index e220539..92358ec 100644 --- a/src/parse.c +++ b/src/parse.c @@ -112,8 +112,9 @@ AttributeTableEntry attributeTable[] = { { "BackendResolution", NV_CTRL_BACKEND_RESOLUTION, N|P }, { "FlatpanelNativeResolution", NV_CTRL_FLATPANEL_NATIVE_RESOLUTION, N|P }, { "FlatpanelBestFitResolution", NV_CTRL_FLATPANEL_BEST_FIT_RESOLUTION, N|P }, - { "GPUScalingActive", NV_CTRL_GPU_SCALING_ACTIVE, N }, - { "DFPScalingActive", NV_CTRL_DFP_SCALING_ACTIVE, N }, + { "GPUScalingActive", NV_CTRL_GPU_SCALING_ACTIVE, N }, + { "DFPScalingActive", NV_CTRL_DFP_SCALING_ACTIVE, N }, + { "FSAAAppEnhanced", NV_CTRL_FSAA_APPLICATION_ENHANCED, 0 }, { "FrameLockMaster", NV_CTRL_FRAMELOCK_MASTER, N|F|G|D }, { "FrameLockSlaves", NV_CTRL_FRAMELOCK_SLAVES, N|F|G|D }, @@ -194,7 +195,7 @@ AttributeTableEntry attributeTable[] = { * about. */ -#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_DFP_SCALING_ACTIVE +#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_FSAA_APPLICATION_ENHANCED #warning "Have you forgotten to add a new integer attribute to attributeTable?" #endif -- cgit v1.2.3