295.17295.17

19 files changed, 574 insertions, 506 deletions

diff --git a/src/gtk+-2.x/ctkcolorcontrols.c b/src/gtk+-2.x/ctkcolorcontrols.c
index afbd30a..b5d7fad 100644
--- a/src/gtk+-2.x/ctkcolorcontrols.c
+++ b/src/gtk+-2.x/ctkcolorcontrols.c
@@ -65,10 +65,15 @@ void post_color_space_update(CtkColorControls *ctk_color_controls,
 /* help text */
 static const char * __color_controls_help =
 "The Color Controls allow changing the color space and color range "
-"of the display device.  The possible values for Color Space vary "
-"depending on the capabilities of the display device and the GPU, but "
-"may contain \"RGB\", \"YCbCr422\", and \"YCbCr444\".  The possible values "
-"for Color Range are \"Limited\" and \"Full\".";
+"of the display device.";
+
+static const char * __color_space_help =
+"The possible values for Color Space vary depending on the capabilities of "
+"the display device and the GPU, but may contain \"RGB\", \"YCbCr422\", "
+"and \"YCbCr444\".";  
+
+static const char * __color_range_help =
+"The possible values for Color Range are \"Limited\" and \"Full\".";
 
 GType ctk_color_controls_get_type(void)
 {
@@ -105,7 +110,7 @@ GtkWidget* ctk_color_controls_new(NvCtrlAttributeHandle *handle,
 {
     GObject *object;
     CtkColorControls *ctk_color_controls;
-    GtkWidget *frame, *hbox, *label, *eventbox;
+    GtkWidget *frame, *hbox, *label;
     GtkWidget *menu, *table, *menu_item = NULL, *separator;
     ReturnStatus ret1, ret2;
     NVCTRLAttributeValidValuesRec valid1, valid2;
@@ -148,10 +153,7 @@ GtkWidget* ctk_color_controls_new(NvCtrlAttributeHandle *handle,
     ctk_color_controls->color_controls_main = hbox;
 
     frame = gtk_frame_new("Color Controls");
-    eventbox = gtk_event_box_new();
-    gtk_container_add(GTK_CONTAINER(eventbox), frame);
-    gtk_box_pack_start(GTK_BOX(hbox), eventbox, FALSE, FALSE, 0);
-    ctk_config_set_tooltip(ctk_config, eventbox, __color_controls_help);
+    gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0);
 
     table = gtk_table_new(1, 6, FALSE);
     gtk_container_add(GTK_CONTAINER(frame), table);
@@ -183,6 +185,9 @@ GtkWidget* ctk_color_controls_new(NvCtrlAttributeHandle *handle,
     gtk_option_menu_set_menu
         (GTK_OPTION_MENU(ctk_color_controls->color_space_menu),
          menu);
+    ctk_config_set_tooltip(ctk_config, 
+                           ctk_color_controls->color_space_menu,
+                           __color_space_help);
 
     /* If dropdown only has one item, disable it */
     if (ctk_color_controls->color_space_table_size > 1) {
@@ -223,6 +228,9 @@ GtkWidget* ctk_color_controls_new(NvCtrlAttributeHandle *handle,
     /* dropdown list for color range */
 
     ctk_color_controls->color_range_menu = gtk_option_menu_new();
+    ctk_config_set_tooltip(ctk_config, 
+                           ctk_color_controls->color_range_menu,
+                           __color_range_help);
 
     g_signal_connect(G_OBJECT(ctk_color_controls->color_range_menu),
                      "changed", G_CALLBACK(color_range_menu_changed),
@@ -459,6 +467,12 @@ void add_color_controls_help(CtkColorControls *ctk_color_controls,
 {
     ctk_help_heading(b, i, "Color Controls");
     ctk_help_para(b, i, __color_controls_help);
+
+    ctk_help_term(b, i, "Color Space");
+    ctk_help_para(b, i, __color_space_help);
+
+    ctk_help_term(b, i, "Color Range");
+    ctk_help_para(b, i, __color_range_help);
 } /* add_color_controls_help() */
 
 
diff --git a/src/gtk+-2.x/ctkdisplayconfig-utils.c b/src/gtk+-2.x/ctkdisplayconfig-utils.c
index c8b41b3..526c120 100644
--- a/src/gtk+-2.x/ctkdisplayconfig-utils.c
+++ b/src/gtk+-2.x/ctkdisplayconfig-utils.c
@@ -1627,11 +1627,9 @@ static Bool screen_add_metamodes(nvScreenPtr screen, gchar **err_str)
     metamode_strs = NULL;
 
     if (!screen->metamodes) {
-        *err_str = g_strdup_printf("Failed to add any metamode to screen %d "
-                                   "(on GPU-%d).",
-                                   screen->scrnum,
-                                   NvCtrlGetTargetId(screen->gpu->handle));
-        nv_error_msg(*err_str);
+        nv_warning_msg("Failed to add any metamode to screen %d (on GPU-%d).",
+                       screen->scrnum,
+                       NvCtrlGetTargetId(screen->gpu->handle));
         goto fail;
     }
 
@@ -2427,6 +2425,59 @@ static void layout_remove_screens(nvLayoutPtr layout)
 
 
 
+/** link_screen_to_gpu() *********************************************
+ *
+ * Finds the GPU driving the screen and links the two.
+ *
+ **/
+
+static Bool link_screen_to_gpu(nvLayoutPtr layout, nvScreenPtr screen)
+{
+    int val;
+    ReturnStatus ret;
+    nvGpuPtr gpu;
+
+    /* Link the screen to the display owner GPU.  If there is no display owner,
+     * which is the case when SLI Mosaic Mode is configured, link screen
+     * to the first GPU we find.
+     */
+    ret = NvCtrlGetAttribute(screen->handle, NV_CTRL_MULTIGPU_DISPLAY_OWNER,
+                             &val);
+    if (ret != NvCtrlSuccess) {
+        int *pData = NULL;
+        int len;
+
+        ret = NvCtrlGetBinaryAttribute(screen->handle,
+                                       0,
+                                       NV_CTRL_BINARY_DATA_GPUS_USED_BY_XSCREEN,
+                                       (unsigned char **)(&pData),
+                                       &len);
+        if (ret != NvCtrlSuccess || !pData) {
+            return FALSE;
+        }
+        if (pData[0] < 1) {
+            XFree(pData);
+            return FALSE;
+        }
+
+        /* Pick the first GPU */
+        val = pData[1];
+        XFree(pData);
+    }
+
+    for (gpu = layout->gpus; gpu; gpu = gpu->next_in_layout) {
+        if (val == NvCtrlGetTargetId(gpu->handle)) {
+            screen->gpu = gpu;
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+
+} /* link_screen_to_gpu() */
+
+
+
 /** layout_add_screen_from_server() **********************************
  *
  * Adds an X screen to the layout structure.
@@ -2441,7 +2492,6 @@ static Bool layout_add_screen_from_server(nvLayoutPtr layout,
     int val, tmp;
     ReturnStatus ret;
     gchar *primary_str = NULL;
-    nvGpuPtr gpu;
 
 
     screen = (nvScreenPtr)calloc(1, sizeof(nvScreen));
@@ -2505,21 +2555,8 @@ static Bool layout_add_screen_from_server(nvLayoutPtr layout,
         goto fail;
     }
 
-
-    /* The display owner GPU gets the screen(s) */
-    ret = NvCtrlGetAttribute(screen->handle, NV_CTRL_MULTIGPU_DISPLAY_OWNER,
-                             &val);
-    if (ret != NvCtrlSuccess) {
-        screen_free(screen);
-        return TRUE;
-    }
-
-    for (gpu = layout->gpus; gpu; gpu = gpu->next_in_layout) {
-        if (val == NvCtrlGetTargetId(gpu->handle)) {
-            screen->gpu = gpu;
-        }
-    }
-    if (!screen->gpu) {
+    /* Link screen to the GPU driving it */
+    if (!link_screen_to_gpu(layout, screen)) {
         *err_str = g_strdup_printf("Failed to find GPU that drives screen %d.",
                                    screen_id);
         nv_warning_msg(*err_str);
@@ -2624,7 +2661,7 @@ static int layout_add_screens_from_server(nvLayoutPtr layout, gchar **err_str)
         }
     }
 
-    return layout->num_screens;
+    return nscreens;
 
 
  fail:
diff --git a/src/gtk+-2.x/ctkdisplayconfig.c b/src/gtk+-2.x/ctkdisplayconfig.c
index 73b85cc..4f399a2 100644
--- a/src/gtk+-2.x/ctkdisplayconfig.c
+++ b/src/gtk+-2.x/ctkdisplayconfig.c
@@ -3890,7 +3890,7 @@ static gchar * validate_screen(nvScreenPtr screen)
         /* There must be at least one display active in the metamode. */
         if (!num_displays) {
             tmp = g_strdup_printf("%s MetaMode %d of Screen %d  does not have "
-                                  "an active display devices.\n\n",
+                                  "an active display device.\n\n",
                                   bullet, i+1, screen->scrnum);
             tmp2 = g_strconcat((err_str ? err_str : ""), tmp, NULL);
             g_free(err_str);
@@ -3910,7 +3910,7 @@ static gchar * validate_screen(nvScreenPtr screen)
             g_free(tmp);
             err_str = tmp2;
         }
-        
+
 
         /* Verify that the metamode is unique */
         metamode_str = screen_get_metamode_str(screen, i, 0);
@@ -4861,17 +4861,24 @@ void do_disable_display(CtkDisplayConfig *ctk_object, nvDisplayPtr display)
     gtk_label_set_text
         (GTK_LABEL(ctk_object->txt_display_disable), str);
     g_free(str);
-        
+
     gtk_button_set_label(GTK_BUTTON(ctk_object->btn_display_disable_off),
                          "Disable");
     gtk_button_set_label(GTK_BUTTON(ctk_object->btn_display_disable_cancel),
                          "Cancel");
 
-     
     /* Confirm with user before disabling */
     if (do_query_remove_display(ctk_object, display)) {
+        gboolean screen_disabled =
+            (display->screen->num_displays == 1) ? TRUE : FALSE;
         ctk_display_layout_disable_display(CTK_DISPLAY_LAYOUT(ctk_object->obj_layout),
                                            display);
+        /* If the display was the last one on the X screen, make note that we
+         * can't actually remove the X screen without a restart.
+         */
+        if (screen_disabled) {
+            ctk_object->apply_possible = FALSE;
+        }
     }
 
 } /* do_disable_display() */
@@ -4980,9 +4987,9 @@ static void display_config_changed(GtkWidget *widget, gpointer user_data)
             validation_auto_fix_screen(ctk_object, screen);
         }
 
-        /* Redraw */
-        ctk_display_layout_redraw(CTK_DISPLAY_LAYOUT(ctk_object->obj_layout));
-        
+        /* Final update */
+        ctk_display_layout_update(CTK_DISPLAY_LAYOUT(ctk_object->obj_layout));
+
         /* Update GUI */
         setup_layout_frame(ctk_object);
         setup_display_page(ctk_object);
@@ -5135,7 +5142,6 @@ static void display_modelname_changed(GtkWidget *widget, gpointer user_data)
     display = ctk_object->display_model_table[idx];
     ctk_display_layout_select_display
         (CTK_DISPLAY_LAYOUT(ctk_object->obj_layout), display);
-    ctk_display_layout_redraw(CTK_DISPLAY_LAYOUT(ctk_object->obj_layout));
 
     /* Reconfigure GUI to display information about the selected display. */
     setup_display_page(ctk_object);
@@ -6426,8 +6432,10 @@ static void apply_clicked(GtkWidget *widget, gpointer user_data)
         }
     }
 
-    /* Clear the apply button if all went well */
-    if (clear_apply) {
+    /* Clear the apply button if all went well, and we were able to apply
+     * eveything.
+     */
+    if (ctk_object->apply_possible && clear_apply) {
         gtk_widget_set_sensitive(widget, False);
         ctk_object->forced_reset_allowed = TRUE;
     }
diff --git a/src/gtk+-2.x/ctkdisplaydevice-crt.c b/src/gtk+-2.x/ctkdisplaydevice-crt.c
index 7d2676f..ad55b39 100644
--- a/src/gtk+-2.x/ctkdisplaydevice-crt.c
+++ b/src/gtk+-2.x/ctkdisplaydevice-crt.c
@@ -141,7 +141,7 @@ GtkWidget* ctk_display_device_crt_new(NvCtrlAttributeHandle *handle,
      */
 
     ctk_display_device_crt->reset_button =
-        gtk_button_new_with_label("Reset Hardware Defaults");
+        gtk_button_new_with_label("Reset CRT Hardware Defaults");
 
     alignment = gtk_alignment_new(1, 1, 0, 0);
     gtk_container_add(GTK_CONTAINER(alignment),
@@ -153,8 +153,7 @@ GtkWidget* ctk_display_device_crt_new(NvCtrlAttributeHandle *handle,
                      (gpointer) ctk_display_device_crt);
 
     ctk_config_set_tooltip(ctk_config, ctk_display_device_crt->reset_button,
-                           "The Reset Hardware Defaults button restores "
-                           "the CRT settings to their default values.");
+                           ctk_help_create_reset_hardware_defaults_text("CRT", name));
     
     /* pack the image sliders */
     
@@ -249,6 +248,7 @@ GtkTextBuffer *ctk_display_device_crt_create_help(GtkTextTagTable *table,
 {
     GtkTextIter i;
     GtkTextBuffer *b;
+    GtkTooltipsData *td;
 
     b = gtk_text_buffer_new(table);
     
@@ -266,7 +266,8 @@ GtkTextBuffer *ctk_display_device_crt_create_help(GtkTextTagTable *table,
         add_acquire_edid_help(b, &i);
     }
     
-    ctk_help_reset_hardware_defaults(b, &i, ctk_display_device_crt->name);
+    td = gtk_tooltips_data_get(GTK_WIDGET(ctk_display_device_crt->reset_button));
+    ctk_help_reset_hardware_defaults (b, &i, td->tip_text);
 
     ctk_help_finish(b);
 
diff --git a/src/gtk+-2.x/ctkdisplaydevice-dfp.c b/src/gtk+-2.x/ctkdisplaydevice-dfp.c
index a61ba9d..ddf559f 100644
--- a/src/gtk+-2.x/ctkdisplaydevice-dfp.c
+++ b/src/gtk+-2.x/ctkdisplaydevice-dfp.c
@@ -91,6 +91,19 @@ static const char *__info_help =
 "This section describes basic informations about the "
 "DVI connection to the digital flat panel.";
 
+static const char *__info_chip_location_help = 
+"Report whether the flat panel is driven by the on-chip controller "
+"(internal), or a separate controller chip elsewhere on the graphics "
+"board (external).";
+                      
+static const char *__info_link_help = 
+"Report whether the specified display device is driven by a single "
+"link or dual link DVI connection.";
+    
+static const char *__info_signal_help = 
+"Report whether the flat panel is driven by an LVDS, TMDS, or "
+"DisplayPort signal.";
+
 static const char * __native_res_help =
 "The Native Resolution is the width and height in pixels that the flat "
 "panel uses to display the image.  All other resolutions must be scaled "
@@ -127,6 +140,22 @@ static const char * __force_gpu_scaling_help =
 "panel's EDID; the flat panel will then scale the image to "
 "its native resolution.";
 
+static const char *__gpu_scaling_help = 
+"Reports whether the GPU and/or DFP are actively scaling the current "
+"resolution.";
+
+static const char *__gpu_scaling_stretched_help = 
+"The image will be expanded to fit the entire flat panel.";
+
+static const char *__gpu_scaling_centered_help = 
+"The image will only occupy the number of pixels "
+"needed and be centered on the flat panel.  Setting this "
+"will disable image sharpening for the display device.";
+
+static const char *__gpu_scaling_ar_scaled_help = 
+"The image will be scaled (retaining the original "
+"aspect ratio) to expand and fit as much of the entire "
+"flat panel as possible.";
 
 GType ctk_display_device_dfp_get_type(void)
 {
@@ -192,13 +221,15 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
     GtkWidget *banner;
     GtkWidget *frame;
     GtkWidget *hbox, *vbox, *tmpbox;
-    GtkWidget *eventbox;
 
     GtkWidget *button;
     GtkWidget *radio0;
     GtkWidget *radio1;
     GtkWidget *radio2;
     GtkWidget *alignment;
+    GtkWidget *notebook;
+    GtkWidget *nbox;
+    GtkWidget *align;
     
     GtkWidget *table;
     ReturnStatus ret1, ret2;
@@ -250,7 +281,7 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
      */
 
     ctk_display_device_dfp->reset_button =
-        gtk_button_new_with_label("Reset Hardware Defaults");
+        gtk_button_new_with_label("Reset DFP Hardware Defaults");
 
     alignment = gtk_alignment_new(1, 1, 0, 0);
     gtk_container_add(GTK_CONTAINER(alignment),
@@ -262,13 +293,26 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
                      (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.");
+                           ctk_help_create_reset_hardware_defaults_text("DFP", name));
+
+    /* Create tabbed notebook for widget */
+
+    notebook = gtk_notebook_new();
+    gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
+    align = gtk_alignment_new(0, 0, 1, 1);
+    gtk_container_add(GTK_CONTAINER(align), notebook);
+    gtk_box_pack_start(GTK_BOX(object), align, FALSE, FALSE, 0);
+
+    /* Create first tab for dfp 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"));
 
     /* 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);
+    gtk_box_pack_start(GTK_BOX(nbox), hbox, FALSE, FALSE, FRAME_PADDING);
 
     /* DFP info */
 
@@ -282,6 +326,7 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
      */
     
     tmpbox = gtk_vbox_new(FALSE, 5);
+    gtk_container_set_border_width(GTK_CONTAINER(tmpbox), FRAME_PADDING);
     gtk_container_add(GTK_CONTAINER(frame), tmpbox);
     
     /* Make the txt widgets that will get updated */
@@ -306,17 +351,17 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
             {
                 gtk_label_new("Chip location:"),
                 ctk_display_device_dfp->txt_chip_location,
-                NULL
+                __info_chip_location_help
             },
             {
                 gtk_label_new("Connection link:"),
                 ctk_display_device_dfp->txt_link,
-                NULL
+                __info_link_help
             },
             {
                 gtk_label_new("Signal:"),
                 ctk_display_device_dfp->txt_signal,
-                NULL
+                __info_signal_help
             },
             {
                 gtk_label_new("Native Resolution:"),
@@ -384,14 +429,15 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
                                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);
+            if (lines[i].tooltip) {
+                ctk_config_set_tooltip(ctk_config, 
+                                       lines[i].label, 
+                                       lines[i].tooltip);
+                ctk_config_set_tooltip(ctk_config, 
+                                       lines[i].txt, 
+                                       lines[i].tooltip);
             }
+            gtk_box_pack_start(GTK_BOX(tmpbox), tmphbox, FALSE, FALSE, 0);
         }
     }
 
@@ -399,13 +445,9 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
     /* 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;
+    gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0);
+    ctk_display_device_dfp->scaling_frame = frame;
     
-    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);
@@ -423,9 +465,10 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
     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,  "");
+        add_table_row_with_help_text(table, ctk_config, __gpu_scaling_help,
+                                     0, 0, 
+                                     0, 0.5, "Scaling:",
+                                     0, 0.5,  "");
 
     gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
 
@@ -442,29 +485,48 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
     radio0 = make_scaling_radio_button
         (ctk_display_device_dfp, vbox, NULL, "Stretched",
          NV_CTRL_GPU_SCALING_METHOD_STRETCHED);
+    ctk_config_set_tooltip(ctk_config, radio0, __gpu_scaling_stretched_help);
     
     radio1 = make_scaling_radio_button
         (ctk_display_device_dfp, vbox, radio0, "Centered",
          NV_CTRL_GPU_SCALING_METHOD_CENTERED);
+    ctk_config_set_tooltip(ctk_config, radio1, __gpu_scaling_centered_help);
     
     radio2 = make_scaling_radio_button
         (ctk_display_device_dfp, vbox, radio1, "Aspect Ratio Scaled",
          NV_CTRL_GPU_SCALING_METHOD_ASPECT_SCALED);
+    ctk_config_set_tooltip(ctk_config, radio2, __gpu_scaling_ar_scaled_help);
     
     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 EDID button */
+
+    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);
+    ctk_display_device_dfp->edid_box = hbox;
+
+    /* 
+     * Create layout for second tab for dfp controls but don't
+     * add the tab until we make sure its required 
+     */
+
+    nbox = gtk_vbox_new(FALSE, FRAME_PADDING);
+    gtk_container_set_border_width(GTK_CONTAINER(nbox), FRAME_PADDING);
+
     /* 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);
+                               ctk_display_device_dfp->reset_button,
+                               display_device_mask, name);
 
     if (ctk_display_device_dfp->color_controls) {
-        gtk_box_pack_start(GTK_BOX(object),
+        gtk_box_pack_start(GTK_BOX(nbox),
                            ctk_display_device_dfp->color_controls,
                            FALSE, FALSE, 0);
     }
@@ -477,7 +539,7 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
                                    display_device_mask, name);
 
     if (ctk_display_device_dfp->dithering_controls) {
-        gtk_box_pack_start(GTK_BOX(object),
+        gtk_box_pack_start(GTK_BOX(nbox),
                            ctk_display_device_dfp->dithering_controls,
                            FALSE, FALSE, 0);
     }
@@ -489,17 +551,19 @@ GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
                               ctk_display_device_dfp->reset_button,
                               display_device_mask, name);
     if (ctk_display_device_dfp->image_sliders) {
-        gtk_box_pack_start(GTK_BOX(object),
+        gtk_box_pack_start(GTK_BOX(nbox),
                            ctk_display_device_dfp->image_sliders,
                            FALSE, FALSE, 0);
     }
 
-    /* pack the EDID button */
+    /* If no controls are created, don't add a controls tab */
+
+    if (ctk_display_device_dfp->color_controls || 
+        ctk_display_device_dfp->dithering_controls || 
+        ctk_display_device_dfp->image_sliders) {
+            gtk_notebook_append_page(GTK_NOTEBOOK(notebook),nbox,gtk_label_new("Controls"));
+    }
 
-    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));
@@ -878,6 +942,7 @@ GtkTextBuffer *ctk_display_device_dfp_create_help(GtkTextTagTable *table,
 {
     GtkTextIter i;
     GtkTextBuffer *b;
+    GtkTooltipsData *td;
     
     b = gtk_text_buffer_new(table);
     
@@ -889,19 +954,13 @@ GtkTextBuffer *ctk_display_device_dfp_create_help(GtkTextTagTable *table,
     ctk_help_para(b, &i, __info_help);
         
     ctk_help_term(b, &i, "Chip Location");
-    ctk_help_para(b, &i, "Report whether the flat panel is driven by "
-                  "the on-chip controller (internal), or a "
-                  "separate controller chip elsewhere on the "
-                  "graphics board (external).");
+    ctk_help_para(b, &i, __info_chip_location_help);
                       
     ctk_help_term(b, &i, "Link");
-    ctk_help_para(b, &i, "Report whether the specified display device "
-                  "is driven by a single link or dual link DVI "
-                  "connection.");
+    ctk_help_para(b, &i, __info_link_help);
     
     ctk_help_term(b, &i, "Signal");
-    ctk_help_para(b, &i, "Report whether the flat panel is driven by "
-                  "an LVDS, TMDS, or DisplayPort signal.");
+    ctk_help_para(b, &i, __info_signal_help);
 
     ctk_help_term(b, &i, "Native Resolution");
     ctk_help_para(b, &i, __native_res_help);
@@ -925,22 +984,20 @@ GtkTextBuffer *ctk_display_device_dfp_create_help(GtkTextTagTable *table,
     ctk_help_para(b, &i, __force_gpu_scaling_help);
     
     ctk_help_term(b, &i, "Scaling");
-    ctk_help_para(b, &i, "Reports whether the GPU and/or DFP are actively "
-                  "scaling the current resolution.");
+    ctk_help_para(b, &i, __gpu_scaling_help);
     
     ctk_help_term(b, &i, "Stretched");
-    ctk_help_para(b, &i, "The image will be expanded to fit the entire "
-                  "flat panel.");
+    ctk_help_para(b, &i, __gpu_scaling_stretched_help);
     
     ctk_help_term(b, &i, "Centered");
-    ctk_help_para(b, &i, "The image will only occupy the number of pixels "
-                  "needed and be centered on the flat panel.  Setting this "
-                  "will disable image sharpening for the display device.");
+    ctk_help_para(b, &i, __gpu_scaling_centered_help);
     
     ctk_help_term(b, &i, "Aspect Ratio Scaled");
-    ctk_help_para(b, &i, "The image will be scaled (retaining the original "
-                  "aspect ratio) to expand and fit as much of the entire "
-                  "flat panel as possible.");
+    ctk_help_para(b, &i, __gpu_scaling_ar_scaled_help);
+
+    if (ctk_display_device_dfp->edid) {
+        add_acquire_edid_help(b, &i);
+    }
 
     if (ctk_display_device_dfp->color_controls) {
         add_color_controls_help
@@ -955,11 +1012,8 @@ GtkTextBuffer *ctk_display_device_dfp_create_help(GtkTextTagTable *table,
     add_image_sliders_help
         (CTK_IMAGE_SLIDERS(ctk_display_device_dfp->image_sliders), b, &i);
     
-    if (ctk_display_device_dfp->edid) {
-        add_acquire_edid_help(b, &i);
-    }
-
-    ctk_help_reset_hardware_defaults(b, &i, ctk_display_device_dfp->name);
+    td = gtk_tooltips_data_get(GTK_WIDGET(ctk_display_device_dfp->reset_button));
+    ctk_help_reset_hardware_defaults (b, &i, td->tip_text);
 
     ctk_help_finish(b);
     
diff --git a/src/gtk+-2.x/ctkdisplaydevice-tv.c b/src/gtk+-2.x/ctkdisplaydevice-tv.c
index eb7cc9e..febfdfe 100644
--- a/src/gtk+-2.x/ctkdisplaydevice-tv.c
+++ b/src/gtk+-2.x/ctkdisplaydevice-tv.c
@@ -369,8 +369,7 @@ GtkWidget* ctk_display_device_tv_new(NvCtrlAttributeHandle *handle,
                      (gpointer) ctk_display_device_tv);
     
     ctk_config_set_tooltip(ctk_config, ctk_display_device_tv->reset_button,
-                           "The Reset TV Hardware Defaults button restores "
-                           "the TV settings to their default values.");
+                           ctk_help_create_reset_hardware_defaults_text("TV", name));
 
     /* EDID button box */
 
@@ -699,6 +698,7 @@ GtkTextBuffer *ctk_display_device_tv_create_help(GtkTextTagTable *table,
 {
     GtkTextIter i;
     GtkTextBuffer *b;
+    GtkTooltipsData *td;
 
     b = gtk_text_buffer_new(table);
     
@@ -737,7 +737,8 @@ GtkTextBuffer *ctk_display_device_tv_create_help(GtkTextTagTable *table,
         add_acquire_edid_help(b, &i);
     }
     
-    ctk_help_reset_hardware_defaults(b, &i, ctk_display_device_tv->name);
+    td = gtk_tooltips_data_get(GTK_WIDGET(ctk_display_device_tv->reset_button));
+    ctk_help_reset_hardware_defaults (b, &i, td->tip_text);
 
     ctk_help_finish(b);
 
diff --git a/src/gtk+-2.x/ctkdisplaylayout.c b/src/gtk+-2.x/ctkdisplaylayout.c
index 8a451e2..f5318ec 100644
--- a/src/gtk+-2.x/ctkdisplaylayout.c
+++ b/src/gtk+-2.x/ctkdisplaylayout.c
@@ -151,6 +151,36 @@ static void calc_metamode(nvScreenPtr screen, nvMetaModePtr metamode);
 /*** F U N C T I O N S *******************************************************/
 
 
+/** queue_layout_redraw() ********************************************
+ *
+ * Queues an expose event to happen on ourselves so we know to
+ * redraw later.
+ *
+ **/
+
+static void queue_layout_redraw(CtkDisplayLayout *ctk_object)
+{
+    GtkWidget *drawing_area = ctk_object->drawing_area;
+    GtkAllocation *allocation = &(drawing_area->allocation);
+    GdkRectangle rect;
+
+
+    if (!drawing_area->window) {
+        return;
+    }
+
+    /* Queue an expose event */
+    rect.x = allocation->x;
+    rect.y = allocation->x;
+    rect.width = allocation->width;
+    rect.height = allocation->height;
+
+    gdk_window_invalidate_rect(drawing_area->window, &rect, TRUE);
+
+} /* queue_layout_redraw() */
+
+
+
 /** zorder_layout() **************************************************
  *
  * In order to draw and allow selecting display devices, we need to
@@ -159,7 +189,7 @@ static void calc_metamode(nvScreenPtr screen, nvMetaModePtr metamode);
  *
  **/
 
-static void zorder_layout(CtkDisplayLayout *ctk_object) 
+static void zorder_layout(CtkDisplayLayout *ctk_object)
 {
     nvLayoutPtr layout = ctk_object->layout;
     nvGpuPtr gpu;
@@ -1786,7 +1816,7 @@ static void snap_pan(CtkDisplayLayout *ctk_object)
  * function handles movement of relative and absolute positions as
  * well as snapping.
  *
- * Returns 1 if a move occured.
+ * Returns 1 if the layout was modified
  *
  **/
 
@@ -1794,6 +1824,7 @@ static int move_selected(CtkDisplayLayout *ctk_object, int x, int y, int snap)
 {
     nvLayoutPtr layout = ctk_object->layout;
     ModifyInfo *info = &(ctk_object->modify_info);
+    int modified = 0;
 
     int *dim; /* Temp dimensions */
     int *sdim; /* Temp screen dimensions */
@@ -1826,12 +1857,12 @@ static int move_selected(CtkDisplayLayout *ctk_object, int x, int y, int snap)
             /* Compute the new orientation based on the mouse position */
             *(info->target_position_type) =
                 get_point_relative_position(dim, p_x, p_y);
-            
+
             /* For displays, while in basic mode, make sure that the
              * relative position applies to all metamodes.
              */
             if (info->display) {
-                
+
                 if (!ctk_object->advanced_mode) {
                     nvModePtr mode;
                     for (mode = info->display->modes; mode;
@@ -1839,7 +1870,7 @@ static int move_selected(CtkDisplayLayout *ctk_object, int x, int y, int snap)
                         mode->position_type = *(info->target_position_type);
                     }
                 }
-                
+
                 /* Make sure the screen position does not change */
                 reposition_screen(info->screen, !ctk_object->advanced_mode);
                 /* Always update the modify dim for relative positioning */
@@ -1890,7 +1921,6 @@ static int move_selected(CtkDisplayLayout *ctk_object, int x, int y, int snap)
         }
         sdim = get_screen_dim(info->screen, 1);
 
-        
         /* Prevent moving out of the max layout bounds */
         x = MAX_LAYOUT_WIDTH - dim[W];
         if (info->dst_dim[X] > x) {
@@ -1999,10 +2029,15 @@ static int move_selected(CtkDisplayLayout *ctk_object, int x, int y, int snap)
         }
     }
 
-
     /* Recalculate layout dimensions and scaling */
     calc_layout(layout);
-    offset_layout(layout, -layout->dim[X], -layout->dim[Y]);
+
+    /* If layout needs to offset, it was modified */
+    if (layout->dim[X] || layout->dim[Y]) {
+        offset_layout(layout, -layout->dim[X], -layout->dim[Y]);
+        modified = 1;
+    }
+
     recenter_layout(layout);
     sync_scaling(ctk_object);
 
@@ -2012,21 +2047,21 @@ static int move_selected(CtkDisplayLayout *ctk_object, int x, int y, int snap)
      */
     x = info->target_dim[X] - info->dst_dim[X];
     y = info->target_dim[Y] - info->dst_dim[Y];
-    if (x || y ) {
+    if (x || y) {
         info->modify_dim[X] += x;
         info->modify_dim[Y] += y;
     }
 
-    /* Report if anything changed */
+    /* Check if the item being moved has a new position */
     if (*(info->target_position_type) != info->orig_position_type ||
         info->target_dim[X] != info->orig_dim[X] ||
         info->target_dim[Y] != info->orig_dim[Y]) {
-        return 1;
+        modified = 1;
     }
 
     // XXX Screen could have changed position due to display moving.
 
-    return 0;
+    return modified;
 
 } /* move_selected() */
 
@@ -2042,10 +2077,11 @@ static int pan_selected(CtkDisplayLayout *ctk_object, int x, int y, int snap)
 {
     nvLayoutPtr layout = ctk_object->layout;
     ModifyInfo *info = &(ctk_object->modify_info);
+    int modified = 0;
 
     int *dim;
     int extra;
-    
+
 
     info->modify_panning = 1;
     if (!get_modify_info(ctk_object)) return 0;
@@ -2154,18 +2190,27 @@ static int pan_selected(CtkDisplayLayout *ctk_object, int x, int y, int snap)
 
     /* Recalculate layout dimensions and scaling */
     calc_layout(layout);
-    offset_layout(layout, -layout->dim[X], -layout->dim[Y]);
+
+    /* If layout needs to offset, something moved */
+    if (layout->dim[X] || layout->dim[Y]) {
+        offset_layout(layout, -layout->dim[X], -layout->dim[Y]);
+        modified = 1;
+    }
+
     recenter_layout(layout);
     sync_scaling(ctk_object);
 
 
+    /* Check if the item being moved has a new position */
     /* Report if anything changed */
     if (info->target_dim[W] != info->orig_dim[W] ||
         info->target_dim[H] != info->orig_dim[H]) {
-        return 1;
+        modified = 1;
     }
 
-    return 0;
+    // XXX Screen could have changed position due to display moving.
+
+    return modified;
 
 } /* pan_selected() */
 
@@ -2822,18 +2867,20 @@ GtkWidget* ctk_display_layout_new(NvCtrlAttributeHandle *handle,
     ctk_object->selected_callback_data = NULL;
     ctk_object->modified_callback = NULL;
     ctk_object->modified_callback_data = NULL;
+    ctk_object->Zorder = NULL;
+    ctk_object->Zcount = 0;
 
     /* Setup widget properties */
     ctk_object->ctk_config = ctk_config;
 
     ctk_object->handle = handle;
     ctk_object->layout = layout;
+
     calc_layout(layout);
     sync_scaling(ctk_object);
     zorder_layout(ctk_object);
     select_default_item(ctk_object);
 
-    
     /* Setup Pango layout/font */
     ctk_object->pango_layout =
         gtk_widget_create_pango_layout(GTK_WIDGET(ctk_object), NULL);
@@ -2863,7 +2910,6 @@ GtkWidget* ctk_display_layout_new(NvCtrlAttributeHandle *handle,
 
     /* Setup the layout state variables */
     ctk_object->snap_strength = DEFAULT_SNAP_STRENGTH;
-    ctk_object->need_swap = 0;
     ctk_object->first_selected_display = NULL;
     ctk_object->first_selected_screen = NULL;
 
@@ -2874,7 +2920,8 @@ GtkWidget* ctk_display_layout_new(NvCtrlAttributeHandle *handle,
                           GDK_EXPOSURE_MASK |
                           GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
-                          GDK_POINTER_MOTION_MASK);
+                          GDK_POINTER_MOTION_MASK |
+                          GDK_POINTER_MOTION_HINT_MASK);
 
     g_signal_connect (G_OBJECT (tmp), "expose_event",  
                       G_CALLBACK (expose_event_callback),
@@ -2943,34 +2990,6 @@ static GdkGC *get_widget_fg_gc(GtkWidget *widget)
 
 
 
-/** do_swap() ********************************************************
- *
- * Preforms a swap from the back buffer if one is needed.
- *
- **/
-
-static void do_swap(CtkDisplayLayout *ctk_object)
-{
-    GtkWidget *drawing_area = ctk_object->drawing_area;
-    GdkGC *fg_gc = get_widget_fg_gc(drawing_area);
-
-    if (ctk_object->need_swap && drawing_area->window && fg_gc) {
-
-        gdk_draw_pixmap(drawing_area->window,
-                        fg_gc,
-                        ctk_object->pixmap,
-                        0,0,
-                        0,0,
-                        ctk_object->width,
-                        ctk_object->height);
-
-        ctk_object->need_swap = 0;
-    }
-
-} /* do_swap() */
-
-
-
 /** draw_rect() ******************************************************
  *
  * Draws a solid or wireframe rectangle to scale of the given color
@@ -3001,8 +3020,6 @@ static void draw_rect(CtkDisplayLayout *ctk_object,
                        w,
                        h);
 
-    ctk_object->need_swap = 1;
-
 } /* draw_rect() */
 
 
@@ -3035,7 +3052,7 @@ static void draw_rect_strs(CtkDisplayLayout *ctk_object,
     if (str_1) {
         pango_layout_set_text(ctk_object->pango_layout, str_1, -1);
         pango_layout_get_pixel_size(ctk_object->pango_layout, &txt_w, &txt_h);
-        
+
         if (txt_w +8 <= ctk_object->scale * dim[W] &&
             txt_h +8 <= ctk_object->scale * dim[H]) {
             draw_1 = 1;
@@ -3079,8 +3096,6 @@ static void draw_rect_strs(CtkDisplayLayout *ctk_object,
                         ctk_object->img_dim[X] + txt_x1,
                         ctk_object->img_dim[Y] + txt_y1,
                         ctk_object->pango_layout);
-
-        ctk_object->need_swap = 1;
     }
 
     else if (!draw_1 && draw_2) {
@@ -3098,8 +3113,6 @@ static void draw_rect_strs(CtkDisplayLayout *ctk_object,
                         ctk_object->img_dim[X] + txt_x2,
                         ctk_object->img_dim[Y] + txt_y2,
                         ctk_object->pango_layout);
-
-        ctk_object->need_swap = 1;
     }
 
     else if (draw_1 && draw_2) {
@@ -3155,7 +3168,7 @@ static void draw_display(CtkDisplayLayout *ctk_object,
     draw_rect(ctk_object, mode->pan, &(ctk_object->color_palettes[color_idx]),
               1);
     draw_rect(ctk_object, mode->pan, &(ctk_object->fg_color), 0);
-    
+
 
     /* Draw viewport */
     color_idx = base_color_idx + ((mode->modeline) ? BG_SCR_ON : BG_SCR_OFF);
@@ -3248,7 +3261,7 @@ static void draw_layout(CtkDisplayLayout *ctk_object)
 {
     GtkWidget *drawing_area = ctk_object->drawing_area;
     GdkGC *fg_gc = get_widget_fg_gc(drawing_area);
-    
+
     GdkColor bg_color; /* Background color */
     GdkColor bd_color; /* Border color */
     int i;
@@ -3257,19 +3270,15 @@ static void draw_layout(CtkDisplayLayout *ctk_object)
     gdk_color_parse("#888888", &bg_color);
     gdk_color_parse("#777777", &bd_color);
 
-
     /* Draw the Z-order back to front */
     for (i = ctk_object->Zcount - 1; i >= 0; i--) {
         if (ctk_object->Zorder[i].type == ZNODE_TYPE_DISPLAY) {
             draw_display(ctk_object, ctk_object->Zorder[i].u.display);
-            ctk_object->need_swap = 1;
         } else if (ctk_object->Zorder[i].type == ZNODE_TYPE_SCREEN) {
             draw_screen(ctk_object, ctk_object->Zorder[i].u.screen);
-            ctk_object->need_swap = 1;
         }
     }
 
-
     /* Hilite the selected item */
     if (ctk_object->selected_display ||
         ctk_object->selected_screen) {
@@ -3311,7 +3320,7 @@ static void draw_layout(CtkDisplayLayout *ctk_object)
                                ctk_object->img_dim[Y] +(ctk_object->scale * dim[Y]) +offset,
                                w -(2 * offset),
                                h -(2 * offset));
-            
+
             gdk_gc_set_line_attributes(fg_gc, 1, GDK_LINE_SOLID, GDK_CAP_ROUND,
                                        GDK_JOIN_ROUND);
         }
@@ -3320,7 +3329,7 @@ static void draw_layout(CtkDisplayLayout *ctk_object)
         /* Uncomment to show bounding box of selected screen's metamodes */
         /*
         if (ctk_object->selected_screen) {
-            
+
             // Shows the screen dimensions used to write to the X config file
             gdk_color_parse("#00FF00", &bg_color);
             draw_rect(ctk_object,
@@ -3360,8 +3369,6 @@ static void draw_layout(CtkDisplayLayout *ctk_object)
             }
         }
         //*/
-
-        ctk_object->need_swap = 1;
     }
 
 } /* draw_layout() */
@@ -3377,6 +3384,7 @@ static void draw_layout(CtkDisplayLayout *ctk_object)
 static void clear_layout(CtkDisplayLayout *ctk_object)
 {
     GtkWidget *drawing_area = ctk_object->drawing_area;
+    GtkAllocation *allocation = &(drawing_area->allocation);
     GdkGC *fg_gc = get_widget_fg_gc(drawing_area);
     GdkColor color;
 
@@ -3389,8 +3397,8 @@ static void clear_layout(CtkDisplayLayout *ctk_object)
                        TRUE,
                        2,
                        2,
-                       drawing_area->allocation.width  -4,
-                       drawing_area->allocation.height -4);
+                       allocation->width  -4,
+                       allocation->height -4);
 
 
     /* Add white trim */
@@ -3401,8 +3409,8 @@ static void clear_layout(CtkDisplayLayout *ctk_object)
                        FALSE,
                        1,
                        1,
-                       drawing_area->allocation.width  -3,
-                       drawing_area->allocation.height -3);
+                       allocation->width  -3,
+                       allocation->height -3);
 
 
     /* Add layout border */
@@ -3412,42 +3420,13 @@ static void clear_layout(CtkDisplayLayout *ctk_object)
                        FALSE,
                        0,
                        0,
-                       drawing_area->allocation.width  -1,
-                       drawing_area->allocation.height -1);
-
-    ctk_object->need_swap = 1;
+                       allocation->width  -1,
+                       allocation->height -1);
 
 } /* clear_layout() */
 
 
 
-/** draw_all() *******************************************************
- *
- * Clears and redraws the entire layout.
- *
- **/
-
-static void draw_all(CtkDisplayLayout *ctk_object)
-{
-    GtkWidget *drawing_area = ctk_object->drawing_area;
-    GdkGC *fg_gc = get_widget_fg_gc(drawing_area);
-    GdkGCValues old_gc_values;
-
-    if (!fg_gc) return;
-
-    /* Redraw everything */
-    gdk_gc_get_values(fg_gc, &old_gc_values);
-
-    clear_layout(ctk_object);
-
-    draw_layout(ctk_object);
-
-    gdk_gc_set_values(fg_gc, &old_gc_values, GDK_GC_FOREGROUND);
-
-} /* draw_all() */
-
-
-
 /** ctk_display_layout_update() **************************************
  *
  * Causes a recalculation of the layout.
@@ -3470,24 +3449,9 @@ void ctk_display_layout_update(CtkDisplayLayout *ctk_object)
         ctk_object->selected_screen = ctk_object->selected_display->screen;
     }
 
-} /* ctk_display_layout_update() */
-
-
-
-/** ctk_display_layout_redraw() **************************************
- *
- * Redraw everything in the layout and makes sure the widget is
- * updated.
- *
- **/
-
-void ctk_display_layout_redraw(CtkDisplayLayout *ctk_object)
-{
-    ctk_display_layout_update(ctk_object);
-    draw_all(ctk_object);
-    do_swap(ctk_object);
+    queue_layout_redraw(ctk_object);
 
-} /* ctk_display_layout_redraw() */
+} /* ctk_display_layout_update() */
 
 
 
@@ -3505,8 +3469,8 @@ void ctk_display_layout_set_layout(CtkDisplayLayout *ctk_object,
     zorder_layout(ctk_object);
     select_default_item(ctk_object);
 
-    /* Redraw */
-    ctk_display_layout_redraw(ctk_object);
+    /* Update */
+    ctk_display_layout_update(ctk_object);
 
 } /* ctk_display_layout_set_layout() */
 
@@ -3522,6 +3486,8 @@ void ctk_display_layout_update_zorder(CtkDisplayLayout *ctk_object)
 {
     zorder_layout(ctk_object);
 
+    queue_layout_redraw(ctk_object);
+
 } /* ctk_display_layout_update_zorder() */
 
 
@@ -3601,8 +3567,8 @@ void ctk_display_layout_set_screen_metamode(CtkDisplayLayout *ctk_object,
     sync_scaling(ctk_object);
     ctk_object->modify_info.modify_dirty = 1;
 
-    /* Redraw the layout */
-    ctk_display_layout_redraw(ctk_object);
+    /* Update the layout */
+    ctk_display_layout_update(ctk_object);
 
 } /* ctk_display_layout_set_screen_metamode() */
 
@@ -3684,6 +3650,7 @@ void ctk_display_layout_add_screen_metamode(CtkDisplayLayout *ctk_object,
      * - Remove metamode from screen
      * - Remove any excess metamodes from the displays
      */
+    queue_layout_redraw(ctk_object);
     return;
 
 } /* ctk_display_layout_add_screen_metamode() */
@@ -3786,6 +3753,8 @@ void ctk_display_layout_delete_screen_metamode(CtkDisplayLayout *ctk_object,
             (ctk_object, screen, screen->cur_metamode_idx);
     }
 
+    queue_layout_redraw(ctk_object);
+
 } /* ctk_display_layout_delete_screen_metamode() */
 
 
@@ -3823,6 +3792,8 @@ void ctk_display_layout_disable_display(CtkDisplayLayout *ctk_object,
     /* Add the fake mode to the display */
     gpu_add_screenless_modes_to_displays(display->gpu);
 
+    queue_layout_redraw(ctk_object);
+
 } /* ctk_display_layout_disable_display() */
 
 
@@ -3852,14 +3823,14 @@ void ctk_display_layout_set_mode_modeline(CtkDisplayLayout *ctk_object,
     if (modeline) {
         mode->dim[W] = modeline->data.hdisplay;
         mode->dim[H] = modeline->data.vdisplay;
-        
+
         if (mode->pan[W] < modeline->data.hdisplay) {
             mode->pan[W] = modeline->data.hdisplay;
         }
         if (mode->pan[H] < modeline->data.vdisplay) {
             mode->pan[H] = modeline->data.vdisplay;
         }
-        
+
         /* If the old modeline did not have panning dimensions */
         if (!old_modeline ||
             (mode->pan[W] == old_modeline->data.hdisplay)) {
@@ -3888,8 +3859,8 @@ void ctk_display_layout_set_mode_modeline(CtkDisplayLayout *ctk_object,
     }
 
 
-    /* Redraw the layout */
-    ctk_display_layout_redraw(ctk_object);
+    /* Update the layout */
+    ctk_display_layout_update(ctk_object);
 
 } /* ctk_display_layout_set_display_modeline() */
 
@@ -3907,9 +3878,6 @@ void ctk_display_layout_set_display_position(CtkDisplayLayout *ctk_object,
                                              nvDisplayPtr relative_to,
                                              int x, int y)
 {
-    GtkWidget *drawing_area = ctk_object->drawing_area;
-    GdkGC *fg_gc = get_widget_fg_gc(drawing_area);
-    GdkGCValues old_gc_values;
     int modified = 0;
     int resolve_all_modes = !ctk_object->advanced_mode;
 
@@ -3918,15 +3886,6 @@ void ctk_display_layout_set_display_position(CtkDisplayLayout *ctk_object,
 
     if (position_type != CONF_ADJ_ABSOLUTE && !relative_to) return;
 
-
-    /* Backup the foreground color and clear the layout */
-    if (fg_gc) {
-        gdk_gc_get_values(fg_gc, &old_gc_values);
-        
-        clear_layout(ctk_object);
-    }
-
-
     /* XXX When configuring a relative position, make sure
      * all displays that are relative to us become absolute.
      * This is to avoid relationship loops.  Eventually, we'll want
@@ -3975,7 +3934,7 @@ void ctk_display_layout_set_display_position(CtkDisplayLayout *ctk_object,
             mode->relative_to = relative_to;
         }
     }
-    
+
 
     switch (position_type) {
     case CONF_ADJ_ABSOLUTE:
@@ -3985,17 +3944,17 @@ void ctk_display_layout_set_display_position(CtkDisplayLayout *ctk_object,
                                  x - display->cur_mode->dim[X],
                                  y - display->cur_mode->dim[Y],
                                  0);
-        
+
         /* Report back result of move */
         if (ctk_object->modified_callback &&
-            (modified || 
+            (modified ||
              x != display->cur_mode->dim[X] ||
              y != display->cur_mode->dim[Y])) {
             ctk_object->modified_callback
                 (ctk_object->layout, ctk_object->modified_callback_data);
         }
         break;
-        
+
     default:
         /* Make sure the screen position does not change */
         reposition_screen(display->screen, resolve_all_modes);
@@ -4005,15 +3964,7 @@ void ctk_display_layout_set_display_position(CtkDisplayLayout *ctk_object,
         break;
     }
 
-    
-    /* Redraw the layout and reset the foreground color */
-    if (fg_gc) {
-        draw_layout(ctk_object);
-
-        gdk_gc_set_values(fg_gc, &old_gc_values, GDK_GC_FOREGROUND);
-        
-        do_swap(ctk_object);
-    }
+    queue_layout_redraw(ctk_object);
 
 } /* ctk_display_layout_set_display_position() */
 
@@ -4029,49 +3980,28 @@ void ctk_display_layout_set_display_panning(CtkDisplayLayout *ctk_object,
                                             nvDisplayPtr display,
                                             int width, int height)
 {
-    GtkWidget *drawing_area = ctk_object->drawing_area;
-    GdkGC *fg_gc = get_widget_fg_gc(drawing_area);
-    GdkGCValues old_gc_values;
     int modified = 0;
 
 
     if (!display) return;
 
-
-    /* Backup the foreground color */
-    if (fg_gc) {
-        gdk_gc_get_values(fg_gc, &old_gc_values);
-
-        clear_layout(ctk_object);
-    }
-
-
     /* Change the panning */
     ctk_object->modify_info.modify_dirty = 1;
     modified = pan_selected(ctk_object,
                             width  - display->cur_mode->pan[W],
                             height - display->cur_mode->pan[H],
                             0);
-    
 
     /* Report back result of move */
     if (ctk_object->modified_callback &&
-        (modified || 
+        (modified ||
          width  != display->cur_mode->pan[W] ||
          height != display->cur_mode->pan[H])) {
         ctk_object->modified_callback(ctk_object->layout,
                                       ctk_object->modified_callback_data);
     }
-    
-
-    /* Redraw layout and reset the foreground color */
-    if (fg_gc) {
-        draw_layout(ctk_object);
 
-        gdk_gc_set_values(fg_gc, &old_gc_values, GDK_GC_FOREGROUND);
-
-        do_swap(ctk_object);
-    }
+    queue_layout_redraw(ctk_object);
 
 } /* ctk_display_layout_set_display_panning() */
 
@@ -4106,6 +4036,8 @@ void ctk_display_layout_select_display(CtkDisplayLayout *ctk_object,
     /* Select the new display */
     select_display(ctk_object, display);
 
+    queue_layout_redraw(ctk_object);
+
 } /* ctk_display_layout_select_display() */
 
 
@@ -4130,6 +4062,8 @@ void ctk_display_layout_update_display_count(CtkDisplayLayout *ctk_object,
         select_topmost_item(ctk_object);
     }
 
+    queue_layout_redraw(ctk_object);
+
 } /* ctk_display_layout_update_display_count() */
 
 
@@ -4144,20 +4078,10 @@ void ctk_display_layout_set_screen_virtual_size(CtkDisplayLayout *ctk_object,
                                                 nvScreenPtr screen,
                                                 int width, int height)
 {
-    GtkWidget *drawing_area = ctk_object->drawing_area;
-    GdkGC *fg_gc = get_widget_fg_gc(drawing_area);
-    GdkGCValues old_gc_values;
     int modified;
 
     if (!screen || !screen->no_scanout) return;
 
-    /* Backup the foreground color */
-    if (fg_gc) {
-        gdk_gc_get_values(fg_gc, &old_gc_values);
-
-        clear_layout(ctk_object);
-    }
-
     /* Do the panning by offsetting */
 
     // XXX May want to pan non-selected screen,
@@ -4178,14 +4102,7 @@ void ctk_display_layout_set_screen_virtual_size(CtkDisplayLayout *ctk_object,
                                       ctk_object->modified_callback_data);
     }
 
-    /* Redraw layout and reset the foreground color */
-    if (fg_gc) {
-        draw_layout(ctk_object);
-
-        gdk_gc_set_values(fg_gc, &old_gc_values, GDK_GC_FOREGROUND);
-
-        do_swap(ctk_object);
-    }
+    queue_layout_redraw(ctk_object);
 
 } /* ctk_display_layout_set_screen_virtual_size() */
 
@@ -4222,9 +4139,6 @@ void ctk_display_layout_set_screen_position(CtkDisplayLayout *ctk_object,
                                             nvScreenPtr relative_to,
                                             int x, int y)
 {
-    GtkWidget *drawing_area = ctk_object->drawing_area;
-    GdkGC *fg_gc = get_widget_fg_gc(drawing_area);
-    GdkGCValues old_gc_values;
     int modified = 0;
     nvLayoutPtr layout = ctk_object->layout;
 
@@ -4234,13 +4148,6 @@ void ctk_display_layout_set_screen_position(CtkDisplayLayout *ctk_object,
     if (position_type != CONF_ADJ_ABSOLUTE && !relative_to) return;
 
 
-    /* Backup the foreground color and clear the layout */
-    if (fg_gc) {
-        gdk_gc_get_values(fg_gc, &old_gc_values);
-        clear_layout(ctk_object);
-    }
-
-
     /* XXX When configuring a relative position, make sure
      * all screens that are relative to us become absolute.
      * This is to avoid relationship loops.  Eventually, we'll want
@@ -4299,11 +4206,10 @@ void ctk_display_layout_set_screen_position(CtkDisplayLayout *ctk_object,
         break;
 
     case CONF_ADJ_RELATIVE:
-        
-        /* Fall Through */
         screen->x_offset = x;
         screen->y_offset = y;
- 
+
+        /* Fall Through */
     default:
         /* Set the desired positioning */
         screen->relative_to = relative_to;
@@ -4324,21 +4230,14 @@ void ctk_display_layout_set_screen_position(CtkDisplayLayout *ctk_object,
          *  CRT-1 left of CRT-2
          *  CRT-2 clones  CRT-0 ...  Eep!
          */
-        
+
         /* Recalculate the layout */
         ctk_display_layout_update(ctk_object);
         break;
     }
 
 
-    /* Redraw the layout and reset the foreground color */
-    if (fg_gc) {
-        draw_layout(ctk_object);
-        
-        gdk_gc_set_values(fg_gc, &old_gc_values, GDK_GC_FOREGROUND);
-        
-        do_swap(ctk_object);
-    }
+    queue_layout_redraw(ctk_object);
 
 } /* ctk_display_layout_set_screen_position() */
 
@@ -4404,15 +4303,34 @@ static gboolean
 expose_event_callback(GtkWidget *widget, GdkEventExpose *event, gpointer data)
 {
     CtkDisplayLayout *ctk_object = CTK_DISPLAY_LAYOUT(data);
+    GdkGC *fg_gc = get_widget_fg_gc(widget);
+    GdkGCValues old_gc_values;
 
 
-    if (event->count) {
+    if (event->count || !widget->window || !fg_gc) {
         return TRUE;
     }
 
     /* Redraw the layout */
-    ctk_display_layout_redraw(ctk_object);
-    
+    gdk_window_begin_paint_rect(widget->window, &event->area);
+
+    gdk_gc_get_values(fg_gc, &old_gc_values);
+
+    clear_layout(ctk_object);
+
+    draw_layout(ctk_object);
+
+    gdk_gc_set_values(fg_gc, &old_gc_values, GDK_GC_FOREGROUND);
+
+    gdk_draw_pixmap(widget->window,
+                    fg_gc,
+                    ctk_object->pixmap,
+                    event->area.x, event->area.y,
+                    event->area.x, event->area.y,
+                    event->area.width, event->area.height);
+
+    gdk_window_end_paint(widget->window);
+
     return TRUE;
 
 } /* expose_event_callback() */
@@ -4433,17 +4351,15 @@ configure_event_callback(GtkWidget *widget, GdkEventConfigure *event,
     int width = widget->allocation.width;
     int height = widget->allocation.height;
 
-    ctk_object->width = width;
-    ctk_object->height = height;
     ctk_object->img_dim[X] = LAYOUT_IMG_OFFSET + LAYOUT_IMG_BORDER_PADDING;
     ctk_object->img_dim[Y] = LAYOUT_IMG_OFFSET + LAYOUT_IMG_BORDER_PADDING;
     ctk_object->img_dim[W] = width  -2*(ctk_object->img_dim[X]);
     ctk_object->img_dim[H] = height -2*(ctk_object->img_dim[Y]);
 
     sync_scaling(ctk_object);
-    
+
     ctk_object->pixmap = gdk_pixmap_new(widget->window, width, height, -1);
-    
+
     return TRUE;
 
 } /* configure_event_callback() */
@@ -4460,16 +4376,24 @@ static gboolean
 motion_event_callback(GtkWidget *widget, GdkEventMotion *event, gpointer data)
 {
     CtkDisplayLayout *ctk_object = CTK_DISPLAY_LAYOUT(data);
-    GtkWidget *drawing_area = ctk_object->drawing_area;
-    GdkGC *fg_gc = get_widget_fg_gc(drawing_area);
-    GdkGCValues old_gc_values;
-
     static int init = 1;
     int modify_panning;
+    int x;
+    int y;
+    GdkModifierType state;
 
 
+    /* Handle hints so we don't get overwhelmed with motion events */
+    if (event->is_hint) {
+        gdk_window_get_pointer(event->window, &x, &y, &state);
+    } else {
+        x = event->x;
+        y = event->y;
+        state = event->state;
+    }
+
     /* Swap between panning and moving  */
-    if (ctk_object->advanced_mode && (event->state & ShiftMask)) {
+    if (ctk_object->advanced_mode && (state & ShiftMask)) {
         modify_panning = 1;
     } else {
         modify_panning = 0;
@@ -4480,13 +4404,13 @@ motion_event_callback(GtkWidget *widget, GdkEventMotion *event, gpointer data)
     }
 
     /* Nothing to do if mouse didn't move */
-    if (ctk_object->last_mouse_x == event->x &&
-        ctk_object->last_mouse_y == event->y) {
+    if (ctk_object->last_mouse_x == x &&
+        ctk_object->last_mouse_y == y) {
         return TRUE;
     }
 
-    ctk_object->mouse_x = event->x;
-    ctk_object->mouse_y = event->y;
+    ctk_object->mouse_x = x;
+    ctk_object->mouse_y = y;
 
 
     /* If mouse moved, allow user to reselect the current display/screen */
@@ -4494,20 +4418,13 @@ motion_event_callback(GtkWidget *widget, GdkEventMotion *event, gpointer data)
     ctk_object->first_selected_screen = NULL;
 
 
-    /* Backup the foreground color */
-    gdk_gc_get_values(fg_gc, &old_gc_values);
-
-
     /* Modify screen layout */
     if (ctk_object->button1 && !ctk_object->clicked_outside) {
         int modified = 0;
         int delta_x =
-            (event->x - ctk_object->last_mouse_x) / ctk_object->scale;
+            (x - ctk_object->last_mouse_x) / ctk_object->scale;
         int delta_y =
-            (event->y - ctk_object->last_mouse_y) / ctk_object->scale;
-
-
-        clear_layout(ctk_object);
+            (y - ctk_object->last_mouse_y) / ctk_object->scale;
 
         if (!modify_panning) {
             modified = move_selected(ctk_object, delta_x, delta_y, 1);
@@ -4515,40 +4432,33 @@ motion_event_callback(GtkWidget *widget, GdkEventMotion *event, gpointer data)
             modified = pan_selected(ctk_object, delta_x, delta_y, 1);
         }
 
-        if (modified && ctk_object->modified_callback) {
-            ctk_object->modified_callback(ctk_object->layout,
-                                       ctk_object->modified_callback_data);
-        }
+        if (modified) {
+            GtkWidget *drawing_area = ctk_object->drawing_area;
 
-        draw_layout(ctk_object);
+            if (ctk_object->modified_callback) {
+                ctk_object->modified_callback(ctk_object->layout,
+                                              ctk_object->modified_callback_data);
+            }
 
+            /* Queue and process expose event so we redraw ASAP */
+            queue_layout_redraw(ctk_object);
+            gdk_window_process_updates(drawing_area->window, TRUE);
+        }
 
     /* Update the tooltip under the mouse */
     } else {
-        char *tip =
-            get_tooltip_under_mouse(ctk_object, event->x, event->y);
-
+        char *tip = get_tooltip_under_mouse(ctk_object, x, y);
         if (tip) {
             gtk_tooltips_set_tip(ctk_object->tooltip_group,
                                  ctk_object->tooltip_area,
                                  tip, NULL);
-            
             gtk_tooltips_force_window(ctk_object->tooltip_group);
             g_free(tip);
         }
     }
 
-
-    ctk_object->last_mouse_x = event->x;
-    ctk_object->last_mouse_y = event->y;
-
-
-    /* Reset the foreground color */
-    gdk_gc_set_values(fg_gc, &old_gc_values, GDK_GC_FOREGROUND);
-    
-
-    /* Refresh GUI */
-    do_swap(ctk_object);
+    ctk_object->last_mouse_x = x;
+    ctk_object->last_mouse_y = y;
 
     return TRUE;
 
@@ -4681,19 +4591,13 @@ button_press_event_callback(GtkWidget *widget, GdkEventButton *event,
                                           ctk_object->selected_callback_data);
         }
 
-        /* Redraw everything */
-        draw_all(ctk_object);
-
+        queue_layout_redraw(ctk_object);
         break;
 
     default:
         break;
     }
 
-
-    /* Refresh GUI */
-    do_swap(ctk_object);
-    
     return TRUE;
 
 } /* button_press_event_callback() */
@@ -4730,10 +4634,6 @@ button_release_event_callback(GtkWidget *widget, GdkEventButton *event,
     default:
         break;
     }
-    
-
-    /* Refresh GUI */
-    do_swap(ctk_object);
 
     return TRUE;
 
diff --git a/src/gtk+-2.x/ctkdisplaylayout.h b/src/gtk+-2.x/ctkdisplaylayout.h
index 5ed89ec..dfc6dab 100644
--- a/src/gtk+-2.x/ctkdisplaylayout.h
+++ b/src/gtk+-2.x/ctkdisplaylayout.h
@@ -396,11 +396,8 @@ typedef struct _CtkDisplayLayout
 
     /* Double buffering of layout image */
     GdkPixmap *pixmap;
-    int        need_swap;
 
     /* Image information */
-    int        width;           /* Real widget dimensions */
-    int        height;
     int        img_dim[4];      /* Dimensions used to draw in */
     float      scale;
 
@@ -413,7 +410,7 @@ typedef struct _CtkDisplayLayout
     /* Pango layout for strings in layout image */
 
     PangoLayout *pango_layout;
-    
+
     /* List of visible elements in the layout */
     ZNode *Zorder; /* Z ordering of visible elements in layout */
     int    Zcount; /* Count of visible elements in the z order */
@@ -467,9 +464,6 @@ GtkWidget*  ctk_display_layout_new       (NvCtrlAttributeHandle *,
 
 void ctk_display_layout_update (CtkDisplayLayout *);
 
-void ctk_display_layout_redraw (CtkDisplayLayout *);
-
-
 void ctk_display_layout_set_layout (CtkDisplayLayout *, nvLayoutPtr);
 
 void ctk_display_layout_update_zorder(CtkDisplayLayout *ctk_object);
diff --git a/src/gtk+-2.x/ctkditheringcontrols.c b/src/gtk+-2.x/ctkditheringcontrols.c
index ef380c0..1e98233 100644
--- a/src/gtk+-2.x/ctkditheringcontrols.c
+++ b/src/gtk+-2.x/ctkditheringcontrols.c
@@ -34,8 +34,7 @@
 #include "ctkditheringcontrols.h"
 
 /* function prototypes */
-static gboolean build_dithering_mode_table(CtkDitheringControls *ctk_dithering_controls,
-                                           NVCTRLAttributeValidValuesRec valid);
+static gboolean build_dithering_mode_table(CtkDitheringControls *ctk_dithering_controls);
 
 static gint map_nvctrl_value_to_table(CtkDitheringControls *ctk_dithering_controls,
                                       gint val);
@@ -70,11 +69,19 @@ void post_dithering_depth_update(CtkDitheringControls *ctk_dithering_controls,
 /* help text */
 static const char * __dithering_help =
 "The Dithering Controls show the current state of dithering and allow "
-"changing the dithering configuration, mode and/or depth.  Dithering will "
-"be performed when dithering is enabled here, and the panel's bitdepth is "
-"less than that of the GPU's internal pixel pipeline.  The depth can be "
-"adjusted to 6 or 8 bits per channel depending on the type of display "
-"device.";
+"changing the dithering configuration, mode and/or depth.";
+
+static const char * __dithering_config_help =
+"Dithering will be performed when dithering is enabled here and the "
+"panel's bitdepth is less than that of the GPU's internal pixel pipeline.";
+
+static const char * __dithering_mode_help = 
+"Dithering mode can be Dynamic 2x2, Static 2x2 or Temporal "
+"depending on the type of the display device.";
+
+static const char * __dithering_depth_help = 
+"The depth can be adjusted to 6 or 8 bits per channel depending on "
+"the type of display device.";
 
 GType ctk_dithering_controls_get_type(void)
 {
@@ -111,28 +118,8 @@ GtkWidget* ctk_dithering_controls_new(NvCtrlAttributeHandle *handle,
 {
     GObject *object;
     CtkDitheringControls *ctk_dithering_controls;
-    GtkWidget *frame, *vbox, *hbox, *label, *eventbox;
+    GtkWidget *frame, *vbox, *hbox, *label;
     GtkWidget *menu, *table, *menu_item = NULL, *separator;
-    ReturnStatus ret1, ret2, ret3;
-    NVCTRLAttributeValidValuesRec valid1, valid2, valid3;
-    gint i;
-
-    /* check if dithering configuration is supported */
-    ret1 = NvCtrlGetValidDisplayAttributeValues(handle, display_device_mask,
-                                                NV_CTRL_DITHERING,
-                                                &valid1);
-    ret2 = NvCtrlGetValidDisplayAttributeValues(handle, display_device_mask,
-                                                NV_CTRL_DITHERING_MODE,
-                                                &valid2);
-    ret3 = NvCtrlGetValidDisplayAttributeValues(handle, display_device_mask,
-                                                NV_CTRL_DITHERING_DEPTH,
-                                                &valid3);
-
-    if ((ret1 != NvCtrlSuccess) || (valid1.type != ATTRIBUTE_TYPE_INTEGER) ||
-        (ret2 != NvCtrlSuccess) || (valid2.type != ATTRIBUTE_TYPE_INT_BITS) ||
-        (ret3 != NvCtrlSuccess) || (valid3.type != ATTRIBUTE_TYPE_INTEGER)) {
-        return NULL;
-    }
 
     /* create the object */
     object = g_object_new(CTK_TYPE_DITHERING_CONTROLS, NULL);
@@ -147,11 +134,6 @@ GtkWidget* ctk_dithering_controls_new(NvCtrlAttributeHandle *handle,
     ctk_dithering_controls->display_device_mask = display_device_mask;
     ctk_dithering_controls->name = strdup(name);
 
-    /* build a table holding available dithering modes */
-    if (!build_dithering_mode_table(ctk_dithering_controls, valid2)) {
-        return NULL;
-    }
-
     /* create main dithering box & frame */
 
     hbox = gtk_hbox_new(FALSE, 0);
@@ -159,10 +141,7 @@ GtkWidget* ctk_dithering_controls_new(NvCtrlAttributeHandle *handle,
     ctk_dithering_controls->dithering_controls_main = hbox;
 
     frame = gtk_frame_new("Dithering Controls");
-    eventbox = gtk_event_box_new();
-    gtk_container_add(GTK_CONTAINER(eventbox), frame);
-    gtk_box_pack_start(GTK_BOX(hbox), eventbox, FALSE, FALSE, 0);
-    ctk_config_set_tooltip(ctk_config, eventbox, __dithering_help);
+    gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0);
 
     table = gtk_table_new(5, 4, FALSE);
     gtk_container_add(GTK_CONTAINER(frame), table);
@@ -190,6 +169,9 @@ GtkWidget* ctk_dithering_controls_new(NvCtrlAttributeHandle *handle,
     gtk_option_menu_set_menu
         (GTK_OPTION_MENU(ctk_dithering_controls->dithering_config_menu),
          menu);
+    ctk_config_set_tooltip(ctk_config, 
+                           ctk_dithering_controls->dithering_config_menu, 
+                           __dithering_config_help);
 
     g_signal_connect(G_OBJECT(ctk_dithering_controls->dithering_config_menu),
                      "changed", G_CALLBACK(dithering_config_menu_changed),
@@ -234,33 +216,11 @@ GtkWidget* ctk_dithering_controls_new(NvCtrlAttributeHandle *handle,
     gtk_table_attach(GTK_TABLE(table), vbox, 0, 4, 1, 2,
                      GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
 
-    /* dropdown list for dithering modes */
-    menu = gtk_menu_new();
-
-    for (i = 0; i < ctk_dithering_controls->dithering_mode_table_size; i++) {
-        switch (ctk_dithering_controls->dithering_mode_table[i]) {
-        case NV_CTRL_DITHERING_MODE_DYNAMIC_2X2:
-            menu_item = gtk_menu_item_new_with_label("Dynamic 2X2");
-            break;
-        case NV_CTRL_DITHERING_MODE_STATIC_2X2:
-            menu_item = gtk_menu_item_new_with_label("Static 2X2");
-            break;
-        case NV_CTRL_DITHERING_MODE_TEMPORAL:
-            menu_item = gtk_menu_item_new_with_label("Temporal");
-            break;
-        default:
-        case NV_CTRL_DITHERING_MODE_AUTO:
-            menu_item = gtk_menu_item_new_with_label("Auto");
-            break;
-        }
-        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
-        gtk_widget_show(menu_item);
-    }
-
+    /* dropdown list for dithering modes - populated in setup */
     ctk_dithering_controls->dithering_mode_menu = gtk_option_menu_new();
-    gtk_option_menu_set_menu
-        (GTK_OPTION_MENU(ctk_dithering_controls->dithering_mode_menu),
-         menu);
+    ctk_config_set_tooltip(ctk_config, 
+                           ctk_dithering_controls->dithering_mode_menu, 
+                           __dithering_mode_help);
 
     g_signal_connect(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
                      "changed", G_CALLBACK(dithering_mode_menu_changed),
@@ -325,6 +285,9 @@ GtkWidget* ctk_dithering_controls_new(NvCtrlAttributeHandle *handle,
     gtk_option_menu_set_menu
         (GTK_OPTION_MENU(ctk_dithering_controls->dithering_depth_menu),
          menu);
+    ctk_config_set_tooltip(ctk_config, 
+                           ctk_dithering_controls->dithering_depth_menu, 
+                           __dithering_depth_help);
 
     g_signal_connect(G_OBJECT(ctk_dithering_controls->dithering_depth_menu),
                      "changed", G_CALLBACK(dithering_depth_menu_changed),
@@ -405,7 +368,8 @@ GtkWidget* ctk_dithering_controls_new(NvCtrlAttributeHandle *handle,
  */
 void ctk_dithering_controls_setup(CtkDitheringControls *ctk_dithering_controls)
 {
-    gint val;
+    GtkWidget *menu, *menu_item = NULL;
+    gint val, i;
 
     if (!ctk_dithering_controls) {
         return;
@@ -433,10 +397,49 @@ void ctk_dithering_controls_setup(CtkDitheringControls *ctk_dithering_controls)
          G_CALLBACK(dithering_config_menu_changed),
          (gpointer) ctk_dithering_controls);
 
+    /* setup dithering modes */
+    build_dithering_mode_table(ctk_dithering_controls);
+
+    /* populate dropdown list for dithering modes */
+    menu = gtk_menu_new();
+    for (i = 0; i < ctk_dithering_controls->dithering_mode_table_size; i++) {
+        switch (ctk_dithering_controls->dithering_mode_table[i]) {
+        case NV_CTRL_DITHERING_MODE_DYNAMIC_2X2:
+            menu_item = gtk_menu_item_new_with_label("Dynamic 2x2");
+            break;
+        case NV_CTRL_DITHERING_MODE_STATIC_2X2:
+            menu_item = gtk_menu_item_new_with_label("Static 2x2");
+            break;
+        case NV_CTRL_DITHERING_MODE_TEMPORAL:
+            menu_item = gtk_menu_item_new_with_label("Temporal");
+            break;
+        default:
+        case NV_CTRL_DITHERING_MODE_AUTO:
+            menu_item = gtk_menu_item_new_with_label("Auto");
+            break;
+        }
+        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+        gtk_widget_show(menu_item);
+    }
+
+    g_signal_handlers_block_by_func
+        (G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
+         G_CALLBACK(dithering_mode_menu_changed),
+         (gpointer) ctk_dithering_controls);
+
+    gtk_option_menu_set_menu
+        (GTK_OPTION_MENU(ctk_dithering_controls->dithering_mode_menu),
+         menu);
+
+    g_signal_handlers_unblock_by_func
+        (G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
+         G_CALLBACK(dithering_mode_menu_changed),
+         (gpointer) ctk_dithering_controls);
+
+
     if (!update_dithering_info((gpointer)ctk_dithering_controls)) {
         gtk_widget_set_sensitive(ctk_dithering_controls->dithering_controls_main,
                                  FALSE);
-        gtk_widget_hide_all(ctk_dithering_controls->dithering_controls_main);
     }
 
 } /* ctk_dithering_controls_setup() */
@@ -453,16 +456,19 @@ static Bool update_dithering_info(gpointer user_data)
         NvCtrlGetDisplayAttribute(ctk_dithering_controls->handle,
                                   ctk_dithering_controls->display_device_mask,
                                   NV_CTRL_DITHERING, &val)) {
-        val = NV_CTRL_DITHERING_DISABLED;
-    }
-
-    if (val == NV_CTRL_DITHERING_ENABLED ||
-        val == NV_CTRL_DITHERING_AUTO) {
+        gtk_widget_set_sensitive(ctk_dithering_controls->dithering_controls_main, 
+                                 FALSE);
+    } else if (val == NV_CTRL_DITHERING_ENABLED ||
+               val == NV_CTRL_DITHERING_AUTO) {
+        gtk_widget_set_sensitive(ctk_dithering_controls->dithering_controls_main, 
+                                 TRUE);
         gtk_widget_set_sensitive(ctk_dithering_controls->dithering_mode_box, TRUE);
         gtk_widget_set_sensitive(ctk_dithering_controls->dithering_depth_box, TRUE);
         gtk_widget_show(ctk_dithering_controls->dithering_mode_box);
         gtk_widget_show(ctk_dithering_controls->dithering_depth_box);
     } else if (val == NV_CTRL_DITHERING_DISABLED) {
+        gtk_widget_set_sensitive(ctk_dithering_controls->dithering_controls_main, 
+                                 TRUE);
         gtk_widget_set_sensitive(ctk_dithering_controls->dithering_mode_box, FALSE);
         gtk_widget_set_sensitive(ctk_dithering_controls->dithering_depth_box, FALSE);
     }
@@ -484,13 +490,12 @@ static Bool update_dithering_info(gpointer user_data)
     }
 
     /* dithering mode */
-    dithering_mode = NV_CTRL_DITHERING_MODE_AUTO;
     if (NvCtrlSuccess !=
         NvCtrlGetDisplayAttribute(ctk_dithering_controls->handle,
                                   ctk_dithering_controls->display_device_mask,
                                   NV_CTRL_DITHERING_MODE,
                                   &dithering_mode)) {
-        goto fail;
+        dithering_mode = NV_CTRL_DITHERING_MODE_AUTO;
     }
 
     dithering_mode = map_nvctrl_value_to_table(ctk_dithering_controls,
@@ -511,13 +516,12 @@ static Bool update_dithering_info(gpointer user_data)
          (gpointer) ctk_dithering_controls);
 
     /* current dithering mode */
-    dithering_mode = NV_CTRL_CURRENT_DITHERING_MODE_NONE;
     if (NvCtrlSuccess !=
         NvCtrlGetDisplayAttribute(ctk_dithering_controls->handle,
                                   ctk_dithering_controls->display_device_mask,
                                   NV_CTRL_CURRENT_DITHERING_MODE,
                                   &dithering_mode)) {
-        goto fail;
+        dithering_mode = NV_CTRL_CURRENT_DITHERING_MODE_NONE;
     }
 
     switch (dithering_mode) {
@@ -541,13 +545,12 @@ static Bool update_dithering_info(gpointer user_data)
     }
 
     /* dithering depth */
-    dithering_depth = NV_CTRL_DITHERING_DEPTH_AUTO;
     if (NvCtrlSuccess !=
         NvCtrlGetDisplayAttribute(ctk_dithering_controls->handle,
                                   ctk_dithering_controls->display_device_mask,
                                   NV_CTRL_DITHERING_DEPTH,
                                   &dithering_depth)) {
-        goto fail;
+        dithering_depth = NV_CTRL_DITHERING_DEPTH_AUTO;
     }
 
     g_signal_handlers_block_by_func
@@ -565,13 +568,12 @@ static Bool update_dithering_info(gpointer user_data)
          (gpointer) ctk_dithering_controls);
 
     /* current dithering depth */
-    dithering_depth = NV_CTRL_CURRENT_DITHERING_DEPTH_NONE;
     if (NvCtrlSuccess !=
         NvCtrlGetDisplayAttribute(ctk_dithering_controls->handle,
                                   ctk_dithering_controls->display_device_mask,
                                   NV_CTRL_CURRENT_DITHERING_DEPTH,
                                   &dithering_depth)) {
-        goto fail;
+        dithering_depth = NV_CTRL_CURRENT_DITHERING_DEPTH_NONE;
     }
 
     switch (dithering_depth) {
@@ -591,10 +593,6 @@ static Bool update_dithering_info(gpointer user_data)
     }
 
     return True;
-
- fail:
-    free(ctk_dithering_controls->dithering_mode_table);
-    return False;
 } /* update_dithering_info() */
 
 static
@@ -836,6 +834,15 @@ void add_dithering_controls_help(CtkDitheringControls *ctk_dithering_controls,
 {
     ctk_help_heading(b, i, "Dithering Controls");
     ctk_help_para(b, i, __dithering_help);
+
+    ctk_help_term(b, i, "Dithering");
+    ctk_help_para(b, i, __dithering_config_help);
+
+    ctk_help_term(b, i, "Mode");
+    ctk_help_para(b, i, __dithering_mode_help);
+
+    ctk_help_term(b, i, "Depth");
+    ctk_help_para(b, i, __dithering_depth_help);
 } /* add_dithering_controls_help() */
 
 
@@ -873,17 +880,43 @@ static void dithering_update_received(GtkObject *object, gpointer arg1,
  * build_dithering_mode_table() - build a table of dithering modes, showing
  * modes supported by the hardware.
  */
-static gboolean build_dithering_mode_table(CtkDitheringControls *ctk_dithering_controls,
-                                           NVCTRLAttributeValidValuesRec valid)
+static gboolean build_dithering_mode_table(CtkDitheringControls *ctk_dithering_controls)
 {
-    gint i, n = 0, num_of_modes = 0;
-    gint mask = valid.u.bits.ints;
+    ReturnStatus ret;
+    NVCTRLAttributeValidValuesRec valid;
+    gint i, n = 0, num_of_modes = 0, mask;
+
+    if (ctk_dithering_controls->dithering_mode_table_size > 0 && 
+        ctk_dithering_controls->dithering_mode_table != NULL) {
+        ctk_dithering_controls->dithering_mode_table_size = 0;
+        free(ctk_dithering_controls->dithering_mode_table);
+    }
 
-    if (valid.type != ATTRIBUTE_TYPE_INT_BITS) {
+    ret = 
+    NvCtrlGetValidDisplayAttributeValues(ctk_dithering_controls->handle, 
+                                         ctk_dithering_controls->display_device_mask,
+                                         NV_CTRL_DITHERING_MODE,
+                                         &valid);
+        
+    if (ret != NvCtrlSuccess || valid.type != ATTRIBUTE_TYPE_INT_BITS) {
+        /* 
+         * We do not have valid information to build a mode table
+         * so we need to create default data for the placeholder menu.
+         */
+        ctk_dithering_controls->dithering_mode_table_size = 1;
+        ctk_dithering_controls->dithering_mode_table =
+            calloc(1, sizeof(ctk_dithering_controls->dithering_mode_table[0]));
+        if (ctk_dithering_controls->dithering_mode_table) {
+            ctk_dithering_controls->dithering_mode_table[0] = 
+                NV_CTRL_DITHERING_MODE_AUTO;
+        } else {
+            ctk_dithering_controls->dithering_mode_table_size = 0;
+        }
         return False;
     }
 
     /* count no. of supported modes */
+    mask = valid.u.bits.ints;
     while(mask) {
         mask = mask & (mask - 1);
         num_of_modes++;
@@ -893,6 +926,7 @@ static gboolean build_dithering_mode_table(CtkDitheringControls *ctk_dithering_c
     ctk_dithering_controls->dithering_mode_table =
         calloc(num_of_modes, sizeof(ctk_dithering_controls->dithering_mode_table[0]));
     if (!ctk_dithering_controls->dithering_mode_table) {
+        ctk_dithering_controls->dithering_mode_table_size = 0;
         return False;
     }
 
diff --git a/src/gtk+-2.x/ctkevent.c b/src/gtk+-2.x/ctkevent.c
index ca642ee..e174d46 100644
--- a/src/gtk+-2.x/ctkevent.c
+++ b/src/gtk+-2.x/ctkevent.c
@@ -323,6 +323,7 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class)
     MAKE_SIGNAL(NV_CTRL_GPU_PCIE_MAX_LINK_WIDTH);
     MAKE_SIGNAL(NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH);
     MAKE_SIGNAL(NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED);
+    MAKE_SIGNAL(NV_CTRL_GVO_AUDIO_BLANKING);
 #undef MAKE_SIGNAL
     
     /*
@@ -332,7 +333,7 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class)
      * knows about.
      */
 
-#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED
+#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_GVO_AUDIO_BLANKING
 #warning "There are attributes that do not emit signals!"
 #endif
 
diff --git a/src/gtk+-2.x/ctkhelp.c b/src/gtk+-2.x/ctkhelp.c
index 90ceca4..1ca7cd0 100644
--- a/src/gtk+-2.x/ctkhelp.c
+++ b/src/gtk+-2.x/ctkhelp.c
@@ -402,13 +402,16 @@ void ctk_help_finish(GtkTextBuffer *buffer)
         (buffer, CTK_HELP_SINGLE_SPACE_TAG, &start, &end);
 }
 
+gchar *ctk_help_create_reset_hardware_defaults_text(gchar *type, gchar *name)
+{
+    return g_strconcat("The Reset ", type, " Hardware Defaults button restores ",
+                       "all ", name, " settings to their default values.", NULL);
+}
+
 void ctk_help_reset_hardware_defaults(GtkTextBuffer *b, GtkTextIter *i,
-                                      char *name)
+                                      gchar *text)
 {
     ctk_help_heading(b, i, "Reset Hardware Defaults");
-    ctk_help_para(b, i, "The Reset Hardware Defaults button restores "
-                  "the %s settings to their default "
-                  "values.", name);
-
+    ctk_help_para(b, i, text);
 }
 
diff --git a/src/gtk+-2.x/ctkhelp.h b/src/gtk+-2.x/ctkhelp.h
index 6e16d34..1ca6a68 100644
--- a/src/gtk+-2.x/ctkhelp.h
+++ b/src/gtk+-2.x/ctkhelp.h
@@ -73,7 +73,8 @@ void ctk_help_heading (GtkTextBuffer *, GtkTextIter *, const gchar *, ...);
 void ctk_help_term    (GtkTextBuffer *, GtkTextIter *, const gchar *, ...);
 void ctk_help_finish  (GtkTextBuffer *);
 
-void ctk_help_reset_hardware_defaults(GtkTextBuffer *, GtkTextIter *, char *);
+void ctk_help_reset_hardware_defaults(GtkTextBuffer *, GtkTextIter *, gchar *);
+gchar *ctk_help_create_reset_hardware_defaults_text(gchar*, gchar *);
 
 
 #define CTK_HELP_TITLE_TAG                "title"
diff --git a/src/gtk+-2.x/ctkimagesliders.c b/src/gtk+-2.x/ctkimagesliders.c
index 2bc906c..afb2a7f 100644
--- a/src/gtk+-2.x/ctkimagesliders.c
+++ b/src/gtk+-2.x/ctkimagesliders.c
@@ -400,7 +400,6 @@ static void scale_value_received(GtkObject *object, gpointer arg1,
         scale = ctk_image_sliders->image_sharpening;
         if (event_struct->availability == FALSE) {
             gtk_widget_set_sensitive(scale, FALSE);
-            gtk_widget_hide(scale);
             g_object_set_data(G_OBJECT(CTK_SCALE(scale)->gtk_adjustment),
                               "attribute active",
                               GINT_TO_POINTER(0));
@@ -408,7 +407,6 @@ static void scale_value_received(GtkObject *object, gpointer arg1,
             setup_scale(ctk_image_sliders, NV_CTRL_IMAGE_SHARPENING,
                         ctk_image_sliders->image_sharpening);
             gtk_widget_set_sensitive(scale, TRUE);
-            gtk_widget_show(scale);
             g_object_set_data(G_OBJECT(CTK_SCALE(scale)->gtk_adjustment),
                               "attribute active",
                               GINT_TO_POINTER(1));
@@ -517,28 +515,22 @@ static void setup_scale(CtkImageSliders *ctk_image_sliders,
                       GINT_TO_POINTER(1));
 
         gtk_widget_set_sensitive(scale, TRUE);
-        gtk_widget_show(scale);
     } else {
         g_object_set_data(G_OBJECT(adj), "attribute active",
                       GINT_TO_POINTER(0));
 
         gtk_widget_set_sensitive(scale, FALSE);
-        gtk_widget_hide(scale);
     }
 
 } /* setup_scale() */
 
 
-
 /*
  * Updates the page to reflect the current configuration of
  * the display device.
  */
 void ctk_image_sliders_setup(CtkImageSliders *ctk_image_sliders)
 {
-    int active;
-
-
     if (!ctk_image_sliders) return;
 
     /* Update sliders */
@@ -558,15 +550,11 @@ void ctk_image_sliders_setup(CtkImageSliders *ctk_image_sliders)
     setup_scale(ctk_image_sliders, NV_CTRL_IMAGE_SHARPENING,
                 ctk_image_sliders->image_sharpening);
 
-    active =
-        get_scale_active(CTK_SCALE(ctk_image_sliders->digital_vibrance)) ||
-        get_scale_active(CTK_SCALE(ctk_image_sliders->overscan_compensation)) ||
-        get_scale_active(CTK_SCALE(ctk_image_sliders->image_sharpening));
-
-    if (!active) {
-        gtk_widget_hide(ctk_image_sliders->frame);
-    } else {
-        gtk_widget_show(ctk_image_sliders->frame);
-    }
+    gtk_widget_set_sensitive(ctk_image_sliders->digital_vibrance,
+        get_scale_active(CTK_SCALE(ctk_image_sliders->digital_vibrance)));
+    gtk_widget_set_sensitive(ctk_image_sliders->overscan_compensation,
+        get_scale_active(CTK_SCALE(ctk_image_sliders->overscan_compensation)));
+    gtk_widget_set_sensitive(ctk_image_sliders->image_sharpening,
+        get_scale_active(CTK_SCALE(ctk_image_sliders->image_sharpening)));
 
 } /* ctk_image_sliders_setup() */
diff --git a/src/gtk+-2.x/ctkscale.c b/src/gtk+-2.x/ctkscale.c
index 98946f1..ce0c924 100644
--- a/src/gtk+-2.x/ctkscale.c
+++ b/src/gtk+-2.x/ctkscale.c
@@ -212,11 +212,7 @@ GtkWidget* ctk_scale_new(GtkAdjustment *gtk_adjustment,
     
     frame = gtk_frame_new(NULL);
     gtk_box_pack_start(GTK_BOX(object), frame, TRUE, TRUE, 0);
-    
-    /* event box (for tooltips) */
-
-    ctk_scale->tooltip_widget = gtk_event_box_new();
-    gtk_container_add(GTK_CONTAINER(frame), ctk_scale->tooltip_widget);
+    ctk_scale->tooltip_widget = frame;
     
     /* hbox to contain slider and text box */
 
diff --git a/src/gtk+-2.x/ctkutils.c b/src/gtk+-2.x/ctkutils.c
index eb428c1..aad233a 100644
--- a/src/gtk+-2.x/ctkutils.c
+++ b/src/gtk+-2.x/ctkutils.c
@@ -134,7 +134,7 @@ GtkWidget *add_table_row_with_help_text(GtkWidget *table,
                                         const gfloat value_yalign,
                                         const gchar *value)
 {
-    GtkWidget *label, *eventbox;
+    GtkWidget *label;
 
     label = gtk_label_new(name);
     gtk_label_set_selectable(GTK_LABEL(label), TRUE);
@@ -147,13 +147,11 @@ GtkWidget *add_table_row_with_help_text(GtkWidget *table,
     else
         label = gtk_label_new(value);
     gtk_label_set_selectable(GTK_LABEL(label), TRUE);
-    eventbox = gtk_event_box_new();
     gtk_misc_set_alignment(GTK_MISC(label), value_xalign, value_yalign);
-    gtk_container_add(GTK_CONTAINER(eventbox), label);
-    gtk_table_attach(GTK_TABLE(table), eventbox, col+1, col+2, row, row + 1,
+    gtk_table_attach(GTK_TABLE(table), label, col+1, col+2, row, row + 1,
                      GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
     if ((help != NULL) || (ctk_config != NULL)) {
-        ctk_config_set_tooltip(ctk_config, eventbox, help);
+        ctk_config_set_tooltip(ctk_config, label, help);
     }
 
     return label;
diff --git a/src/gtk+-2.x/ctkwindow.c b/src/gtk+-2.x/ctkwindow.c
index fcecaec..1a45bdd 100644
--- a/src/gtk+-2.x/ctkwindow.c
+++ b/src/gtk+-2.x/ctkwindow.c
@@ -128,6 +128,9 @@ static void add_display_devices(CtkWindow *ctk_window, GtkTreeIter *iter,
 static void update_display_devices(GtkObject *object, gpointer arg1,
                                    gpointer user_data);
 
+static void ctk_window_destroyed(GtkObject *object, gpointer arg1,
+                                 gpointer user_data);
+
 
 static GObjectClass *parent_class;
 
@@ -200,6 +203,19 @@ static void ctk_window_real_destroy(GtkObject *object)
 
 
 
+/* 
+ * ctk_window_destroyed() - called when ctk_window destroyed.
+ */
+
+static void ctk_window_destroyed(GtkObject *object, gpointer arg1,
+                                 gpointer user_data)
+{
+    CtkWindow *ctk_window = CTK_WINDOW(object);
+    save_settings_and_exit(ctk_window);
+} /* ctk_window_destroyed() */
+
+
+
 /*
  * close_button_clicked() - called when the "Quit" button is clicked.
  */
@@ -1070,6 +1086,11 @@ GtkWidget *ctk_window_new(ParsedAttribute *p, ConfigProperties *conf,
                                        GTK_POLICY_AUTOMATIC);
     }
 
+    /* Add callback when window destroyed */
+
+    g_signal_connect(G_OBJECT(ctk_window), "destroy",
+                     G_CALLBACK(ctk_window_destroyed), (gpointer) ctk_window);
+    
     return GTK_WIDGET(object);
 
 } /* ctk_window_new() */
diff --git a/src/libXNVCtrl/NVCtrl.h b/src/libXNVCtrl/NVCtrl.h
index 95d7024..1c848d9 100644
--- a/src/libXNVCtrl/NVCtrl.h
+++ b/src/libXNVCtrl/NVCtrl.h
@@ -3242,7 +3242,23 @@
  */
 #define NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED                     385 /* R--GI */
 
-#define NV_CTRL_LAST_ATTRIBUTE NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED
+/*
+ * NV_CTRL_GVO_AUDIO_BLANKING - specifies whether the GVO device should delete
+ * audio ancillary data packets when frames are repeated.
+ *
+ * When a new frame is not ready in time, the current frame, including all
+ * ancillary data packets, is repeated.  When this data includes audio packets,
+ * this can result in stutters or clicks.  When this option is enabled, the GVO
+ * device will detect when frames are repeated, identify audio ancillary data
+ * packets, and mark them for deletion.
+ *
+ * This option is applied when the GVO device is bound.
+ */
+#define NV_CTRL_GVO_AUDIO_BLANKING                              386 /* RW- */
+#define NV_CTRL_GVO_AUDIO_BLANKING_DISABLE                        0
+#define NV_CTRL_GVO_AUDIO_BLANKING_ENABLE                         1
+
+#define NV_CTRL_LAST_ATTRIBUTE NV_CTRL_GVO_AUDIO_BLANKING
 
 /**************************************************************************/
 
diff --git a/src/parse.c b/src/parse.c
index ff1acad..0e9ec28 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -245,6 +245,7 @@ AttributeTableEntry attributeTable[] = {
     { "GvoFullRangeColor",               NV_CTRL_GVO_FULL_RANGE_COLOR,                 I,     "Allow full range color data [4-1019].  If disabled, color data is clamped to [64-940]." },
     { "IsGvoDisplay",                    NV_CTRL_IS_GVO_DISPLAY,                       N|D,   "Returns whether or not the given display device is driven by the GVO device." },
     { "GvoEnableRGBData",                NV_CTRL_GVO_ENABLE_RGB_DATA,                  I,     "Indicates that RGB data is being sent via a PASSTHU mode." },
+    { "GvoAudioBlanking",                NV_CTRL_GVO_AUDIO_BLANKING,                   I,     "Indicates that the GVO device should drop audio ancillary data packets when frames are repeated." },
     { "GviNumJacks",                          NV_CTRL_GVI_NUM_JACKS,                            I|N, "Returns the number of input (BNC) jacks on a GVI device that can read video streams." },
     { "GviMaxLinksPerStream",                 NV_CTRL_GVI_MAX_LINKS_PER_STREAM,                 I|N, "Returns the maximum number of links that can make up a stream." },
     { "GviDetectedChannelBitsPerComponent",   NV_CTRL_GVI_DETECTED_CHANNEL_BITS_PER_COMPONENT,  I|N, "Returns the detected bits per component on the given jack+channel of the GVI device.  The jack+channel must be passed through via the display mask param where the jack number is in the lower 16 bits and the channel number is in the upper 16 bits." },
@@ -373,7 +374,7 @@ AttributeTableEntry attributeTable[] = {
  * about.
  */
 
-#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED
+#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_GVO_AUDIO_BLANKING
 #warning "Have you forgotten to add a new integer attribute to attributeTable?"
 #endif
 
diff --git a/version.mk b/version.mk
index 9cf35b0..fe9f882 100644
--- a/version.mk
+++ b/version.mk
@@ -1 +1 @@
-NVIDIA_VERSION = 295.09
+NVIDIA_VERSION = 295.17