1.0-97461.0-9746

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
--- a/src/libXNVCtrl/libXNVCtrl.a
+++ b/src/libXNVCtrl/libXNVCtrl.a
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