Merge lp:~dsiuchninski/ubuntu/precise/nvidia-settings/nvidia-settings into lp:ubuntu/precise/nvidia-settings

[Donald Siuchninski]

Fixed a typo in the short package description.

Originally: "Tool of configuring the NVIDIA graphics driver"
Changed: "Tool for configuring the NVIDIA graphics driver"

=== modified file 'Makefile'
--- Makefile	2012-02-18 10:21:04 +0000
+++ Makefile	2012-07-30 04:30:25 +0000
@@ -2,7 +2,7 @@
 # nvidia-settings: A tool for configuring the NVIDIA X driver on Unix
 # and Linux systems.
 #
-# Copyright (C) 2008 NVIDIA Corporation.
+# Copyright (C) 2008-2012 NVIDIA Corporation.
 #
 # This program is free software; you can redistribute it and/or modify it
 # under the terms and conditions of the GNU General Public License,
@@ -17,201 +17,10 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses>.
 #
 
-
-##############################################################################
-# include common variables and functions
-##############################################################################
-
-include utils.mk
-
-
-##############################################################################
-# The calling Makefile may export any of the following variables; we
-# assign default values if they are not exported by the caller
-##############################################################################
-
-ifndef X_LDFLAGS
-  ifeq ($(TARGET_OS)-$(TARGET_ARCH),Linux-x86_64)
-    X_LDFLAGS          = -L/usr/X11R6/lib64
-  else
-    X_LDFLAGS          = -L/usr/X11R6/lib
-  endif
-endif
-
-X_CFLAGS              ?=
-
-GL_INCLUDE_PATH       ?= /usr/include
-
-PKG_CONFIG            ?= pkg-config
-
-ifndef GTK_CFLAGS
-  GTK_CFLAGS          := $(shell $(PKG_CONFIG) --cflags gtk+-2.0)
-endif
-
-ifndef GTK_LDFLAGS
-  GTK_LDFLAGS         := $(shell $(PKG_CONFIG) --libs gtk+-2.0)
-endif
-
-
-##############################################################################
-# The XF86Config-parser, libXNVCtrl, and common-utils directories may
-# be in one of two places: either elsewhere in the driver source tree
-# when building nvidia-settings as part of the NVIDIA driver build (in
-# which case, XNVCTRL_DIR, XNVCTRL_ARCHIVE, XCONFIG_PARSER_DIR and
-# COMMON_UTILS_DIR should be defined by the calling makefile), or
-# directly in the source directory when building from the
-# nvidia-settings source tarball (in which case, the below conditional
-# assignments should be used)
-##############################################################################
-
-XNVCTRL_DIR           ?= src/libXNVCtrl
-XNVCTRL_ARCHIVE       ?= $(XNVCTRL_DIR)/libXNVCtrl.a
-XCONFIG_PARSER_DIR    ?= src/XF86Config-parser
-COMMON_UTILS_DIR      ?= src/common-utils
-
-##############################################################################
-# assign variables
-##############################################################################
-
-NVIDIA_SETTINGS = $(OUTPUTDIR)/nvidia-settings
-
-NVIDIA_SETTINGS_PROGRAM_NAME = "nvidia-settings"
-
-NVIDIA_SETTINGS_VERSION := $(NVIDIA_VERSION)
-
-CFLAGS += $(X_CFLAGS)
-
-ifeq ($(TARGET_OS),SunOS)
-  LDFLAGS += -Wl,-rpath=/usr/X11R6/lib
-endif
-
-LDFLAGS += $(X_LDFLAGS)
-
-# Some older Linux distributions do not have the dynamic library
-# libXxf86vm.so, though some newer Linux distributions do not have the
-# static library libXxf86vm.a.  Statically link against libXxf86vm
-# when building nvidia-settings within the NVIDIA driver build, but
-# dynamically link against libXxf86vm in the public builds.
-ifdef NV_LINK_LIBXXF86VM_STATICALLY
-    LDFLAGS += -Wl,-Bstatic -lXxf86vm -Wl,-Bdynamic
-else
-    LDFLAGS += -lXxf86vm
-endif
-
-LDFLAGS += -lX11 -lXext -lm
-LDFLAGS += $(GTK_LDFLAGS)
-LDFLAGS += $(LIBDL_LDFLAGS)
-
-MANPAGE_GZIP ?= 1
-
-MANPAGE_gzipped 	= $(OUTPUTDIR)/nvidia-settings.1.gz
-MANPAGE_not_gzipped 	= $(OUTPUTDIR)/nvidia-settings.1
-ifeq ($(MANPAGE_GZIP),1)
-  MANPAGE     = $(MANPAGE_gzipped)
-else
-  MANPAGE     = $(MANPAGE_not_gzipped)
-endif
-GEN_MANPAGE_OPTS   = $(OUTPUTDIR)/gen-manpage-opts
-OPTIONS_1_INC      = $(OUTPUTDIR)/options.1.inc
-
-# Include all the source lists; dist-files.mk will define SRC
-include dist-files.mk
-
-include $(XCONFIG_PARSER_DIR)/src.mk
-SRC        += $(addprefix $(XCONFIG_PARSER_DIR)/,$(XCONFIG_PARSER_SRC))
-
-include $(COMMON_UTILS_DIR)/src.mk
-SRC        += $(addprefix $(COMMON_UTILS_DIR)/,$(COMMON_UTILS_SRC))
-
-SRC        += $(STAMP_C)
-
-OBJS        = $(call BUILD_OBJECT_LIST,$(SRC))
-
-CFLAGS     += -I src
-CFLAGS     += -I src/image_data
-CFLAGS     += -I $(XNVCTRL_DIR)
-CFLAGS     += -I $(XCONFIG_PARSER_DIR)/..
-CFLAGS     += -I src/libXNVCtrlAttributes
-CFLAGS     += -I src/xpm_data
-CFLAGS     += -I src/gtk+-2.x
-CFLAGS     += -I $(COMMON_UTILS_DIR)
-CFLAGS     += -I $(OUTPUTDIR)
-CFLAGS     += -DPROGRAM_NAME=\"nvidia-setttings\"
-
-$(call BUILD_OBJECT_LIST,$(GTK_SRC)): CFLAGS += $(GTK_CFLAGS)
-
-
-##############################################################################
-# build rules
-##############################################################################
-
-.PNONY: all install NVIDIA_SETTINGS_install MANPAGE_install clean clobber
-
-all: $(NVIDIA_SETTINGS) $(MANPAGE)
-
-install: NVIDIA_SETTINGS_install MANPAGE_install
-
-NVIDIA_SETTINGS_install: $(NVIDIA_SETTINGS)
-	$(MKDIR) $(bindir)
-	$(INSTALL) $(INSTALL_BIN_ARGS) $< $(bindir)/$(notdir $<)
-
-MANPAGE_install: $(MANPAGE)
-	$(MKDIR) $(mandir)
-	$(INSTALL) $(INSTALL_BIN_ARGS) $< $(mandir)/$(notdir $<)
-
-$(NVIDIA_SETTINGS): $(OBJS) $(XNVCTRL_ARCHIVE)
-	$(call quiet_cmd,LINK) -o $@ $(OBJS) $(XNVCTRL_ARCHIVE) \
-		$(CFLAGS) $(LDFLAGS) $(BIN_LDFLAGS)
-	$(call quiet_cmd,STRIP_CMD) $@
-
-# define the rule to build each object file
-$(foreach src,$(SRC),$(eval $(call DEFINE_OBJECT_RULE,CC,$(src))))
-
-# define the rule to generate $(STAMP_C)
-$(eval $(call DEFINE_STAMP_C_RULE, $(OBJS),$(NVIDIA_SETTINGS_PROGRAM_NAME)))
-
-clean clobber:
-	rm -rf $(NVIDIA_SETTINGS) $(MANPAGE) *~ $(STAMP_C) \
-		$(OUTPUTDIR)/*.o $(OUTPUTDIR)/*.d \
-		$(GEN_MANPAGE_OPTS) $(OPTIONS_1_INC)
-
-
-##############################################################################
-# Documentation
-##############################################################################
-
-AUTO_TEXT = ".\\\" WARNING: THIS FILE IS AUTO-GENERATED!  Edit $< instead."
-
-doc: $(MANPAGE)
-
-GEN_MANPAGE_OPTS_SRC = src/gen-manpage-opts.c
-
-BUILD_MANPAGE_OBJECT_LIST = \
-	$(patsubst %.o,%.manpage.o,$(call BUILD_OBJECT_LIST,$(1)))
-
-GEN_MANPAGE_OPTS_OBJS = \
-	$(call BUILD_MANPAGE_OBJECT_LIST,$(GEN_MANPAGE_OPTS_SRC))
-
-$(GEN_MANPAGE_OPTS): $(GEN_MANPAGE_OPTS_OBJS)
-	$(call quiet_cmd,HOST_LINK) $(GEN_MANPAGE_OPTS_OBJS) -o $@ \
-		$(HOST_CFLAGS) $(HOST_LDFLAGS) $(HOST_BIN_LDFLAGS)
-
-# define a rule to build each GEN_MANPAGE_OPTS object file
-$(foreach src,$(GEN_MANPAGE_OPTS_SRC),\
-	$(eval $(call DEFINE_OBJECT_RULE_WITH_OBJECT_NAME,HOST_CC,$(src),\
-		$(call BUILD_MANPAGE_OBJECT_LIST,$(src)))))
-
-$(OPTIONS_1_INC): $(GEN_MANPAGE_OPTS)
-	@./$< > $@
-
-$(MANPAGE_not_gzipped): doc/nvidia-settings.1.m4 $(OPTIONS_1_INC)
-	$(call quiet_cmd,M4) \
-	  -D__HEADER__=$(AUTO_TEXT) \
-	  -D__BUILD_OS__=$(TARGET_OS) \
-	  -D__VERSION__=$(NVIDIA_VERSION) \
-	  -D__DATE__="`$(DATE) +%F`" \
-	  -I $(OUTPUTDIR) \
-	  $< > $@
-
-$(MANPAGE_gzipped): $(MANPAGE_not_gzipped)
-	$(GZIP_CMD) -9f < $< > $@
+.PHONY: all clean clobber install
+
+all clean clobber install:
+	@$(MAKE) -C src  $@
+	@$(MAKE) -C samples $@
+	@$(MAKE) -C doc $@
+

=== modified file 'debian/changelog'
--- debian/changelog	2012-03-30 14:23:10 +0000
+++ debian/changelog	2012-07-30 04:30:25 +0000
@@ -1,3 +1,26 @@
+nvidia-settings (302.17-0ubuntu3) precise; urgency=low
+
+  * debian/control: Changed a typo in the package description; changed 'of' to 'for' (LP: #306178)
+
+ -- Donald Siuchninski <[e-mail]>  Sun, 29 Jul 2012 22:19:32 -0500
+
+nvidia-settings (302.17-0ubuntu2) quantal; urgency=low
+
+  * Rename build to build-arch and make build depend on build-arch.
+
+ -- Adam Conrad <[e-mail]>  Mon, 02 Jul 2012 17:18:24 -0600
+
+nvidia-settings (302.17-0ubuntu1) quantal; urgency=low
+
+  * New upstream release.
+  * Refresh 04_nvidia-settings_natty_ftbs.patch.
+  * Drop 02_nvidia-settings-format-string.patch which
+    is now upstream.
+  * debian/rules:
+    - Make sure to install the new sources correctly.
+
+ -- Alberto Milone <[e-mail]>  Mon, 25 Jun 2012 16:31:12 +0200
+
 nvidia-settings (295.33-0ubuntu1) precise; urgency=low
 
   * New upstream release.

=== modified file 'debian/control'
--- debian/control	2011-10-17 17:35:57 +0000
+++ debian/control	2012-07-30 04:30:25 +0000
@@ -15,7 +15,7 @@
 Depends: python-gtk2, pkg-config, screen-resolution-extra (>= 0.12), ${shlibs:Depends}
 Conflicts: libxnvctrl-dev
 Replaces: libxnvctrl-dev
-Description:  Tool of configuring the NVIDIA graphics driver
+Description:  Tool for configuring the NVIDIA graphics driver
  The nvidia-settings utility is a tool for configuring the NVIDIA
  Linux graphics driver.  It operates by communicating with the NVIDIA
  X driver, querying and updating state as appropriate.  This

=== modified file 'debian/patches/04_nvidia-settings_natty_ftbs.patch'
--- debian/patches/04_nvidia-settings_natty_ftbs.patch	2010-11-21 13:02:24 +0000
+++ debian/patches/04_nvidia-settings_natty_ftbs.patch	2012-07-30 04:30:25 +0000
@@ -1,8 +1,7 @@
-diff --git a/Makefile b/Makefile
-index 0b4d202..bb9781f 100644
---- a/Makefile
-+++ b/Makefile
-@@ -53,7 +53,7 @@ ifndef GTK_CFLAGS
+diff -Nurp nvidia-settings.orig/src/Makefile nvidia-settings/src/Makefile
+--- nvidia-settings.orig/src/Makefile	2012-05-02 17:06:02.000000000 +0200
++++ nvidia-settings/src/Makefile	2012-05-17 09:09:32.341638054 +0200
+@@ -51,7 +51,7 @@ ifndef GTK_CFLAGS
  endif
  
  ifndef GTK_LDFLAGS

=== modified file 'debian/patches/series'
--- debian/patches/series	2011-08-04 17:43:17 +0000
+++ debian/patches/series	2012-07-30 04:30:25 +0000
@@ -1,4 +1,3 @@
 01_allow_dark_themes.dpatch
-02_nvidia-settings-format-string.patch
 04_nvidia-settings_natty_ftbs.patch
 05_add_polkit_support.patch

=== modified file 'debian/rules'
--- debian/rules	2011-08-05 14:19:18 +0000
+++ debian/rules	2012-07-30 04:30:25 +0000
@@ -58,12 +58,12 @@
                         debian/$$i.in > debian/$$i;      \
         done
 
-
-build: regen-from-templates
+build: build-arch
+build-arch: regen-from-templates
 	dh_quilt_patch
 
 	$(MAKE) -C src/libXNVCtrl EXTINCSRC=/usr/include/X11/extensions \
-		CFLAGS="$(CFLAGS) -fPIC"
+		CFLAGS="$(CFLAGS) -fPIC" PREFIX=$(PKG_libdir)
 	$(MAKE)
 	dh build
 
@@ -82,8 +82,8 @@
 	dh clean
 
 binary-arch:
-	dh_auto_install -- prefix=$(CURDIR)/debian/$(PKG_name)$(PKG_libdir)
-	#$(MAKE) prefix=$(CURDIR)/debian/$(PKG_name)$(PKG_libdir) install
+	#dh_auto_install -- prefix=$(CURDIR)/debian/$(PKG_name)$(PKG_libdir)
+	$(MAKE) PREFIX=$(CURDIR)/debian/$(PKG_name)$(PKG_libdir) install
 	dh_install -p$(PKG_name) src/libXNVCtrl/libXNVCtrl.a    "$(PKG_libdir)"
 	dh_install -p$(PKG_name) src/libXNVCtrl/NVCtrl.h        "$(PKG_includedir)/NVCtrl"
 	dh_install -p$(PKG_name) src/libXNVCtrl/NVCtrlLib.h     "$(PKG_includedir)/NVCtrl"
@@ -109,5 +109,8 @@
 	mv $(CURDIR)/debian/$(PKG_name)$(PKG_libdir)/share/man/man1/nvidia-settings.1.gz \
 	$(CURDIR)/debian/$(PKG_name)$(PKG_libdir)/share/man/man1/alt-$(PKG_name).1.gz
 
+override_dh_usrlocal:
+	rm -Rf $(CURDIR)/debian/$(PKG_name)/usr/local
+
 %:
 	dh $@ --with quilt

=== removed file 'dist-files.mk'
--- dist-files.mk	2012-02-18 10:21:04 +0000
+++ dist-files.mk	1970-01-01 00:00:00 +0000
@@ -1,60 +0,0 @@
-#
-# nvidia-settings: A tool for configuring the NVIDIA X driver on Unix
-# and Linux systems.
-#
-# Copyright (C) 2008 NVIDIA Corporation.
-#
-# This program is free software; you can redistribute it and/or modify it
-# under the terms and conditions of the GNU General Public License,
-# version 2, as published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
-# more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses>.
-#
-
-##############################################################################
-# define the list of files that should be distributed in the
-# nvidia-settings tarball; this is used by the NVIDIA driver build
-# when packaging the tarball, and by the nvidia-settings makefile when
-# building nvidia-settings.
-#
-# Defines SRC, EXTRA_DIST, and DIST_FILES
-##############################################################################
-
-SRC        :=
-EXTRA_DIST := COPYING dist-files.mk
-
-include src/src.mk
-SRC        += $(addprefix src/,$(SRC_SRC))
-EXTRA_DIST += $(addprefix src/,$(SRC_EXTRA_DIST))
-
-include src/image_data/src.mk
-SRC        += $(addprefix src/image_data/,$(IMAGE_DATA_SRC))
-EXTRA_DIST += $(addprefix src/image_data/,$(IMAGE_DATA_EXTRA_DIST))
-
-include src/libXNVCtrlAttributes/src.mk
-SRC        += $(addprefix src/libXNVCtrlAttributes/,$(LIB_XNVCTRL_ATTRIBUTES_SRC))
-EXTRA_DIST += $(addprefix src/libXNVCtrlAttributes/,$(LIB_XNVCTRL_ATTRIBUTES_EXTRA_DIST))
-
-include src/xpm_data/src.mk
-SRC        += $(addprefix src/xpm_data/,$(LIB_XPM_DATA_SRC))
-EXTRA_DIST += $(addprefix src/xpm_data/,$(LIB_XPM_DATA_EXTRA_DIST))
-
-include src/gtk+-2.x/src.mk
-SRC        += $(addprefix src/gtk+-2.x/,$(GTK_SRC))
-EXTRA_DIST += $(addprefix src/gtk+-2.x/,$(GTK_EXTRA_DIST))
-
-include doc/src.mk
-SRC        += $(addprefix doc/,$(DOC_SRC))
-EXTRA_DIST += $(addprefix doc/,$(DOC_EXTRA_DIST))
-
-include samples/src.mk
-SRC        += $(addprefix samples/,$(SAMPLES_SRC))
-EXTRA_DIST += $(addprefix samples/,$(SAMPLES_EXTRA_DIST))
-
-DIST_FILES := $(SRC) $(EXTRA_DIST)

=== added file 'doc/Makefile'
--- doc/Makefile	1970-01-01 00:00:00 +0000
+++ doc/Makefile	2012-07-30 04:30:25 +0000
@@ -0,0 +1,115 @@
+#
+# nvidia-settings: A tool for configuring the NVIDIA X driver on Unix
+# and Linux systems.
+#
+# Copyright (C) 2008-2012 NVIDIA Corporation.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms and conditions of the GNU General Public License,
+# version 2, as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses>.
+#
+
+
+##############################################################################
+# include common variables and functions
+##############################################################################
+
+UTILS_MK_DIR ?= ..
+
+include $(UTILS_MK_DIR)/utils.mk
+
+
+##############################################################################
+# The common-utils directory may be in one of two places: either
+# elsewhere in the driver source tree when building nvidia-settings as
+# part of the NVIDIA driver build (in which case, COMMON_UTILS_DIR
+# should be defined by the calling makefile), or directly in the
+# source directory when building from the nvidia-settings source
+# tarball (in which case, the below conditional assignments should be
+# used)
+##############################################################################
+
+COMMON_UTILS_DIR      ?= ../src/common-utils
+
+
+##############################################################################
+# assign variables
+##############################################################################
+
+MANPAGE_GZIP ?= 1
+
+MANPAGE_gzipped         = $(OUTPUTDIR)/nvidia-settings.1.gz
+MANPAGE_not_gzipped 	= $(OUTPUTDIR)/nvidia-settings.1
+ifeq ($(MANPAGE_GZIP),1)
+  MANPAGE               = $(MANPAGE_gzipped)
+else
+  MANPAGE               = $(MANPAGE_not_gzipped)
+endif
+GEN_MANPAGE_OPTS        = $(OUTPUTDIR)/gen-manpage-opts
+OPTIONS_1_INC           = $(OUTPUTDIR)/options.1.inc
+
+CFLAGS     += -I $(COMMON_UTILS_DIR)
+CFLAGS     += -I ../src/libXNVCtrlAttributes
+
+
+##############################################################################
+# build rules
+##############################################################################
+
+.PNONY: all install MANPAGE_install clean clobber
+
+all: $(MANPAGE)
+
+install: MANPAGE_install
+
+MANPAGE_install: $(MANPAGE)
+	$(MKDIR) $(MANDIR)
+	$(INSTALL) $(INSTALL_BIN_ARGS) $< $(MANDIR)/$(notdir $<)
+
+clean clobber:
+	rm -rf $(MANPAGE) *~ $(OUTPUTDIR)/*.o $(OUTPUTDIR)/*.d \
+		$(GEN_MANPAGE_OPTS) $(OPTIONS_1_INC)
+
+
+##############################################################################
+# Documentation
+##############################################################################
+
+AUTO_TEXT = ".\\\" WARNING: THIS FILE IS AUTO-GENERATED!  Edit $< instead."
+
+doc: $(MANPAGE)
+
+GEN_MANPAGE_OPTS_SRC  = ../src/gen-manpage-opts.c
+GEN_MANPAGE_OPTS_SRC += $(COMMON_UTILS_DIR)/gen-manpage-opts-helper.c
+
+GEN_MANPAGE_OPTS_OBJS = $(call BUILD_OBJECT_LIST,$(GEN_MANPAGE_OPTS_SRC))
+
+$(foreach src, $(GEN_MANPAGE_OPTS_SRC), \
+    $(eval $(call DEFINE_OBJECT_RULE,HOST_CC,$(src))))
+
+$(GEN_MANPAGE_OPTS): $(GEN_MANPAGE_OPTS_OBJS)
+	$(call quiet_cmd,HOST_LINK) \
+	    $(HOST_CFLAGS) $(HOST_LDFLAGS) $(HOST_BIN_LDFLAGS) $^ -o $@
+
+$(OPTIONS_1_INC): $(GEN_MANPAGE_OPTS)
+	@./$< > $@
+
+$(MANPAGE_not_gzipped): nvidia-settings.1.m4 $(OPTIONS_1_INC) $(VERSION_MK)
+	$(call quiet_cmd,M4) \
+	  -D__HEADER__=$(AUTO_TEXT) \
+	  -D__BUILD_OS__=$(TARGET_OS) \
+	  -D__VERSION__=$(NVIDIA_VERSION) \
+	  -D__DATE__="`$(DATE) +%F`" \
+	  -I $(OUTPUTDIR) \
+	  $< > $@
+
+$(MANPAGE_gzipped): $(MANPAGE_not_gzipped)
+	$(GZIP_CMD) -9f < $< > $@

=== modified file 'doc/nvidia-settings.png'
Binary files doc/nvidia-settings.png	2010-06-27 18:59:46 +0000 and doc/nvidia-settings.png	2012-07-30 04:30:25 +0000 differ
=== modified file 'doc/src.mk'
--- doc/src.mk	2010-06-27 18:59:46 +0000
+++ doc/src.mk	2012-07-30 04:30:25 +0000
@@ -10,3 +10,5 @@
 DOC_EXTRA_DIST += nvidia-settings.desktop
 DOC_EXTRA_DIST += nvidia-settings.png
 DOC_EXTRA_DIST += src.mk
+
+DOC_DIST_FILES := $(DOC_SRC) $(DOC_EXTRA_DIST)
\ No newline at end of file

=== added file 'doc/version.mk'
--- doc/version.mk	1970-01-01 00:00:00 +0000
+++ doc/version.mk	2012-07-30 04:30:25 +0000
@@ -0,0 +1,1 @@
+NVIDIA_VERSION = 302.17

=== modified file 'samples/Makefile'
--- samples/Makefile	2012-02-18 10:21:04 +0000
+++ samples/Makefile	2012-07-30 04:30:25 +0000
@@ -55,7 +55,7 @@
 
 LDFLAGS               += $(X_LDFLAGS)
 LDFLAGS               += -L $(LIBXNVCTRL_DIR)
-LDFLAGS               += -lXNVCtrl -lXext -lX11
+LIBS                  += -lXNVCtrl -lXext -lX11
 
 
 ##############################################################################
@@ -76,7 +76,7 @@
 # build rules
 ##############################################################################
 
-.PHONY: all clean clobber
+.PHONY: all clean clobber install
 
 # define the rule to build each object file
 $(foreach src, $(SAMPLE_SOURCES), $(eval $(call DEFINE_OBJECT_RULE,CC,$(src))))
@@ -84,7 +84,7 @@
 # define the rule to link each sample app from its corresponding object file
 define link_sample_from_object
   $$(OUTPUTDIR)/$(1:.c=): $$(call BUILD_OBJECT_LIST,$(1))
-	$$(call quiet_cmd,LINK) $$(CFLAGS) -o $$@ $$< $$(LDFLAGS) $$(BIN_LDFLAGS)
+	$$(call quiet_cmd,LINK) $$(CFLAGS) $$(LDFLAGS) $$(BIN_LDFLAGS) -o $$@ $$< $$(LIBS)
   all:: $$(OUTPUTDIR)/$(1:.c=)
   SAMPLES += $$(OUTPUTDIR)/$(1:.c=)
 endef
@@ -93,3 +93,7 @@
 
 clean clobber:
 	rm -rf *~ $(OUTPUTDIR)/*.o $(OUTPUTDIR)/*.d $(SAMPLES)
+
+install:
+	@# don't install samples, this is just to satisfy the top-level
+	@# recursion rule

=== modified file 'samples/nv-control-dpy.c'
--- samples/nv-control-dpy.c	2010-06-27 18:59:46 +0000
+++ samples/nv-control-dpy.c	2012-07-30 04:30:25 +0000
@@ -53,6 +53,28 @@
 
 
 
+static void print_display_name(Display *dpy, int target_id, int attr,
+                               char *name)
+{
+    Bool ret;
+    char *str;
+
+    ret = XNVCTRLQueryTargetStringAttribute(dpy,
+                                            NV_CTRL_TARGET_TYPE_DISPLAY,
+                                            target_id, 0,
+                                            attr,
+                                            &str);
+    if (!ret) {
+        printf("    %18s : N/A\n", name);
+        return;
+    }
+
+    printf("    %18s : %s\n", name, str);
+    XFree(str);
+}
+
+
+
 
 int main(int argc, char *argv[])
 {
@@ -363,8 +385,48 @@
         
         XFree(str);
     }
-    
-    
+
+
+    /*
+     * query the MetaModes for the X screen, using
+     * NV_CTRL_BINARY_DATA_METAMODES_VERSION_2.
+     */
+
+    else if (strcmp(argv[1], "--print-metamodes-version2") == 0) {
+
+        /* get list of metamodes */
+
+        ret = XNVCTRLQueryBinaryData(dpy, screen, 0, // n/a
+                                     NV_CTRL_BINARY_DATA_METAMODES_VERSION_2,
+                                     (void *) &str, &len);
+
+        if (!ret) {
+            fprintf(stderr, "Failed to query MetaModes.\n\n");
+            return 1;
+        }
+
+        /*
+         * the returned data is in the form:
+         *
+         *   "MetaMode 1\0MetaMode 2\0MetaMode 3\0Last MetaMode\0\0"
+         *
+         * so walk from one "\0" to the next to print each MetaMode.
+         */
+
+        printf("MetaModes:\n");
+
+        start = str;
+        for (j = 0; j < len; j++) {
+            if (str[j] == '\0') {
+                printf("  %s\n", start);
+                start = &str[j+1];
+            }
+        }
+
+        XFree(str);
+    }
+
+
     /*
      * query the currently in use MetaMode.  Note that an alternative
      * way to accomplish this is to use XRandR to query the current
@@ -387,8 +449,32 @@
 
         XFree(str);
     }
-    
-    
+
+
+    /*
+     * query the currently in use MetaMode.  Note that an alternative
+     * way to accomplish this is to use XRandR to query the current
+     * mode's refresh rate, and then match the refresh rate to the id
+     * reported in the returned NV_CTRL_BINARY_DATA_METAMODES_VERSION_2 data.
+     */
+
+    else if (strcmp(argv[1], "--print-current-metamode-version2") == 0) {
+
+        ret = XNVCTRLQueryStringAttribute(dpy, screen, mask,
+                                          NV_CTRL_STRING_CURRENT_METAMODE_VERSION_2,
+                                          &str);
+
+        if (!ret) {
+            fprintf(stderr, "Failed to query the current MetaMode.\n\n");
+            return 1;
+        }
+
+        printf("current metamode: \"%s\"\n\n", str);
+
+        XFree(str);
+    }
+
+
     /*
      * add the given MetaMode to X screen's list of MetaModes, using
      * NV_CTRL_STRING_OPERATION_ADD_METAMODE; example MetaMode string:
@@ -791,46 +877,45 @@
     
     
     /*
-     * query the TwinViewXineramaInfoOrder
+     * query the nvidiaXineramaInfoOrder
      */
     
-    else if (strcmp(argv[1], "--query-twinview-xinerama-info-order") == 0) {
+    else if (strcmp(argv[1], "--query-nvidia-xinerama-info-order") == 0) {
         
         ret = XNVCTRLQueryTargetStringAttribute
             (dpy, NV_CTRL_TARGET_TYPE_X_SCREEN, screen, 0,
-             NV_CTRL_STRING_TWINVIEW_XINERAMA_INFO_ORDER, &str);
+             NV_CTRL_STRING_NVIDIA_XINERAMA_INFO_ORDER, &str);
         
         if (!ret) {
-            fprintf(stderr, "Failed to query "
-                    "TwinViewXineramaInfoOrder.\n\n");
+            fprintf(stderr, "Failed to query nvidiaXineramaInfoOrder.\n\n");
             return 1;
         }
         
-        printf("TwinViewXineramaInfoOrder: %s\n\n", str);
+        printf("nvidiaXineramaInfoOrder: %s\n\n", str);
     }
     
     
     /*
-     * assign the TwinViewXineramaInfoOrder
+     * assign the nvidiaXineramaInfoOrder
      */
     
-    else if ((strcmp(argv[1], "--assign-twinview-xinerama-info-order")== 0)
+    else if ((strcmp(argv[1], "--assign-nvidia-xinerama-info-order")== 0)
              && argv[2]) {
         
         ret = XNVCTRLSetStringAttribute
             (dpy,
              screen,
              0,
-             NV_CTRL_STRING_TWINVIEW_XINERAMA_INFO_ORDER,
+             NV_CTRL_STRING_NVIDIA_XINERAMA_INFO_ORDER,
              argv[2]);
         
         if (!ret) {
             fprintf(stderr, "Failed to assign "
-                    "TwinViewXineramaInfoOrder = \"%s\".\n\n", argv[2]);
+                    "nvidiaXineramaInfoOrder = \"%s\".\n\n", argv[2]);
             return 1;
         }
         
-        printf("assigned TwinViewXineramaInfoOrder: \"%s\"\n\n",
+        printf("assigned nvidiaXineramaInfoOrder: \"%s\"\n\n",
                argv[2]);
     }
 
@@ -1163,7 +1248,54 @@
         printf("The id of the new MetaMode is %d; use xrandr to "
                "switch to it.\n\n", id);
     }
-    
+
+
+    /* Display all names each display device goes by
+     */
+    else if (strcmp(argv[1], "--print-display-names") == 0) {
+        unsigned int *pData;
+        int len, i;
+
+        printf("Display Device Information:\n");
+
+        ret = XNVCTRLQueryTargetBinaryData(dpy,
+                                           NV_CTRL_TARGET_TYPE_GPU,
+                                           0,
+                                           0,
+                                           NV_CTRL_BINARY_DATA_DISPLAY_TARGETS,
+                                           (unsigned char **) &pData,
+                                           &len);
+        if (!ret) {
+            fprintf(stderr, "Failed to query number of display devices.\n\n");
+            return 1;
+        }
+
+        printf("  number of display devices: %d\n", pData[0]);
+
+        for (i = 1; i <= pData[0]; i++) {
+
+            printf("\n  Display Device: %d\n", pData[i]);
+
+            print_display_name(dpy, pData[i],
+                               NV_CTRL_STRING_DISPLAY_NAME_TYPE_BASENAME,
+                               "Type Basename");
+            print_display_name(dpy, pData[i],
+                               NV_CTRL_STRING_DISPLAY_NAME_TYPE_ID,
+                               "Type ID");
+            print_display_name(dpy, pData[i],
+                               NV_CTRL_STRING_DISPLAY_NAME_DP_GUID,
+                               "DP GUID");
+            print_display_name(dpy, pData[i],
+                               NV_CTRL_STRING_DISPLAY_NAME_EDID_HASH,
+                               "EDID HASH");
+            print_display_name(dpy, pData[i],
+                               NV_CTRL_STRING_DISPLAY_NAME_TARGET_INDEX,
+                               "Target Index");
+            print_display_name(dpy, pData[i],
+                               NV_CTRL_STRING_DISPLAY_NAME_RANDR,
+                               "RANDR");
+        }
+    }
 
     /*
      * print help information
@@ -1204,6 +1336,9 @@
         printf("  --print-metamodes: print the current MetaModes for the "
                "X screen\n\n");
 
+        printf("  --print-metamodes-version2: print the current MetaModes for "
+               "the X screen with extended information\n\n");
+
         printf("  --add-metamode [metamode]: add the specified "
                "MetaMode to the X screen's list of MetaModes.\n\n");
         
@@ -1212,7 +1347,10 @@
 
         printf("  --print-current-metamode: print the current MetaMode.\n\n");
 
-        
+        printf("  --print-current-metamode-version2: print the current "
+               "MetaMode with extended information.\n\n");
+
+
         printf(" Misc options:\n\n");
         
         printf("  --get-valid-freq-ranges: query the valid frequency "
@@ -1232,11 +1370,11 @@
         
         printf("  --probe-dpys: probe GPUs for new display devices\n\n");
         
-        printf("  --query-twinview-xinerama-info-order: query the "
-               "TwinViewXineramaInfoOrder.\n\n");
+        printf("  --query-nvidia-xinerama-info-order: query the "
+               "nvidiaXineramaInfoOrder.\n\n");
         
-        printf("  --assign-twinview-xinerama-info-order [order]: assign the "
-               "TwinViewXineramaInfoOrder.\n\n");
+        printf("  --assign-nvidia-xinerama-info-order [order]: assign the "
+               "nvidiaXineramaInfoOrder.\n\n");
 
         printf("  --max-screen-size: query the maximum screen size "
                "on all GPUs in the system\n\n");
@@ -1246,6 +1384,9 @@
 
         printf("  --dynamic-twinview: demonstrates the process of "
                "dynamically transitioning into TwinView.\n\n");
+
+        printf("  --print-display-names: print all the names associated with "
+               "each display device on the server\n\n");
     }
 
     return 0;

=== modified file 'samples/nv-control-dvc.c'
--- samples/nv-control-dvc.c	2010-06-27 18:59:46 +0000
+++ samples/nv-control-dvc.c	2012-07-30 04:30:25 +0000
@@ -52,7 +52,7 @@
  * to the display device mask.
  */
 
-char *display_device_name(int mask)
+static char *display_device_name(int mask)
 {
     switch (mask) {
     case (1 <<  0): return "CRT-0"; break;

=== modified file 'samples/nv-control-events.c'
--- samples/nv-control-events.c	2011-02-25 15:18:56 +0000
+++ samples/nv-control-events.c	2012-07-30 04:30:25 +0000
@@ -30,6 +30,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
+#include <unistd.h>
 
 
 #include <X11/Xlib.h>
@@ -37,30 +38,119 @@
 #include "NVCtrl.h"
 #include "NVCtrlLib.h"
 
+#define EVENT_TYPE_START TARGET_ATTRIBUTE_CHANGED_EVENT
+#define EVENT_TYPE_END TARGET_BINARY_ATTRIBUTE_CHANGED_EVENT
+
+
 static const char *attr2str(int n);
 static const char *target2str(int n);
-
-int main(void)
+static const char *targetTypeAndId2Str(int targetType, int targetId);
+
+struct target_info {
+    int type;
+    int count;
+    unsigned int *pIds; // If Non-NULL, is list of target ids.
+};
+
+static void print_usage(char **argv)
+{
+    printf("Usage:\n");
+    printf("%s [-d <dpy>] [-a] [-c] [-b] [-s]\n", argv[0]);
+    printf("\n");
+    printf("-d <dpy>: X server display to connect to\n");
+    printf("-a: Listen for attribute availability events\n");
+    printf("-c: Listen for attribute changed events\n");
+    printf("-b: Listen for binary attribute changed events\n");
+    printf("-s: Listen for string attribute changed events\n");
+    printf("\n");
+    printf("By default (i.e., if none of -a, -c, -b, or -s are requested),\n"
+           "all event types are enabled.\n");
+}
+
+int main(int argc, char **argv)
 {
     Display *dpy;
     Bool ret;
     int event_base, error_base;
-    int num_screens, num_gpus, num_framelocks, num_vcs, i;
-    int num_gvis, num_coolers, num_thermal_sensors;
-    int num_3d_vision_pro_transceivers;
-    int sources;
-    XEvent event;
-    XNVCtrlAttributeChangedEvent *nvevent;
-    XNVCtrlAttributeChangedEventTarget *nveventtarget;
+    int i, j, k;
+    int sources = 0;
+    struct target_info info[] = {
+        { .type = NV_CTRL_TARGET_TYPE_X_SCREEN },
+        { .type = NV_CTRL_TARGET_TYPE_GPU },
+        { .type = NV_CTRL_TARGET_TYPE_DISPLAY },
+        { .type = NV_CTRL_TARGET_TYPE_FRAMELOCK },
+        { .type = NV_CTRL_TARGET_TYPE_VCSC },
+        { .type = NV_CTRL_TARGET_TYPE_GVI },
+        { .type = NV_CTRL_TARGET_TYPE_COOLER },
+        { .type = NV_CTRL_TARGET_TYPE_THERMAL_SENSOR },
+        { .type = NV_CTRL_TARGET_TYPE_3D_VISION_PRO_TRANSCEIVER },
+    };
+    static const int num_target_types = sizeof(info) / sizeof(*info);
+
+    int c;
+    char *dpy_name = NULL;
+    Bool anythingEnabled;
+
+#define EVENT_TYPE_ENTRY(_x) [_x] = { False, #_x }
+
+    struct {
+        Bool enabled;
+        char *description;
+    } eventTypes[] = {
+        EVENT_TYPE_ENTRY(TARGET_ATTRIBUTE_CHANGED_EVENT),
+        EVENT_TYPE_ENTRY(TARGET_ATTRIBUTE_AVAILABILITY_CHANGED_EVENT),
+        EVENT_TYPE_ENTRY(TARGET_STRING_ATTRIBUTE_CHANGED_EVENT),
+        EVENT_TYPE_ENTRY(TARGET_BINARY_ATTRIBUTE_CHANGED_EVENT),
+    };
+
+    while ((c = getopt(argc, argv, "d:acbsh")) >= 0) {
+        switch (c) {
+        case 'd':
+            dpy_name = optarg;
+            break;
+        case 'a':
+            eventTypes[TARGET_ATTRIBUTE_AVAILABILITY_CHANGED_EVENT].enabled = True;
+            break;
+        case 'c':
+            eventTypes[TARGET_ATTRIBUTE_CHANGED_EVENT].enabled = True;
+            break;
+        case 'b':
+            eventTypes[TARGET_BINARY_ATTRIBUTE_CHANGED_EVENT].enabled = True;
+            break;
+        case 's':
+            eventTypes[TARGET_STRING_ATTRIBUTE_CHANGED_EVENT].enabled = True;
+            break;
+        case '?':
+            fprintf(stderr, "%s: Unknown argument '%c'\n", argv[0], optopt);
+            /* fallthrough */
+        case 'h':
+            print_usage(argv);
+            return 1;
+        }
+    }
+
+    anythingEnabled = False;
+    for (i = EVENT_TYPE_START; i <= EVENT_TYPE_END; i++) {
+        if (eventTypes[i].enabled) {
+            anythingEnabled = True;
+            break;
+        }
+    }
+
+    if (!anythingEnabled) {
+        for (i = EVENT_TYPE_START; i <= EVENT_TYPE_END; i++) {
+            eventTypes[i].enabled = True;
+        }
+    }
 
     /*
      * Open a display connection, and make sure the NV-CONTROL X
      * extension is present on the screen we want to use.
      */
-    
-    dpy = XOpenDisplay(NULL);
+
+    dpy = XOpenDisplay(dpy_name);
     if (!dpy) {
-        fprintf(stderr, "Cannot open display '%s'.\n", XDisplayName(NULL));
+        fprintf(stderr, "Cannot open display '%s'.\n", XDisplayName(dpy_name));
         return 1;
     }
     
@@ -71,305 +161,119 @@
     ret = XNVCTRLQueryExtension(dpy, &event_base, &error_base);
     if (ret != True) {
         fprintf(stderr, "The NV-CONTROL X extension does not exist on '%s'.\n",
-                XDisplayName(NULL));
-        return 1;
-    }
-
-    /* Query number of X Screens */
-
-    ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
-                                  &num_screens);
-    if (ret != True) {
-        fprintf(stderr, "Failed to query the number of X Screens on '%s'.\n",
-                XDisplayName(NULL));
-        return 1;
-    }
-
-    /* Query number of GPUs */
-
-    ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_GPU,
-                                  &num_gpus);
-    if (ret != True) {
-        fprintf(stderr, "Failed to query the number of GPUs on '%s'.\n",
-                XDisplayName(NULL));
-        return 1;
-    }
-
-    /* Query number of Frame Lock (G-Sync) devices */
-
-    ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_FRAMELOCK,
-                                  &num_framelocks);
-    if (ret != True) {
-        fprintf(stderr, "Failed to query the number of G-Sync devices on "
-                "'%s'.\n",
-                XDisplayName(NULL));
-        return 1;
-    }
-
-    /* Query number of VCS (Visual Computing System) devices */
-
-    ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_VCSC,
-                                  &num_vcs);
-    if (ret != True) {
-        fprintf(stderr, "Failed to query the number of Visual Computing "
-                "System devices on '%s'.\n",
-                XDisplayName(NULL));
-        return 1;
-    }
-
-    /* Query number of GVI (Graphics Video Input) devices */
-
-    ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_GVI,
-                                  &num_gvis);
-    if (ret != True) {
-        fprintf(stderr, "Failed to query the number of Graphics Video "
-                "Input devices on '%s'.\n",
-                XDisplayName(NULL));
-        return 1;
-    }
-
-    /* Query number of Cooler devices */
-
-    ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_COOLER,
-                                  &num_coolers);
-    if (ret != True) {
-        fprintf(stderr, "Failed to query the number of Cooler devices "
-                "on '%s'.\n",
-                XDisplayName(NULL));
-        return 1;
-    }
-
-    /* Query number of Thermal Sensor devices */
-
-    ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_THERMAL_SENSOR,
-                                  &num_thermal_sensors);
-    if (ret != True) {
-        fprintf(stderr, "Failed to query the number of Thermal Sensor "
-                "devices on '%s'.\n",
-                XDisplayName(NULL));
-        return 1;
-    }
-
-    /* Query number of 3d Vision Pro Transceivers */
-
-    ret = XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_3D_VISION_PRO_TRANSCEIVER,
-                                  &num_3d_vision_pro_transceivers);
-    if (ret != True) {
-        fprintf(stderr, "Failed to query the number of 3D Vision Pro "
-                "Transceiver devices on '%s'.\n",
-                XDisplayName(NULL));
-        return 1;
-    }
-
-    /*
-     * register to receive NV-CONTROL events: whenever any NV-CONTROL
-     * attribute is changed by an NV-CONTROL client, any other client
-     * can receive notification of the change.
-     */
-
-    sources = 0;
-
-    /* 
-     * - Register to receive ATTRIBUTE_CHANGE_EVENT events.  These events
-     *   are specific to attributes set on X Screens.
-     */
-
-    printf("Registering to receive ATTRIBUTE_CHANGED_EVENT events...\n");
-    fflush(stdout);
-
-    for (i = 0; i < num_screens; i++ ) {
-
-        /* Only register to receive events if this screen is controlled by
-         * the NVIDIA driver.
-         */
-        if (!XNVCTRLIsNvScreen(dpy, i)) {
-            printf("- The NV-CONTROL X not available on X screen "
-                   "%d of '%s'.\n", i, XDisplayName(NULL));
-            continue;
-        }
-        
-        ret = XNVCtrlSelectNotify(dpy, i, ATTRIBUTE_CHANGED_EVENT, True);
-        if (ret != True) {
-            printf("- Unable to register to receive NV-CONTROL events on '%s'."
-                   "\n", XDisplayName(NULL));
-            continue;
-        }
-        
-        printf("+ Listening to ATTRIBUTE_CHANGE_EVENTs on X screen %d.\n", i);
-        sources++;
-    }
-    printf("\n");
-
-    /* 
-     * - Register to receive TARGET_ATTRIBUTE_CHANGED_EVENT events.  These
-     *   events are specific to attributes set on various devices and
-     *   structures controlled by the NVIDIA driver.  Some possible targets
-     *   include X Screens, GPUs, and Frame Lock boards.
-     */
-
-    printf("Registering to receive TARGET_ATTRIBUTE_CHANGED_EVENT "
-           "events...\n");
-    fflush(stdout);
-
-    /* Register to receive on all X Screen targets */
-
-    for (i = 0; i < num_screens; i++ ) {
-
-        /* Only register to receive events if this screen is controlled by
-         * the NVIDIA driver.
-         */
-        if (!XNVCTRLIsNvScreen(dpy, i)) {
-            printf("- The NV-CONTROL X not available on X screen "
-                   "%d of '%s'.\n", i, XDisplayName(NULL));
-            continue;
-        }
-
-        ret = XNVCtrlSelectTargetNotify(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
-                                        i, TARGET_ATTRIBUTE_CHANGED_EVENT,
-                                        True);
-        if (ret != True) {
-            printf("- Unable to register to receive NV-CONTROL "
-                   "target events for X screen %d on '%s'.\n",
-                   i, XDisplayName(NULL));
-            continue;
-        }
-        
-        printf("+ Listening to TARGET_ATTRIBUTE_CHANGE_EVENTs on X screen "
-               "%d.\n", i);
-        sources++;
-    }
-
-    /* Register to receive on all GPU targets */
-
-    for (i = 0; i < num_gpus; i++ ) {
-
-        ret = XNVCtrlSelectTargetNotify(dpy, NV_CTRL_TARGET_TYPE_GPU,
-                                        i, TARGET_ATTRIBUTE_CHANGED_EVENT,
-                                        True);
-        if (ret != True) {
-            printf("- Unable to register to receive NV-CONTROL "
-                   "target events for GPU %d on '%s'.\n",
-                   i, XDisplayName(NULL));
-            continue;
-        }
-        
-        printf("+ Listening to TARGET_ATTRIBUTE_CHANGE_EVENTs on GPU "
-               "%d.\n", i);
-        sources++;
-    }
-
-    /* Register to receive on all Frame Lock (G-Sync) targets */
-
-    for (i = 0; i < num_framelocks; i++ ) {
-
-        ret = XNVCtrlSelectTargetNotify(dpy, NV_CTRL_TARGET_TYPE_FRAMELOCK,
-                                        i, TARGET_ATTRIBUTE_CHANGED_EVENT,
-                                        True);
-        if (ret != True) {
-            printf("- Unable to register to receive NV-CONTROL "
-                   "target events for Frame Lock %d on '%s'.\n",
-                   i, XDisplayName(NULL));
-            continue;
-        }
-        
-        printf("+ Listening to TARGET_ATTRIBUTE_CHANGE_EVENTs on Frame Lock "
-               "%d.\n", i);
-        sources++;
-    }
-
-    /* Register to receive on all VCS targets */
-
-    for (i = 0; i < num_vcs; i++ ) {
-
-        ret = XNVCtrlSelectTargetNotify(dpy, NV_CTRL_TARGET_TYPE_VCSC,
-                                        i, TARGET_ATTRIBUTE_CHANGED_EVENT,
-                                        True);
-        if (ret != True) {
-            printf("- Unable to register to receive NV-CONTROL "
-                   "target events for VCS %d on '%s'.\n",
-                   i, XDisplayName(NULL));
-            continue;
-        }
-        
-        printf("+ Listening to TARGET_ATTRIBUTE_CHANGE_EVENTs on VCS "
-               "%d.\n", i);
-        sources++;
-    }
-
-    /* Register to receive on all GVI targets */
-
-    for (i = 0; i < num_gvis; i++ ) {
-
-        ret = XNVCtrlSelectTargetNotify(dpy, NV_CTRL_TARGET_TYPE_GVI,
-                                        i, TARGET_ATTRIBUTE_CHANGED_EVENT,
-                                        True);
-        if (ret != True) {
-            printf("- Unable to register to receive NV-CONTROL "
-                   "target events for GVI %d on '%s'.\n",
-                   i, XDisplayName(NULL));
-            continue;
-        }
-        
-        printf("+ Listening to TARGET_ATTRIBUTE_CHANGE_EVENTs on GVI "
-               "%d.\n", i);
-        sources++;
-    }
-
-    /* Register to receive on all Cooler targets */
-
-    for (i = 0; i < num_coolers; i++ ) {
-
-        ret = XNVCtrlSelectTargetNotify(dpy, NV_CTRL_TARGET_TYPE_COOLER,
-                                        i, TARGET_ATTRIBUTE_CHANGED_EVENT,
-                                        True);
-        if (ret != True) {
-            printf("- Unable to register to receive NV-CONTROL "
-                   "target events for Cooler %d on '%s'.\n",
-                   i, XDisplayName(NULL));
-            continue;
-        }
-        
-        printf("+ Listening to TARGET_ATTRIBUTE_CHANGE_EVENTs on Cooler "
-               "%d.\n", i);
-        sources++;
-    }
-
-    /* Register to receive on all Thermal Sensor targets */
-
-    for (i = 0; i < num_thermal_sensors; i++ ) {
-
-        ret = XNVCtrlSelectTargetNotify(dpy, NV_CTRL_TARGET_TYPE_THERMAL_SENSOR,
-                                        i, TARGET_ATTRIBUTE_CHANGED_EVENT,
-                                        True);
-        if (ret != True) {
-            printf("- Unable to register to receive NV-CONTROL "
-                   "target events for Thermal Sensor %d on '%s'.\n",
-                   i, XDisplayName(NULL));
-            continue;
-        }
-        
-        printf("+ Listening to TARGET_ATTRIBUTE_CHANGE_EVENTs on Thermal "
-               "Sensor %d.\n", i);
-        sources++;
-    }
-
-    /* Register to receive on all 3D Vision Pro Transceiver targets */
-
-    for (i = 0; i < num_3d_vision_pro_transceivers; i++ ) {
-
-        ret = XNVCtrlSelectTargetNotify(dpy, NV_CTRL_TARGET_TYPE_3D_VISION_PRO_TRANSCEIVER,
-                                        i, TARGET_ATTRIBUTE_CHANGED_EVENT,
-                                        True);
-        if (ret != True) {
-            printf("- Unable to register to receive NV-CONTROL "
-                   "target events for 3D Vision Pro Transceiver %d on '%s'.\n",
-                   i, XDisplayName(NULL));
-            continue;
-        }
-
-        printf("+ Listening to TARGET_ATTRIBUTE_CHANGE_EVENTs on 3d Vision "
-               "Pro Transceiver %d.\n", i);
-        sources++;
+                XDisplayName(dpy_name));
+        return 1;
+    }
+
+    /* Query target counts */
+    for (i = 0; i < num_target_types; i++) {
+
+        struct target_info *tinfo = &info[i];
+
+
+        if (tinfo->type == NV_CTRL_TARGET_TYPE_DISPLAY) {
+            ret = XNVCTRLQueryTargetBinaryData(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
+                                               0, 0,
+                                               NV_CTRL_BINARY_DATA_DISPLAY_TARGETS,
+                                               (unsigned char **)&(tinfo->pIds),
+                                               &(tinfo->count));
+            if (ret != True) {
+                fprintf(stderr, "Failed to query %s target count on '%s'.\n",
+                        target2str(tinfo->type), XDisplayName(dpy_name));
+                return 1;
+            }
+            tinfo->count = tinfo->pIds[0];
+        } else {
+            ret = XNVCTRLQueryTargetCount(dpy, tinfo->type, &tinfo->count);
+            if (ret != True) {
+                fprintf(stderr, "Failed to query %s target count on '%s'.\n",
+                        target2str(tinfo->type), XDisplayName(dpy_name));
+                return 1;
+            }
+        }
+    }
+
+    printf("Registering to receive events...\n");
+    fflush(stdout);
+
+    /* Register to receive events on all targets */
+
+    for (i = 0; i < num_target_types; i++) {
+        struct target_info *tinfo = &info[i];
+
+        for (j = 0; j < tinfo->count; j++) {
+            int target_id;
+
+            if (tinfo->pIds) {
+                target_id = tinfo->pIds[1+j];
+            } else {
+                target_id = j;
+            }
+
+            for (k = EVENT_TYPE_START; k <= EVENT_TYPE_END; k++) {
+                if (!eventTypes[k].enabled) {
+                    continue;
+                }
+
+                if ((k == TARGET_ATTRIBUTE_CHANGED_EVENT) &&
+                    (tinfo->type == NV_CTRL_TARGET_TYPE_X_SCREEN)) {
+
+                    /*
+                     * Only register to receive events if this screen is
+                     * controlled by the NVIDIA driver.
+                     */
+                    if (!XNVCTRLIsNvScreen(dpy, target_id)) {
+                        printf("- The NV-CONTROL X not available on X screen "
+                               "%d of '%s'.\n", i, XDisplayName(dpy_name));
+                        continue;
+                    }
+
+                    /*
+                     * - Register to receive ATTRIBUTE_CHANGE_EVENT events.
+                     *   These events are specific to attributes set on X
+                     *   Screens.
+                     */
+
+
+                    ret = XNVCtrlSelectNotify(dpy, target_id, ATTRIBUTE_CHANGED_EVENT,
+                                              True);
+                    if (ret != True) {
+                        printf("- Unable to register to receive NV-CONTROL"
+                               "events on '%s'.\n", XDisplayName(dpy_name));
+                        continue;
+                    }
+
+                    printf("+ Listening on X screen %d for "
+                           "ATTRIBUTE_CHANGED_EVENTs.\n", target_id);
+                    sources++;
+                }
+
+                /*
+                 * - Register to receive TARGET_ATTRIBUTE_CHANGED_EVENT events.
+                 *   These events are specific to attributes set on various
+                 *   devices and structures controlled by the NVIDIA driver.
+                 *   Some possible targets include X Screens, GPUs, and Frame
+                 *   Lock boards.
+                 */
+
+                ret = XNVCtrlSelectTargetNotify(dpy,
+                                                tinfo->type, /* target type */
+                                                target_id,   /* target ID */
+                                                k,           /* eventType */
+                                                True);
+                if (ret != True) {
+                    printf("- Unable to register on %s %d for %ss.\n",
+                           target2str(tinfo->type), target_id,
+                           eventTypes[k].description);
+                    continue;
+                }
+
+                printf("+ Listening on %s %d for %ss.\n",
+                       target2str(tinfo->type), target_id, eventTypes[k].description);
+
+                sources++;
+            }
+        }
     }
 
     /* 
@@ -386,31 +290,25 @@
      */
 
     while (True) {
-        char target_str[256];
+        XEvent event;
+        const char *target_str;
 
         /* block for the next event */
 
         XNextEvent(dpy, &event);
 
-        /* if this is not one of our events, then bail out of this iteration */
-
-        if ((event.type != (event_base + ATTRIBUTE_CHANGED_EVENT)) &&
-            (event.type != (event_base + TARGET_ATTRIBUTE_CHANGED_EVENT)))
-            continue;
-        
         /* Handle ATTRIBUTE_CHANGED_EVENTS */
         if (event.type == (event_base + ATTRIBUTE_CHANGED_EVENT)) {
 
             /* cast the X event as an XNVCtrlAttributeChangedEvent */
-            
-            nvevent = (XNVCtrlAttributeChangedEvent *) &event;
-            
+            XNVCtrlAttributeChangedEvent *nvevent =
+                (XNVCtrlAttributeChangedEvent *) &event;
+
+            target_str = targetTypeAndId2Str(NV_CTRL_TARGET_TYPE_X_SCREEN,
+                                             nvevent->screen);
+
             /* print out the event information */
-            snprintf(target_str, 256, "%s-%-3d", 
-                     target2str(NV_CTRL_TARGET_TYPE_X_SCREEN),
-                     nvevent->screen);
-
-            printf("ATTRIBUTE_CHANGED_EVENTS:         Target: %15s   "
+            printf("ATTRIBUTE_CHANGED_EVENTS:                    Target: %15s  "
                    "Display Mask: 0x%08x   "
                    "Attribute: (%3d) %-32s   Value: %d (0x%08x)\n",
                    target_str,
@@ -424,16 +322,16 @@
         /* Handle TARGET_ATTRIBUTE_CHANGED_EVENTS */
         } else if (event.type ==
                    (event_base + TARGET_ATTRIBUTE_CHANGED_EVENT)) {
+
             /* cast the X event as an XNVCtrlAttributeChangedEventTarget */
-            
-            nveventtarget = (XNVCtrlAttributeChangedEventTarget *) &event;
-            
+            XNVCtrlAttributeChangedEventTarget *nveventtarget =
+                (XNVCtrlAttributeChangedEventTarget *) &event;
+
+            target_str = targetTypeAndId2Str(nveventtarget->target_type,
+                                             nveventtarget->target_id);
+
             /* print out the event information */
-            snprintf(target_str, 256, "%s-%-3d",
-                     target2str(nveventtarget->target_type),
-                     nveventtarget->target_id);
-
-            printf("TARGET_ATTRIBUTE_CHANGED_EVENTS:  Target: %15s   "
+            printf("TARGET_ATTRIBUTE_CHANGED_EVENT:              Target: %15s  "
                    "Display Mask: 0x%08x   "
                    "Attribute: (%3d) %-32s   Value: %d (0x%08x)\n",
                    target_str,
@@ -443,6 +341,66 @@
                    nveventtarget->value,
                    nveventtarget->value
                    );
+
+        /* Handle TARGET_ATTRIBUTE_AVAILABILITY_CHANGED_EVENTS */
+        } else if (event.type ==
+                   (event_base + TARGET_ATTRIBUTE_AVAILABILITY_CHANGED_EVENT)) {
+
+            /* cast the X event as an XNVCtrlAttributeChangedEventTargetAvailability */
+            XNVCtrlAttributeChangedEventTargetAvailability *nveventavail =
+                (XNVCtrlAttributeChangedEventTargetAvailability *) &event;
+
+            target_str = targetTypeAndId2Str(nveventavail->target_type,
+                                             nveventavail->target_id);
+
+            /* print out the event information */
+            printf("TARGET_ATTRIBUTE_AVAILABILITY_CHANGED_EVENT: Target: %15s  "
+                   "Display Mask: 0x%08x   "
+                   "Attribute: (%3d) %-32s   Available: %s\n",
+                   target_str,
+                   nveventavail->display_mask,
+                   nveventavail->attribute,
+                   attr2str(nveventavail->attribute),
+                   nveventavail->availability ? "Yes" : "No"
+                   );
+        } else if (event.type ==
+                   (event_base + TARGET_STRING_ATTRIBUTE_CHANGED_EVENT)) {
+
+            XNVCtrlStringAttributeChangedEventTarget *nveventstring =
+                (XNVCtrlStringAttributeChangedEventTarget*) &event;
+
+            target_str = targetTypeAndId2Str(nveventstring->target_type,
+                                             nveventstring->target_id);
+
+            /* print out the event information */
+            printf("TARGET_STRING_ATTRIBUTE_CHANGED_EVENT:       Target: %15s  "
+                   "Display Mask: 0x%08x   "
+                   "Attribute: %3d\n",
+                   target_str,
+                   nveventstring->display_mask,
+                   nveventstring->attribute
+                   );
+
+        } else if (event.type ==
+                   (event_base + TARGET_BINARY_ATTRIBUTE_CHANGED_EVENT)) {
+
+            XNVCtrlBinaryAttributeChangedEventTarget *nveventbinary =
+                (XNVCtrlBinaryAttributeChangedEventTarget *) &event;
+
+            target_str = targetTypeAndId2Str(nveventbinary->target_type,
+                                             nveventbinary->target_id);
+
+            /* print out the event information */
+            printf("TARGET_BINARY_ATTRIBUTE_CHANGED_EVENT:       Target: %15s  "
+                   "Display Mask: 0x%08x   "
+                   "Attribute: %3d\n",
+                   target_str,
+                   nveventbinary->display_mask,
+                   nveventbinary->attribute
+                   );
+
+        } else {
+            printf("ERROR: unrecognized event type %d\n", event.type);
         }
     }
 
@@ -463,6 +421,8 @@
         return "X Screen";
     case NV_CTRL_TARGET_TYPE_GPU:
         return "GPU";
+    case NV_CTRL_TARGET_TYPE_DISPLAY:
+        return "Display";
     case NV_CTRL_TARGET_TYPE_FRAMELOCK:
         return "Frame Lock";
     case NV_CTRL_TARGET_TYPE_VCSC:
@@ -481,6 +441,15 @@
     }
 }
 
+static const char *targetTypeAndId2Str(int targetType, int targetId)
+{
+    static char tmp[256];
+
+    snprintf(tmp, sizeof(tmp), "%s-%-3d", target2str(targetType), targetId);
+
+    return tmp;
+}
+
 
 // Used to convert the NV-CONTROL #defines to human readable text.
 #define MAKE_ENTRY(ATTRIBUTE) { ATTRIBUTE, #ATTRIBUTE, NULL }
@@ -590,7 +559,6 @@
     MAKE_ENTRY(NV_CTRL_GVIO_REQUESTED_VIDEO_FORMAT),
     MAKE_ENTRY(NV_CTRL_GVIO_DETECTED_VIDEO_FORMAT),
     MAKE_ENTRY(NV_CTRL_GVO_DATA_FORMAT),
-    MAKE_ENTRY(NV_CTRL_GVO_DISPLAY_X_SCREEN),
     MAKE_ENTRY(NV_CTRL_GVO_COMPOSITE_SYNC_INPUT_DETECTED),
     MAKE_ENTRY(NV_CTRL_GVO_COMPOSITE_SYNC_INPUT_DETECT_MODE),
     MAKE_ENTRY(NV_CTRL_GVO_SDI_SYNC_INPUT_DETECTED),
@@ -603,8 +571,6 @@
     MAKE_ENTRY(NV_CTRL_GVIO_VIDEO_FORMAT_WIDTH),
     MAKE_ENTRY(NV_CTRL_GVIO_VIDEO_FORMAT_HEIGHT),
     MAKE_ENTRY(NV_CTRL_GVIO_VIDEO_FORMAT_REFRESH_RATE),
-    MAKE_ENTRY(NV_CTRL_GVO_X_SCREEN_PAN_X),
-    MAKE_ENTRY(NV_CTRL_GVO_X_SCREEN_PAN_Y),
     MAKE_ENTRY(NV_CTRL_GPU_OVERCLOCKING_STATE),
     MAKE_ENTRY(NV_CTRL_GPU_2D_CLOCK_FREQS),
     MAKE_ENTRY(NV_CTRL_GPU_3D_CLOCK_FREQS),

=== modified file 'samples/nv-control-gvi.c'
--- samples/nv-control-gvi.c	2010-09-29 11:46:29 +0000
+++ samples/nv-control-gvi.c	2012-07-30 04:30:25 +0000
@@ -46,24 +46,10 @@
 
 
 /*
- * Decode SDI input value returned.
- */
-char *SyncTypeName(int value)
-{
-    switch (value) {
-        ADD_NVCTRL_CASE(NV_CTRL_GVO_SDI_SYNC_INPUT_DETECTED_HD);
-        ADD_NVCTRL_CASE(NV_CTRL_GVO_SDI_SYNC_INPUT_DETECTED_SD);
-        ADD_NVCTRL_CASE(NV_CTRL_GVO_SDI_SYNC_INPUT_DETECTED_NONE);
-    default:
-        return "Invalid Value";
-    }
-}
-
-/*
  * Decode provided signal format.
  */
 
-char *VideoFormatName(int value)
+static char *VideoFormatName(int value)
 {
     switch(value) {
         ADD_NVCTRL_CASE(NV_CTRL_GVIO_VIDEO_FORMAT_NONE);
@@ -136,7 +122,7 @@
     }
 }
 
-const char *SamplingName(int value)
+static const char *SamplingName(int value)
 {
     switch (value) {
     default:
@@ -150,7 +136,7 @@
     }
 }
 
-const char *BPCName(int value)
+static const char *BPCName(int value)
 {
     switch (value) {
         ADD_NVCTRL_CASE(NV_CTRL_GVI_BITS_PER_COMPONENT_UNKNOWN);
@@ -349,9 +335,10 @@
             printf("    - Jack %d\n", jack);
 
             for (channel = 0; channel < max_channels_per_jack; channel++) {
+                unsigned int link_definition = ((channel & 0xFFFF)<<16);
+
                 printf("      - Channel %d\n", channel);
 
-                unsigned int link_definition = ((channel & 0xFFFF)<<16);
                 link_definition |= (jack & 0xFFFF);
 
                 ret = XNVCTRLQueryTargetAttribute(dpy,
@@ -571,13 +558,13 @@
 
 
 
-unsigned int firstbit (unsigned int mask)
+static unsigned int firstbit (unsigned int mask)
 {
     return mask ^ ((mask - 1) & mask);
 }
 
 // List the configuration space of the GVI device.
-void do_listconfig(Display *dpy, int gvi)
+static void do_listconfig(Display *dpy, int gvi)
 {
     NVCTRLAttributeValidValuesRec values;
 
@@ -770,7 +757,7 @@
 
 
 
-void do_configure(Display *dpy, int use_gvi, char *pIn)
+static void do_configure(Display *dpy, int use_gvi, char *pIn)
 {
     Bool ret;
     char *pOut = NULL;

=== modified file 'samples/nv-control-info.c'
--- samples/nv-control-info.c	2011-02-25 15:18:56 +0000
+++ samples/nv-control-info.c	2012-07-30 04:30:25 +0000
@@ -142,7 +142,6 @@
     MAKE_ENTRY(NV_CTRL_GVIO_REQUESTED_VIDEO_FORMAT),
     MAKE_ENTRY(NV_CTRL_GVIO_DETECTED_VIDEO_FORMAT),
     MAKE_ENTRY(NV_CTRL_GVO_DATA_FORMAT),
-    MAKE_ENTRY(NV_CTRL_GVO_DISPLAY_X_SCREEN),
     MAKE_ENTRY(NV_CTRL_GVO_COMPOSITE_SYNC_INPUT_DETECTED),
     MAKE_ENTRY(NV_CTRL_GVO_COMPOSITE_SYNC_INPUT_DETECT_MODE),
     MAKE_ENTRY(NV_CTRL_GVO_SDI_SYNC_INPUT_DETECTED),
@@ -155,8 +154,6 @@
     MAKE_ENTRY(NV_CTRL_GVIO_VIDEO_FORMAT_WIDTH),
     MAKE_ENTRY(NV_CTRL_GVIO_VIDEO_FORMAT_HEIGHT),
     MAKE_ENTRY(NV_CTRL_GVIO_VIDEO_FORMAT_REFRESH_RATE),
-    MAKE_ENTRY(NV_CTRL_GVO_X_SCREEN_PAN_X),
-    MAKE_ENTRY(NV_CTRL_GVO_X_SCREEN_PAN_Y),
     MAKE_ENTRY(NV_CTRL_GPU_OVERCLOCKING_STATE),
     MAKE_ENTRY(NV_CTRL_GPU_2D_CLOCK_FREQS),
     MAKE_ENTRY(NV_CTRL_GPU_3D_CLOCK_FREQS),
@@ -353,7 +350,7 @@
     MAKE_ENTRY(NV_CTRL_STRING_VALID_HORIZ_SYNC_RANGES),
     MAKE_ENTRY(NV_CTRL_STRING_VALID_VERT_REFRESH_RANGES),
     MAKE_ENTRY(NV_CTRL_STRING_XINERAMA_SCREEN_INFO),
-    MAKE_ENTRY(NV_CTRL_STRING_TWINVIEW_XINERAMA_INFO_ORDER),
+    MAKE_ENTRY(NV_CTRL_STRING_NVIDIA_XINERAMA_INFO_ORDER),
     MAKE_ENTRY(NV_CTRL_STRING_SLI_MODE),
     MAKE_ENTRY(NV_CTRL_STRING_PERFORMANCE_MODES),
     MAKE_ENTRY(NV_CTRL_STRING_VCSC_FAN_STATUS),
@@ -372,13 +369,20 @@
     MAKE_ENTRY(NV_CTRL_STRING_3D_VISION_PRO_GLASSES_FIRMWARE_DATE_A),
     MAKE_ENTRY(NV_CTRL_STRING_3D_VISION_PRO_GLASSES_ADDRESS),
     MAKE_ENTRY(NV_CTRL_STRING_3D_VISION_PRO_GLASSES_NAME),
+    MAKE_ENTRY(NV_CTRL_STRING_CURRENT_METAMODE_VERSION_2),
+    MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_NAME_TYPE_BASENAME),
+    MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_NAME_TYPE_ID),
+    MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_NAME_DP_GUID),
+    MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_NAME_EDID_HASH),
+    MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_NAME_TARGET_INDEX),
+    MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_NAME_RANDR),
     { -1, NULL, NULL }
 };
 
 static AttrEntry attr_bin_table[] = {
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_EDID),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_MODELINES),
-    MAKE_ENTRY(NV_CTRL_BINARY_DATA_METAMODES),
+    MAKE_ENTRY(NV_CTRL_BINARY_DATA_METAMODES_VERSION_1),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_XSCREENS_USING_GPU),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_GPUS_USED_BY_XSCREEN),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_GPUS_USING_FRAMELOCK),
@@ -390,6 +394,9 @@
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_GPUS_USED_BY_LOGICAL_XSCREEN),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_THERMAL_SENSORS_USED_BY_GPU),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_GLASSES_PAIRED_TO_3D_VISION_PRO_TRANSCEIVER),
+    MAKE_ENTRY(NV_CTRL_BINARY_DATA_DISPLAY_TARGETS),
+    MAKE_ENTRY(NV_CTRL_BINARY_DATA_DISPLAYS_CONNECTED_TO_GPU),
+    MAKE_ENTRY(NV_CTRL_BINARY_DATA_METAMODES_VERSION_2),
     { -1, NULL, NULL }
 };
 
@@ -404,7 +411,7 @@
 };
 
 
-void print_perms(NVCTRLAttributePermissionsRec *perms)
+static void print_perms(NVCTRLAttributePermissionsRec *perms)
 {
     printf("%c", (perms->permissions & ATTRIBUTE_TYPE_READ)                      ? 'R' : '_');
     printf("%c", (perms->permissions & ATTRIBUTE_TYPE_WRITE)                     ? 'W' : '_');
@@ -426,7 +433,7 @@
 case (FMT):                  \
     return #FMT;
 
-const char *GetAttrTypeName(value)
+static const char *GetAttrTypeName(int value)
 {
     switch (value) {
         ADD_NVCTRL_CASE(ATTRIBUTE_TYPE_UNKNOWN);

=== modified file 'samples/nv-control-targets.c'
--- samples/nv-control-targets.c	2010-06-27 18:59:46 +0000
+++ samples/nv-control-targets.c	2012-07-30 04:30:25 +0000
@@ -46,7 +46,7 @@
  * to the display device mask.
  */
 
-char *display_device_name(int mask)
+static char *display_device_name(int mask)
 {
     switch (mask) {
     case (1 <<  0): return "CRT-0"; break;

=== modified file 'samples/src.mk'
--- samples/src.mk	2012-02-18 10:21:04 +0000
+++ samples/src.mk	2012-07-30 04:30:25 +0000
@@ -15,3 +15,5 @@
 SAMPLES_EXTRA_DIST += nv-control-framelock.c
 SAMPLES_EXTRA_DIST += nv-control-screen.h
 SAMPLES_EXTRA_DIST += src.mk
+
+SAMPLES_DIST_FILES := $(SAMPLES_SRC) $(SAMPLES_EXTRA_DIST)
\ No newline at end of file

=== added file 'samples/version.mk'
--- samples/version.mk	1970-01-01 00:00:00 +0000
+++ samples/version.mk	2012-07-30 04:30:25 +0000
@@ -0,0 +1,1 @@
+NVIDIA_VERSION = 302.17

=== added file 'src/Makefile'
--- src/Makefile	1970-01-01 00:00:00 +0000
+++ src/Makefile	2012-07-30 04:30:25 +0000
@@ -0,0 +1,174 @@
+#
+# nvidia-settings: A tool for configuring the NVIDIA X driver on Unix
+# and Linux systems.
+#
+# Copyright (C) 2008-2012 NVIDIA Corporation.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms and conditions of the GNU General Public License,
+# version 2, as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses>.
+#
+
+
+##############################################################################
+# include common variables and functions
+##############################################################################
+
+UTILS_MK_DIR ?= ..
+
+include $(UTILS_MK_DIR)/utils.mk
+
+
+##############################################################################
+# The calling Makefile may export any of the following variables; we
+# assign default values if they are not exported by the caller
+##############################################################################
+
+ifndef X_LDFLAGS
+  ifeq ($(TARGET_OS)-$(TARGET_ARCH),Linux-x86_64)
+    X_LDFLAGS          = -L/usr/X11R6/lib64
+  else
+    X_LDFLAGS          = -L/usr/X11R6/lib
+  endif
+endif
+
+X_CFLAGS              ?=
+
+GL_INCLUDE_PATH       ?= /usr/include
+
+PKG_CONFIG            ?= pkg-config
+
+ifndef GTK_CFLAGS
+  GTK_CFLAGS          := $(shell $(PKG_CONFIG) --cflags gtk+-2.0)
+endif
+
+ifndef GTK_LDFLAGS
+  GTK_LDFLAGS         := $(shell $(PKG_CONFIG) --libs gtk+-2.0)
+endif
+
+
+##############################################################################
+# The XF86Config-parser, libXNVCtrl, and common-utils directories may
+# be in one of two places: either elsewhere in the driver source tree
+# when building nvidia-settings as part of the NVIDIA driver build (in
+# which case, XNVCTRL_DIR, XNVCTRL_ARCHIVE, XCONFIG_PARSER_DIR and
+# COMMON_UTILS_DIR should be defined by the calling makefile), or
+# directly in the source directory when building from the
+# nvidia-settings source tarball (in which case, the below conditional
+# assignments should be used)
+##############################################################################
+
+XNVCTRL_DIR           ?= libXNVCtrl
+XNVCTRL_ARCHIVE       ?= $(XNVCTRL_DIR)/libXNVCtrl.a
+XCONFIG_PARSER_DIR    ?= XF86Config-parser
+COMMON_UTILS_DIR      ?= common-utils
+
+##############################################################################
+# assign variables
+##############################################################################
+
+NVIDIA_SETTINGS = $(OUTPUTDIR)/nvidia-settings
+
+NVIDIA_SETTINGS_PROGRAM_NAME = "nvidia-settings"
+
+NVIDIA_SETTINGS_VERSION := $(NVIDIA_VERSION)
+
+CFLAGS += $(X_CFLAGS)
+
+ifeq ($(TARGET_OS),SunOS)
+  LDFLAGS += -Wl,-rpath=/usr/X11R6/lib
+endif
+
+LDFLAGS += $(X_LDFLAGS)
+
+# Some older Linux distributions do not have the dynamic library
+# libXxf86vm.so, though some newer Linux distributions do not have the
+# static library libXxf86vm.a.  Statically link against libXxf86vm
+# when building nvidia-settings within the NVIDIA driver build, but
+# dynamically link against libXxf86vm in the public builds.
+ifdef NV_LINK_LIBXXF86VM_STATICALLY
+    LIBS += -Wl,-Bstatic -lXxf86vm -Wl,-Bdynamic
+else
+    LIBS += -lXxf86vm
+endif
+
+# Preferably, we would use pkg-config's "--libs-only-l" and
+# "--libs-only-L" options to get separate GTK_LDFLAGS and GTK_LIBS,
+# appending them to LDFLAGS and LIBS, respectively.  However, the
+# pkg-config(1) man page cautions:
+#
+#     [...] Note that the union of "--libs-only-l"  and
+#     "--libs-only-L"  may be smaller than "--libs", due to flags such
+#     as -rdynamic.
+#
+# So append all of GTK_LDFLAGS to LIBS, so that LIBS can go after
+# $(OBJECTS) on the link commandline, causing libraries for linking to
+# be named after the objects that depend on those libraries (needed
+# for "--as-needed" linker behavior).
+LIBS += -lX11 -lXext -lm $(LIBDL_LIBS) $(GTK_LDFLAGS)
+
+# Include all the source lists; dist-files.mk will define NVIDIA_SETTINGS_SRC
+include src.mk
+SRC        += $(NVIDIA_SETTINGS_SRC)
+
+include $(XCONFIG_PARSER_DIR)/src.mk
+SRC        += $(addprefix $(XCONFIG_PARSER_DIR)/,$(XCONFIG_PARSER_SRC))
+
+include $(COMMON_UTILS_DIR)/src.mk
+SRC        += $(addprefix $(COMMON_UTILS_DIR)/,$(COMMON_UTILS_SRC))
+
+SRC        += $(STAMP_C)
+
+OBJS        = $(call BUILD_OBJECT_LIST,$(SRC))
+
+CFLAGS     += -I .
+CFLAGS     += -I image_data
+CFLAGS     += -I $(XNVCTRL_DIR)
+CFLAGS     += -I $(XCONFIG_PARSER_DIR)/..
+CFLAGS     += -I libXNVCtrlAttributes
+CFLAGS     += -I xpm_data
+CFLAGS     += -I gtk+-2.x
+CFLAGS     += -I $(COMMON_UTILS_DIR)
+CFLAGS     += -I $(OUTPUTDIR)
+CFLAGS     += -DPROGRAM_NAME=\"nvidia-setttings\"
+
+$(call BUILD_OBJECT_LIST,$(GTK_SRC)): CFLAGS += $(GTK_CFLAGS)
+
+
+##############################################################################
+# build rules
+##############################################################################
+
+.PNONY: all install NVIDIA_SETTINGS_install clean clobber
+
+all: $(NVIDIA_SETTINGS)
+
+install: NVIDIA_SETTINGS_install
+
+NVIDIA_SETTINGS_install: $(NVIDIA_SETTINGS)
+	$(MKDIR) $(BINDIR)
+	$(INSTALL) $(INSTALL_BIN_ARGS) $< $(BINDIR)/$(notdir $<)
+
+$(NVIDIA_SETTINGS): $(OBJS) $(XNVCTRL_ARCHIVE)
+	$(call quiet_cmd,LINK) $(CFLAGS) $(LDFLAGS) $(BIN_LDFLAGS) -o $@ $(OBJS) \
+	    $(XNVCTRL_ARCHIVE) $(LIBS)
+	$(call quiet_cmd,STRIP_CMD) $@
+
+# define the rule to build each object file
+$(foreach src,$(SRC),$(eval $(call DEFINE_OBJECT_RULE,CC,$(src))))
+
+# define the rule to generate $(STAMP_C)
+$(eval $(call DEFINE_STAMP_C_RULE, $(OBJS),$(NVIDIA_SETTINGS_PROGRAM_NAME)))
+
+clean clobber:
+	rm -rf $(NVIDIA_SETTINGS) *~ $(STAMP_C) \
+		$(OUTPUTDIR)/*.o $(OUTPUTDIR)/*.d
+

=== modified file 'src/command-line.c'
--- src/command-line.c	2012-02-18 10:21:04 +0000
+++ src/command-line.c	2012-07-30 04:30:25 +0000
@@ -146,6 +146,12 @@
 } /* print_attribute_help() */
 
 
+static void print_help_helper(const char *name, const char *description)
+{
+    nv_msg(TAB, name);
+    nv_msg_preserve_whitespace(BIGTAB, description);
+    nv_msg(NULL, "");
+}
 
 /*
  * print_help() - loop through the __options[] table, and print the
@@ -154,66 +160,14 @@
 
 void print_help(void)
 {
-    int i, j, len;
-    char *msg, *tmp, scratch[64];
-    const NVGetoptOption *o;
-    
     print_version();
 
     nv_msg(NULL, "");
     nv_msg(NULL, "nvidia-settings [options]");
     nv_msg(NULL, "");
-    
-    for (i = 0; __options[i].name; i++) {
-        o = &__options[i];
-        if (isalpha(o->val)) {
-            sprintf(scratch, "%c", o->val);
-            msg = nvstrcat("-", scratch, ", --", o->name, NULL);
-        } else {
-            msg = nvstrcat("--", o->name, NULL);
-        }
-        if (o->flags & NVGETOPT_HAS_ARGUMENT) {
-            len = strlen(o->name);
-            for (j = 0; j < len; j++) scratch[j] = toupper(o->name[j]);
-            scratch[len] = '\0';
-            tmp = nvstrcat(msg, "=[", scratch, "]", NULL);
-            free(msg);
-            msg = tmp;
-        }
-        nv_msg(TAB, msg);
-        free(msg);
-
-        if (o->description) {
-            char *buf = NULL, *pbuf = NULL, *s = NULL;
-
-            buf = calloc(1, 1 + strlen(o->description));
-            if (!buf) {
-                /* XXX There should be better message than this */
-                nv_error_msg("Not enough memory\n");
-                return;
-            }
-            pbuf = buf;
-
-            for (s = o->description; s && *s; s++) {
-                switch (*s) {
-                case '<':
-                case '>':
-                case '^':
-                    break;
-                default:
-                    *pbuf = *s;
-                    pbuf++;
-                    break;
-                }
-            }
-            *pbuf = '\0';
-            nv_msg_preserve_whitespace(BIGTAB, buf);
-            free(buf);
-        }
-
-        nv_msg(NULL, "");
-    }
-} /* print_help() */
+
+    nvgetopt_print_help(__options, 0, print_help_helper);
+}
 
 
 /*

=== modified file 'src/command-line.h'
--- src/command-line.h	2012-02-18 10:21:04 +0000
+++ src/command-line.h	2012-07-30 04:30:25 +0000
@@ -20,8 +20,6 @@
 #ifndef __COMMAND_LINE_H__
 #define __COMMAND_LINE_H__
 
-#include <NvCtrlAttributes.h>
-
 #define DEFAULT_RC_FILE "~/.nvidia-settings-rc"
 #define CONFIG_FILE_OPTION 1
 

=== modified file 'src/common-utils/common-utils.c'
--- src/common-utils/common-utils.c	2012-02-18 10:21:04 +0000
+++ src/common-utils/common-utils.c	2012-07-30 04:30:25 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 NVIDIA Corporation
+ * Copyright (C) 2010-2012 NVIDIA Corporation
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -150,6 +150,35 @@
 
 
 /*
+ * nvstrndup() - implementation of strndup() that checks return values; if
+ * an error occurs, an error is printed to stderr and exit is called
+ * -- this function will only return on success.
+ */
+
+char *nvstrndup(const char *s, size_t n)
+{
+    char *m;
+
+    if (!s) return NULL;
+
+    m = malloc(n + 1);
+
+    if (!m) {
+        fprintf(stderr, "%s: memory allocation failure during malloc (%s)! \n",
+                PROGRAM_NAME, strerror(errno));
+        exit(1);
+    }
+
+    strncpy (m, s, n);
+    m[n] = '\0';
+
+    return m;
+
+} /* nvstrndup() */
+
+
+
+/*
  * nvstrtolower() - convert the given string to lowercase.
  */
 
@@ -250,3 +279,310 @@
     return ret;
 
 } /* tilde_expansion() */
+
+
+/****************************************************************************/
+/* TextRows helper functions */
+/****************************************************************************/
+
+/*
+ * nv_format_text_rows() - this function breaks the given string str
+ * into some number of rows, where each row is not longer than the
+ * specified width.
+ *
+ * If prefix is non-NULL, the first line is prepended with the prefix,
+ * and subsequent lines are indented to line up with the prefix.
+ *
+ * If word_boundary is TRUE, then attempt to only break lines on
+ * boundaries between words.
+ */
+
+TextRows *nv_format_text_rows(const char *prefix,
+                              const char *str,
+                              int width, int word_boundary)
+{
+    int len, prefix_len, z, w, i;
+    char *line, *buf, *local_prefix, *a, *b, *c;
+    TextRows *t;
+
+    /* initialize the TextRows structure */
+
+    t = (TextRows *) malloc(sizeof(TextRows));
+
+    if (!t) return NULL;
+
+    t->t = NULL;
+    t->n = 0;
+    t->m = 0;
+
+    if (!str) return t;
+
+    buf = strdup(str);
+
+    if (!buf) return t;
+
+    z = strlen(buf); /* length of entire string */
+    a = buf;         /* pointer to the start of the string */
+
+    /* initialize the prefix fields */
+
+    if (prefix) {
+        prefix_len = strlen(prefix);
+        local_prefix = strdup(prefix);
+    } else {
+        prefix_len = 0;
+        local_prefix = NULL;
+    }
+
+    /* adjust the max width for any prefix */
+
+    w = width - prefix_len;
+
+    do {
+        /*
+         * if the string will fit on one line, point b to the end of the
+         * string
+         */
+
+        if (z < w) b = a + z;
+
+        /*
+         * if the string won't fit on one line, move b to where the
+         * end of the line should be, and then move b back until we
+         * find a space; if we don't find a space before we back b all
+         * the way up to a, just assign b to where the line should end.
+         */
+
+        else {
+            b = a + w;
+
+            if (word_boundary) {
+                while ((b >= a) && (!isspace(*b))) b--;
+                if (b <= a) b = a + w;
+            }
+        }
+
+        /* look for any newline inbetween a and b, and move b to it */
+
+        for (c = a; c < b; c++) if (*c == '\n') { b = c; break; }
+
+        /*
+         * copy the string that starts at a and ends at b, prepending
+         * with a prefix, if present
+         */
+
+        len = b-a;
+        len += prefix_len;
+        line = (char *) malloc(len+1);
+        if (local_prefix) strncpy(line, local_prefix, prefix_len);
+        strncpy(line + prefix_len, a, len - prefix_len);
+        line[len] = '\0';
+
+        /* append the new line to the array of text rows */
+
+        t->t = (char **) realloc(t->t, sizeof(char *) * (t->n + 1));
+        t->t[t->n] = line;
+        t->n++;
+
+        if (t->m < len) t->m = len;
+
+        /*
+         * adjust the length of the string and move the pointer to the
+         * beginning of the new line
+         */
+
+        z -= (b - a + 1);
+        a = b + 1;
+
+        /* move to the first non whitespace character (excluding newlines) */
+
+        if (word_boundary && isspace(*b)) {
+            while ((z) && (isspace(*a)) && (*a != '\n')) a++, z--;
+        } else {
+            if (!isspace(*b)) z++, a--;
+        }
+
+        if (local_prefix) {
+            for (i = 0; i < prefix_len; i++) local_prefix[i] = ' ';
+        }
+
+    } while (z > 0);
+
+    if (local_prefix) free(local_prefix);
+    free(buf);
+
+    return t;
+}
+
+
+/*
+ * nv_text_rows_append() - append the given msg to the existing TextRows
+ */
+
+void nv_text_rows_append(TextRows *t, const char *msg)
+{
+    int len;
+
+    t->t = realloc(t->t, sizeof(char *) * (t->n + 1));
+
+    if (msg) {
+        t->t[t->n] = strdup(msg);
+        len = strlen(msg);
+        if (t->m < len) t->m = len;
+    } else {
+        t->t[t->n] = NULL;
+    }
+
+    t->n++;
+}
+
+/*
+ * nv_concat_text_rows() - concatenate two text rows, storing the
+ * result in t0
+ */
+
+#define NV_MAX(x,y) ((x) > (y) ? (x) : (y))
+
+void nv_concat_text_rows(TextRows *t0, TextRows *t1)
+{
+    int n, i;
+
+    n = t0->n + t1->n;
+
+    t0->t = realloc(t0->t, sizeof(char *) * n);
+
+    for (i = 0; i < t1->n; i++) {
+        t0->t[i + t0->n] = strdup(t1->t[i]);
+    }
+
+    t0->m = NV_MAX(t0->m, t1->m);
+    t0->n = n;
+
+} /* nv_concat_text_rows() */
+
+
+/*
+ * nv_free_text_rows() - free the TextRows data structure allocated by
+ * nv_format_text_rows()
+ */
+
+void nv_free_text_rows(TextRows *t)
+{
+    int i;
+
+    if (!t) return;
+    for (i = 0; i < t->n; i++) free(t->t[i]);
+    if (t->t) free(t->t);
+    free(t);
+
+} /* nv_free_text_rows() */
+
+
+/****************************************************************************/
+/* printing helper functions */
+/****************************************************************************/
+
+#define DEFAULT_WIDTH 75
+
+static unsigned short __terminal_width = 0;
+
+/*
+ * reset_current_terminal_width() - if new_val is zero, then use the
+ * TIOCGWINSZ ioctl to get the current width of the terminal, and
+ * assign it the value to __terminal_width.  If the ioctl fails, use a
+ * hardcoded constant.  If new_val is non-zero, then use new_val.
+ */
+
+void reset_current_terminal_width(unsigned short new_val)
+{
+    struct winsize ws;
+
+    if (new_val) {
+        __terminal_width = new_val;
+        return;
+    }
+
+    if (ioctl(STDERR_FILENO, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
+        __terminal_width = DEFAULT_WIDTH;
+    } else {
+        __terminal_width = ws.ws_col - 1;
+    }
+}
+
+/*
+ * Call silence_fmt(1) to turn fmtout(), fmtoutp() and format() into noops.
+ */
+static int __silent = 0;
+
+void silence_fmt(int val)
+{
+    __silent = val;
+}
+
+
+static void vformat(FILE *stream, const int wb,
+                    const char *prefix, const char *buf)
+{
+    int i;
+    TextRows *t;
+
+    if (!__terminal_width) reset_current_terminal_width(0);
+
+    t = nv_format_text_rows(prefix, buf, __terminal_width, wb);
+
+    for (i = 0; i < t->n; i++) fprintf(stream, "%s\n", t->t[i]);
+
+    nv_free_text_rows(t);
+}
+
+
+#define NV_VFORMAT(stream, wb, prefix, fmt)     \
+do {                                            \
+    char *buf;                                  \
+    NV_VSNPRINTF(buf, fmt);                     \
+    vformat(stream, wb, prefix, buf);           \
+    free (buf);                                 \
+} while(0)
+
+
+void fmtout(const char *fmt, ...)
+{
+    if (__silent > 0) {
+        return;
+    }
+    NV_VFORMAT(stdout, TRUE, NULL, fmt);
+}
+
+
+void fmtoutp(const char *prefix, const char *fmt, ...)
+{
+    if (__silent > 0) {
+        return;
+    }
+    NV_VFORMAT(stdout, TRUE, prefix, fmt);
+}
+
+
+void fmterr(const char *fmt, ...)
+{
+    vformat(stderr, 0, NULL, "");
+    NV_VFORMAT(stderr, TRUE, "ERROR: ", fmt);
+    vformat(stderr, 0, NULL, "");
+}
+
+
+void fmtwarn(const char *fmt, ...)
+{
+    vformat(stderr, 0, NULL, "");
+    NV_VFORMAT(stderr, TRUE, "WARNING: ", fmt);
+    vformat(stderr, 0, NULL, "");
+}
+
+
+void fmt(FILE *stream, const char *prefix, const char *fmt, ...)
+{
+    if (__silent > 0) {
+        return;
+    }
+    NV_VFORMAT(stream, TRUE, prefix, fmt);
+}

=== modified file 'src/common-utils/common-utils.h'
--- src/common-utils/common-utils.h	2012-02-18 10:21:04 +0000
+++ src/common-utils/common-utils.h	2012-07-30 04:30:25 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 NVIDIA Corporation
+ * Copyright (C) 2010-2012 NVIDIA Corporation
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -17,6 +17,9 @@
 #ifndef __COMMON_UTILS_H__
 #define __COMMON_UTILS_H__
 
+#include <stdio.h>
+#include <stdarg.h>
+
 #if !defined(TRUE)
 #define TRUE 1
 #endif
@@ -25,13 +28,86 @@
 #define FALSE 0
 #endif
 
+#define ARRAY_LEN(_arr) (sizeof(_arr) / sizeof(_arr[0]))
+
+#define TAB "  "
+#define BIGTAB "      "
+
+typedef struct {
+    char **t; /* the text rows */
+    int n;    /* number of rows */
+    int m;    /* maximum row length */
+} TextRows;
+
 void *nvalloc(size_t size);
 char *nvstrcat(const char *str, ...);
 void *nvrealloc(void *ptr, size_t size);
 char *nvstrdup(const char *s);
+char *nvstrndup(const char *s, size_t n);
 char *nvstrtolower(char *s);
 void nvfree(void *s);
 
 char *tilde_expansion(const char *str);
 
+TextRows *nv_format_text_rows(const char *prefix,
+                              const char *str,
+                              int width, int word_boundary);
+void nv_text_rows_append(TextRows *t, const char *msg);
+void nv_concat_text_rows(TextRows *t0, TextRows *t1);
+void nv_free_text_rows(TextRows *t);
+
+void reset_current_terminal_width(unsigned short new_val);
+
+void silence_fmt(int val);
+void fmtout(const char *fmt, ...);
+void fmtoutp(const char *prefix, const char *fmt, ...);
+void fmterr(const char *fmt, ...);
+void fmtwarn(const char *fmt, ...);
+void fmt(FILE *stream, const char *prefix, const char *fmt, ...);
+
+/*
+ * NV_VSNPRINTF(): macro that assigns buf using vsnprintf().  This is
+ * correct for differing semantics of the vsnprintf() return value:
+ *
+ * -1 when the buffer is not long enough (glibc < 2.1)
+ *
+ *   or
+ *
+ * the length the string would have been if the buffer had been large
+ * enough (glibc >= 2.1)
+ *
+ * This macro allocates memory for buf; the caller should free it when
+ * done.
+ */
+
+#define NV_FMT_BUF_LEN 256
+
+#define NV_VSNPRINTF(buf, fmt)                                  \
+do {                                                            \
+    if (!fmt) {                                                 \
+        (buf) = NULL;                                           \
+    } else {                                                    \
+        va_list ap;                                             \
+        int len, current_len = NV_FMT_BUF_LEN;                  \
+                                                                \
+        (buf) = malloc(current_len);                            \
+                                                                \
+        while (1) {                                             \
+            va_start(ap, fmt);                                  \
+            len = vsnprintf((buf), current_len, (fmt), ap);     \
+            va_end(ap);                                         \
+                                                                \
+            if ((len > -1) && (len < current_len)) {            \
+                break;                                          \
+            } else if (len > -1) {                              \
+                current_len = len + 1;                          \
+            } else {                                            \
+                current_len += NV_FMT_BUF_LEN;                  \
+            }                                                   \
+            free(buf);                                          \
+            (buf) = malloc(current_len);                        \
+        }                                                       \
+    }                                                           \
+} while (0)
+
 #endif /* __COMMON_UTILS_H__ */

=== added file 'src/common-utils/gen-manpage-opts-helper.c'
--- src/common-utils/gen-manpage-opts-helper.c	1970-01-01 00:00:00 +0000
+++ src/common-utils/gen-manpage-opts-helper.c	2012-07-30 04:30:25 +0000
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "nvgetopt.h"
+#include "gen-manpage-opts-helper.h"
+
+static void print_option(const NVGetoptOption *o)
+{
+    char scratch[64], *s;
+    int j, len;
+
+    int italics, bold, omitWhiteSpace;
+
+    /* if we are going to need the argument, process it now */
+    if (o->flags & NVGETOPT_HAS_ARGUMENT) {
+        if (o->arg_name) {
+            strcpy(scratch, o->arg_name);
+        } else {
+            len = strlen(o->name);
+            for (j = 0; j < len; j++) scratch[j] = toupper(o->name[j]);
+            scratch[len] = '\0';
+        }
+    }
+
+    printf(".TP\n.BI \"");
+    /* Print the name of the option */
+    /* XXX We should backslashify the '-' characters in o->name. */
+
+    if (isalpha(o->val)) {
+        /* '\-c' */
+        printf("\\-%c", o->val);
+
+        if (o->flags & NVGETOPT_HAS_ARGUMENT) {
+            /* ' " "ARG" "' */
+            printf(" \" \"%s\" \"", scratch);
+        }
+        /* ', ' */
+        printf(", ");
+    }
+
+    /* '\-\-name' */
+    printf("\\-\\-%s", o->name);
+
+    /* '=" "ARG' */
+    if (o->flags & NVGETOPT_HAS_ARGUMENT) {
+        printf("=\" \"%s", scratch);
+
+        /* '" "' */
+        if ((o->flags & NVGETOPT_IS_BOOLEAN) ||
+            (o->flags & NVGETOPT_ALLOW_DISABLE)) {
+            printf("\" \"");
+        }
+    }
+
+    /* ', \-\-no\-name' */
+    if (((o->flags & NVGETOPT_IS_BOOLEAN) &&
+         !(o->flags & NVGETOPT_HAS_ARGUMENT)) ||
+        (o->flags & NVGETOPT_ALLOW_DISABLE)) {
+        printf(", \\-\\-no\\-%s", o->name);
+    }
+
+    printf("\"\n");
+
+    /* Print the option description */
+    /* XXX Each sentence should be on its own line! */
+
+    /*
+     * Print the option description:  write each character one at a
+     * time (ugh) so that we can special-case a few characters:
+     *
+     * '&' : toggles italics on and off
+     * '^' : toggles bold on and off
+     * '-' : is backslashified: "\-"
+     *
+     * Whitespace is omited when italics or bold is on
+     */
+
+    italics = 0;
+    bold = 0;
+    omitWhiteSpace = 0;
+
+    for (s = o->description; s && *s; s++) {
+
+        switch (*s) {
+          case '&':
+              if (italics) {
+                  printf("\n");
+              } else {
+                  printf("\n.I ");
+              }
+              omitWhiteSpace = italics;
+              italics = !italics;
+              break;
+          case '^':
+              if (bold) {
+                  printf("\n");
+              } else {
+                  printf("\n.B ");
+              }
+              omitWhiteSpace = bold;
+              bold = !bold;
+              break;
+          case '-':
+              printf("\\-");
+              omitWhiteSpace = 0;
+              break;
+          case ' ':
+              if (!omitWhiteSpace) {
+                  printf(" ");
+              }
+              break;
+          default:
+              printf("%c", *s);
+              omitWhiteSpace = 0;
+              break;
+        }
+    }
+
+    printf("\n");
+}
+
+void gen_manpage_opts_helper(const NVGetoptOption *options)
+{
+    int i;
+    int has_advanced_options = 0;
+
+    /* Print the "simple" options; i.e. the ones you get with --help. */
+    printf(".SH OPTIONS\n");
+    for (i = 0; options[i].name; i++) {
+        const NVGetoptOption *o = &options[i];
+
+        if (!o->description) {
+            continue;
+        }
+
+        if (!(o->flags & NVGETOPT_HELP_ALWAYS)) {
+            has_advanced_options = 1;
+            continue;
+        }
+
+        print_option(o);
+    }
+
+    if (has_advanced_options) {
+        /*
+         * If any exist, print the advanced options; i.e., the ones
+         * you get with --advanced-help
+         */
+        printf(".SH \"ADVANCED OPTIONS\"\n");
+        for (i = 0; options[i].name; i++) {
+            const NVGetoptOption *o = &options[i];
+
+            if (!o->description) {
+                continue;
+            }
+
+            if (o->flags & NVGETOPT_HELP_ALWAYS) {
+                continue;
+            }
+
+            print_option(o);
+        }
+    }
+}

=== added file 'src/common-utils/gen-manpage-opts-helper.h'
--- src/common-utils/gen-manpage-opts-helper.h	1970-01-01 00:00:00 +0000
+++ src/common-utils/gen-manpage-opts-helper.h	2012-07-30 04:30:25 +0000
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if !defined(__GEN_MANPAGE_OPTS_HELPER_H__)
+#define __GEN_MANPAGE_OPTS_HELPER_H__
+
+#include "nvgetopt.h"
+
+void gen_manpage_opts_helper(const NVGetoptOption *options);
+
+#endif /* __GEN_MANPAGE_OPTS_HELPER_H__ */

=== modified file 'src/common-utils/nvgetopt.c'
--- src/common-utils/nvgetopt.c	2012-02-18 10:21:04 +0000
+++ src/common-utils/nvgetopt.c	2012-07-30 04:30:25 +0000
@@ -21,8 +21,10 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <ctype.h>
 
 #include "nvgetopt.h"
+#include "common-utils.h"
 
 
 int nvgetopt(int argc,
@@ -309,3 +311,126 @@
     return ret;
 
 } /* nvgetopt() */
+
+
+/*
+ * cook_description() - the description string may contain text within
+ * special characters which are interpreted by the manpage generator.
+ * We want to omit those characters here.
+ */
+
+static char *cook_description(const char *description)
+{
+    const char *src;
+    char *s, *dst;
+
+    if (!description) {
+        return NULL;
+    }
+
+    s = strdup(description);
+
+    if (!s) {
+        return NULL;
+    }
+
+    for (src = description, dst = s; *src; src++) {
+        if ((*src == '&') || (*src == '^')) {
+            continue;
+        }
+        *dst = *src;
+        dst++;
+    }
+
+    *dst = '\0';
+
+    return s;
+}
+
+
+void nvgetopt_print_help(const NVGetoptOption *options,
+                         unsigned int include_mask,
+                         nvgetopt_print_help_callback_ptr callback)
+{
+    const NVGetoptOption *o;
+    int i;
+
+    for (i = 0; options[i].name; i++) {
+
+        char *msg = NULL, *arg = NULL, *description = NULL;
+
+        o = &options[i];
+
+        /* Skip options with no help text */
+        if (!o->description) {
+            continue;
+        }
+
+        /* skip options who don't have all the bits of include_mask */
+        if ((o->flags & include_mask) != include_mask) {
+            continue;
+        }
+
+        /* if we are going to need the argument, process it now */
+        arg = NULL;
+        if (o->flags & NVGETOPT_HAS_ARGUMENT) {
+            if (o->arg_name) {
+                arg = strdup(o->arg_name);
+            } else {
+                char *tmp;
+                arg = strdup(o->name);
+                for (tmp = arg; tmp && *tmp; tmp++) {
+                    *tmp = toupper(*tmp);
+                }
+            }
+        }
+
+        msg = NULL;
+
+        /*
+         * create the long version of the option, possibly with an
+         * argument; e.g., "--foo" or "--foo=BAR"
+         */
+        if (arg) {
+            msg = nvstrcat("--", o->name, "=", arg, NULL);
+        } else {
+            msg = nvstrcat("--", o->name, NULL);
+        }
+
+        /*
+         * prepend the single character version of the option,
+         * possibly with an argument; e.g., "-f" or "-f BAR"
+         */
+        if (isalpha(o->val)) {
+            char scratch[16];
+            char *tmp;
+            snprintf(scratch, sizeof(scratch), "%c", o->val);
+            if (arg) {
+                tmp = nvstrcat("-", scratch, " ", arg, ", ", msg, NULL);
+            } else {
+                tmp = nvstrcat("-", scratch, ", ", msg, NULL);
+            }
+            free(msg);
+            msg = tmp;
+        }
+
+        /* append the boolean version of the option; e.g., "--no-foo" */
+        if (((o->flags & NVGETOPT_IS_BOOLEAN) &&
+             !(o->flags & NVGETOPT_HAS_ARGUMENT)) ||
+            (o->flags & NVGETOPT_ALLOW_DISABLE)) {
+            char *tmp = nvstrcat(msg, ", --no-", o->name, NULL);
+            free(msg);
+            msg = tmp;
+        }
+
+        /* process the description text */
+        description = cook_description(o->description);
+
+        /* give the strings to the caller to format and print */
+        callback(msg, description);
+
+        free(msg);
+        free(arg);
+        free(description);
+    }
+}

=== modified file 'src/common-utils/nvgetopt.h'
--- src/common-utils/nvgetopt.h	2012-02-18 10:21:04 +0000
+++ src/common-utils/nvgetopt.h	2012-07-30 04:30:25 +0000
@@ -155,5 +155,29 @@
              double *doubleval,
              int *disable_val);
 
+/*
+ * nvgetopt_print_help() - print a help message for each option in the
+ * provided NVGetoptOption array.  This is useful for a utility's
+ * "--help" output.
+ *
+ * Options will only be printed if they have every bit set that
+ * include_mask includes.
+ *
+ * For each option, the provided callback function wil be called with
+ * two strings: a name string that lists the option's name, and a
+ * description string for the option.  The callback function is
+ * responsible for actually printing these strings.  Examples:
+ *
+ * name = "-v, --version";
+ * description = "Print usage information for the common commandline "
+ *     "options and exit.";
+ */
+
+typedef void nvgetopt_print_help_callback_ptr(const char *name,
+                                              const char *description);
+
+void nvgetopt_print_help(const NVGetoptOption *options,
+                         unsigned int include_mask,
+                         nvgetopt_print_help_callback_ptr callback);
 
 #endif /* __NVGETOPT_H__ */

=== modified file 'src/common-utils/src.mk'
--- src/common-utils/src.mk	2011-02-25 15:18:56 +0000
+++ src/common-utils/src.mk	2012-07-30 04:30:25 +0000
@@ -7,3 +7,9 @@
 COMMON_UTILS_EXTRA_DIST += common-utils.h
 COMMON_UTILS_EXTRA_DIST += src.mk
 
+# gen-manpage-opts-helper.c is listed in EXTRA_DIST, rather than SRC,
+# because it is not compiled into the utilities themselves, but used
+# when building the utility's gen-manpage-opts
+COMMON_UTILS_EXTRA_DIST += gen-manpage-opts-helper.c
+COMMON_UTILS_EXTRA_DIST += gen-manpage-opts-helper.h
+

=== modified file 'src/config-file.c'
--- src/config-file.c	2012-02-18 10:21:04 +0000
+++ src/config-file.c	2012-07-30 04:30:25 +0000
@@ -434,14 +434,14 @@
                 (p->display_device_mask);
             
             fprintf(stream, "%s%s%c%s[%s]=%d\n", p->display, target_str,
-                    DISPLAY_NAME_SEPARATOR, tmp, tmp_d_str, p->val);
+                    DISPLAY_NAME_SEPARATOR, tmp, tmp_d_str, p->val.i);
             
             free(tmp_d_str);
             
         } else {
                 
             fprintf(stream, "%s%s%c%s=%d\n", p->display, target_str,
-                    DISPLAY_NAME_SEPARATOR, tmp, p->val);
+                    DISPLAY_NAME_SEPARATOR, tmp, p->val.i);
         }
         
         p = p->next;

=== modified file 'src/gen-manpage-opts.c'
--- src/gen-manpage-opts.c	2012-02-18 10:21:04 +0000
+++ src/gen-manpage-opts.c	2012-07-30 04:30:25 +0000
@@ -24,119 +24,10 @@
 
 #include "nvgetopt.h"
 #include "option-table.h"
-
-#define NV_FMT_BUF_LEN 512
-
-/*
- * Prints the option help in a form that is suitable to include in the manpage.
- */
-
-static void print_option(const NVGetoptOption *o)
-{
-    int omitWhiteSpace;
-
-    /* if we are going to need the argument, process it now */
-
-    printf(".TP\n.BI \"");
-    /* Print the name of the option */
-    /* XXX We should backslashify the '-' characters in o->name. */
-
-    if (isalpha(o->val)) {
-        /* '\-c  \-\-name' */
-        printf("\\-%c, \\-\\-%s", o->val, o->name);
-    } else {
-        printf("\\-\\-%s", o->name);
-    }
-
-    /* '=" "ARG' */
-    if (o->flags & NVGETOPT_HAS_ARGUMENT) {
-        int len, j;
-        char tbuf[32];
-        len = strlen(o->name);
-        for (j = 0; j < len; j++)
-            tbuf[j] = toupper(o->name[j]);
-        tbuf[len] = '\0';
-        printf("=\" \"%s", tbuf);
-    }
-
-    printf("\"\n");
-
-    /* Print the option description */
-    /* XXX Each sentence should be on its own line! */
-
-    /*
-     * Print the option description:  write each character one at a
-     * time (ugh) so that we can special-case a few characters:
-     *
-     * "^" --> "\n.I "
-     * "<" --> "\n.B "
-     * ">" --> "\n"
-     *
-     * '^' is used to mark the text as underlined till it is turned off with '>'.
-     * '<' is used to mark the text as bold till it is turned off with '>'.
-     *
-     * XXX Each sentence should be on its own line!
-     */
-
-    if (o->description) {
-        char *buf = NULL, *s = NULL, *pbuf = NULL;
-
-        buf = calloc(1, NV_FMT_BUF_LEN + strlen(o->description));
-        if (!buf) {
-            /* XXX There should be better message than this */
-            printf("Not enough memory\n");
-            return;
-        }
-        pbuf = buf;
-
-        omitWhiteSpace = 0;
-        for (s = o->description; s && *s; s++) {
-            switch (*s) {
-            case '<':
-                sprintf(pbuf, "\n.B ");
-                pbuf = pbuf + 4;
-                omitWhiteSpace = 0;
-                break;
-            case '^':
-                sprintf(pbuf, "\n.I ");
-                pbuf = pbuf + 4;
-                omitWhiteSpace = 0;
-                break;
-            case '>':
-                *pbuf = '\n';
-                pbuf++;
-                omitWhiteSpace = 1;
-                break;
-            case ' ':
-                if (!omitWhiteSpace) {
-                    *pbuf = *s;
-                    pbuf++;
-                }
-                break;
-            default:
-                *pbuf = *s;
-                pbuf++;
-                omitWhiteSpace = 0;
-                break;
-            }
-        }
-        printf("%s", buf);
-        free(buf);
-    }
-
-    printf("\n");
-}
-
-int main(int argc, char* argv[])
-{
-    int i;
-    const NVGetoptOption *o;
-
-    printf(".SH OPTIONS\n");
-    for (i = 0; __options[i].name; i++) {
-        o = &__options[i];
-        print_option(o);
-    }
-
+#include "gen-manpage-opts-helper.h"
+
+int main(void)
+{
+    gen_manpage_opts_helper(__options);
     return 0;
 }

=== modified file 'src/glxinfo.c'
--- src/glxinfo.c	2012-02-18 10:21:04 +0000
+++ src/glxinfo.c	2012-07-30 04:30:25 +0000
@@ -25,6 +25,7 @@
 #include "NvCtrlAttributes.h"
 #include "query-assign.h" /* CtrlHandles */
 #include "msg.h"
+#include "glxinfo.h"
 
 #include <GL/glx.h> /* GLX #defines */
 

=== modified file 'src/gtk+-2.x/ctk3dvisionpro.c'
--- src/gtk+-2.x/ctk3dvisionpro.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctk3dvisionpro.c	2012-07-30 04:30:25 +0000
@@ -197,6 +197,7 @@
             sizeof (Ctk3DVisionPro),
             0,    /* n_preallocs */
             NULL, /* instance_init */
+            NULL  /* value_table */
         };
 
         ctk_3d_vision_pro_type = g_type_register_static(GTK_TYPE_VBOX,

=== modified file 'src/gtk+-2.x/ctkbanner.c'
--- src/gtk+-2.x/ctkbanner.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkbanner.c	2012-07-30 04:30:25 +0000
@@ -49,7 +49,6 @@
 #include "opengl_pixdata.h"
 #include "penguin_pixdata.h"
 #include "gvi_pixdata.h"
-#include "rotation_pixdata.h"
 #include "sdi_pixdata.h"
 #include "sdi_shared_sync_bnc_pixdata.h"
 #include "slimm_pixdata.h"
@@ -105,6 +104,7 @@
             sizeof (CtkBanner),
             0, /* n_preallocs */
             NULL, /* instance_init */
+            NULL  /* value_table */
         };
 
         ctk_banner_type = g_type_register_static(GTK_TYPE_DRAWING_AREA,
@@ -365,7 +365,6 @@
         { BANNER_ARTWORK_HELP,           FALSE, 16, &help_pixdata           },
         { BANNER_ARTWORK_OPENGL,         FALSE, 16, &opengl_pixdata         },
         { BANNER_ARTWORK_PENGUIN,        TRUE,  16, &penguin_pixdata        },
-        { BANNER_ARTWORK_ROTATION,       FALSE, 16, &rotation_pixdata       },
         { BANNER_ARTWORK_SDI,            FALSE, 16, &sdi_pixdata            },
         { BANNER_ARTWORK_SDI_SHARED_SYNC_BNC, FALSE, 16, &sdi_shared_sync_bnc_pixdata },
         { BANNER_ARTWORK_SLIMM,          FALSE, 16, &slimm_pixdata          },

=== modified file 'src/gtk+-2.x/ctkbanner.h'
--- src/gtk+-2.x/ctkbanner.h	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkbanner.h	2012-07-30 04:30:25 +0000
@@ -60,7 +60,6 @@
     BANNER_ARTWORK_HELP,
     BANNER_ARTWORK_OPENGL,
     BANNER_ARTWORK_PENGUIN,
-    BANNER_ARTWORK_ROTATION,
     BANNER_ARTWORK_SDI,
     BANNER_ARTWORK_SDI_SHARED_SYNC_BNC,
     BANNER_ARTWORK_SLIMM,

=== modified file 'src/gtk+-2.x/ctkclocks.c'
--- src/gtk+-2.x/ctkclocks.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkclocks.c	2012-07-30 04:30:25 +0000
@@ -165,6 +165,7 @@
             sizeof(CtkClocks),
             0, /* n_preallocs */
             NULL, /* instance_init */
+            NULL  /* value_table */
         };
 
         ctk_object_type = g_type_register_static

=== modified file 'src/gtk+-2.x/ctkcolorcontrols.c'
--- src/gtk+-2.x/ctkcolorcontrols.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkcolorcontrols.c	2012-07-30 04:30:25 +0000
@@ -43,6 +43,8 @@
 static
 gboolean update_color_space_menu_info(CtkColorControls *ctk_color_controls);
 
+static void setup_reset_button(CtkColorControls *ctk_color_controls);
+
 static void color_space_menu_changed(GtkOptionMenu *color_space_menu,
                                      gpointer user_data);
 static void color_range_menu_changed(GtkOptionMenu *color_range_menu,
@@ -90,6 +92,7 @@
             sizeof (CtkColorControls),
             0, /* n_preallocs */
             NULL, /* instance_init */
+            NULL  /* value_table */
         };
 
         ctk_color_controls_type =
@@ -105,7 +108,6 @@
                                   CtkConfig *ctk_config,
                                   CtkEvent *ctk_event,
                                   GtkWidget *reset_button,
-                                  unsigned int display_device_mask,
                                   char *name)
 {
     GObject *object;
@@ -117,12 +119,12 @@
     gint i;
 
     /* check if color configuration is supported */
-    ret1 = NvCtrlGetValidDisplayAttributeValues(handle, display_device_mask,
-                                                NV_CTRL_COLOR_SPACE,
-                                                &valid1);
-    ret2 = NvCtrlGetValidDisplayAttributeValues(handle, display_device_mask,
-                                                NV_CTRL_COLOR_RANGE,
-                                                &valid2);
+    ret1 = NvCtrlGetValidAttributeValues(handle,
+                                         NV_CTRL_COLOR_SPACE,
+                                         &valid1);
+    ret2 = NvCtrlGetValidAttributeValues(handle,
+                                         NV_CTRL_COLOR_RANGE,
+                                         &valid2);
 
     if ((ret1 != NvCtrlSuccess) || (ret2 != NvCtrlSuccess)) {
         return NULL;
@@ -138,7 +140,6 @@
     ctk_color_controls->handle = handle;
     ctk_color_controls->ctk_config = ctk_config;
     ctk_color_controls->reset_button = reset_button;
-    ctk_color_controls->display_device_mask = display_device_mask;
     ctk_color_controls->name = strdup(name);
 
     /* build a table holding available color space */
@@ -150,7 +151,7 @@
 
     hbox = gtk_hbox_new(FALSE, 0);
     gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, FRAME_PADDING);
-    ctk_color_controls->color_controls_main = hbox;
+    ctk_color_controls->color_controls_box = hbox;
 
     frame = gtk_frame_new("Color Controls");
     gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0);
@@ -210,7 +211,6 @@
     gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 
     hbox = gtk_hbox_new(FALSE, 0);
-    ctk_color_controls->color_space_box = hbox;
     gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 0, 1,
                      GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
     gtk_box_pack_start(GTK_BOX(hbox),
@@ -270,6 +270,50 @@
 } /* ctk_color_controls_new() */
 
 
+
+/*
+ * setup_reset_button() - enables the reset button if any of the current
+ * settings are not the default.
+ */
+static void setup_reset_button(CtkColorControls *ctk_color_controls)
+{
+    gint history;
+    gint val;
+
+    if (!GTK_WIDGET_SENSITIVE(ctk_color_controls->color_controls_box)) {
+        /* Nothing is available, don't bother enabling the reset button yet. */
+        return;
+    }
+
+    /* The color space menu is always available */
+    history = gtk_option_menu_get_history
+        (GTK_OPTION_MENU(ctk_color_controls->color_space_menu));
+    val = ctk_color_controls->color_space_table[history];
+    if (val != NV_CTRL_COLOR_SPACE_RGB) {
+        goto enable;
+    }
+
+    /* Color range is dependent on the color space */
+    if (GTK_WIDGET_SENSITIVE(ctk_color_controls->color_range_menu)) {
+        history = gtk_option_menu_get_history
+            (GTK_OPTION_MENU(ctk_color_controls->color_range_menu));
+        val = ctk_color_controls->color_range_table[history];
+        if (val != NV_CTRL_COLOR_RANGE_FULL) {
+            goto enable;
+        }
+    }
+
+    /* Don't disable reset button here, since other settings that are not
+     * managed by the ctk_image_slider here may need it enabled
+     */
+    return;
+
+ enable:
+    gtk_widget_set_sensitive(ctk_color_controls->reset_button, TRUE);
+}
+
+
+
 /*
  * ctk_color_controls_setup() - Setup routine for color attributes. Used
  * in DFP setup stage as well as for updating the GUI when there is change in
@@ -283,10 +327,12 @@
 
     /* color space */
     if (!update_color_space_menu_info(ctk_color_controls)) {
-        gtk_widget_set_sensitive(ctk_color_controls->color_controls_main,
-                                 FALSE);
-        gtk_widget_hide_all(ctk_color_controls->color_controls_main);
+        gtk_widget_set_sensitive(ctk_color_controls->color_controls_box, FALSE);
+        gtk_widget_hide_all(ctk_color_controls->color_controls_box);
     }
+
+    setup_reset_button(ctk_color_controls);
+
 } /* ctk_color_controls_setup() */
 
 
@@ -296,11 +342,9 @@
 
     /* color space */
     if (NvCtrlSuccess !=
-        NvCtrlGetDisplayAttribute(ctk_color_controls->handle,
-                                  ctk_color_controls->display_device_mask,
-                                  NV_CTRL_COLOR_SPACE,
-                                  &color_space)) {
-        free(ctk_color_controls->color_space_table);
+        NvCtrlGetAttribute(ctk_color_controls->handle,
+                           NV_CTRL_COLOR_SPACE,
+                           &color_space)) {
         return FALSE;
     }
 
@@ -322,9 +366,14 @@
          (gpointer) ctk_color_controls);
 
     /* dynamically regenerate color range dropdown */
-    setup_color_range_dropdown(ctk_color_controls);
-
-    return True;
+    if (!setup_color_range_dropdown(ctk_color_controls)) {
+        gtk_widget_set_sensitive(ctk_color_controls->color_range_menu, FALSE);
+    } else {
+        gtk_widget_set_sensitive(ctk_color_controls->color_range_menu, TRUE);
+    }
+
+    return TRUE;
+
 } /* update_color_space_menu_info() */
 
 static
@@ -370,10 +419,9 @@
     history = gtk_option_menu_get_history(color_range_menu);
     color_range = ctk_color_controls->color_range_table[history];
 
-    NvCtrlSetDisplayAttribute(ctk_color_controls->handle,
-                              ctk_color_controls->display_device_mask,
-                              NV_CTRL_COLOR_RANGE,
-                              color_range);
+    NvCtrlSetAttribute(ctk_color_controls->handle,
+                       NV_CTRL_COLOR_RANGE,
+                       color_range);
 
     g_signal_handlers_block_by_func
         (G_OBJECT(ctk_color_controls->color_range_menu),
@@ -406,10 +454,9 @@
 
     color_space = ctk_color_controls->color_space_table[history];
 
-    NvCtrlSetDisplayAttribute(ctk_color_controls->handle,
-                              ctk_color_controls->display_device_mask,
-                              NV_CTRL_COLOR_SPACE,
-                              color_space);
+    NvCtrlSetAttribute(ctk_color_controls->handle,
+                       NV_CTRL_COLOR_SPACE,
+                       color_space);
 
     color_space = map_nvctrl_value_to_table(ctk_color_controls,
                                             color_space);
@@ -444,15 +491,13 @@
         return;
     }
 
-    NvCtrlSetDisplayAttribute(ctk_color_controls->handle,
-                              ctk_color_controls->display_device_mask,
-                              NV_CTRL_COLOR_SPACE,
-                              NV_CTRL_COLOR_SPACE_RGB);
+    NvCtrlSetAttribute(ctk_color_controls->handle,
+                       NV_CTRL_COLOR_SPACE,
+                       NV_CTRL_COLOR_SPACE_RGB);
 
-    NvCtrlSetDisplayAttribute(ctk_color_controls->handle,
-                              ctk_color_controls->display_device_mask,
-                              NV_CTRL_COLOR_RANGE,
-                              NV_CTRL_COLOR_RANGE_FULL);
+    NvCtrlSetAttribute(ctk_color_controls->handle,
+                       NV_CTRL_COLOR_RANGE,
+                       NV_CTRL_COLOR_RANGE_FULL);
 
     ctk_color_controls_setup(ctk_color_controls);
 } /* ctk_color_controls_reset() */
@@ -487,14 +532,8 @@
     CtkColorControls *ctk_object = CTK_COLOR_CONTROLS(user_data);
     CtkEventStruct *event_struct = (CtkEventStruct *) arg1;
 
-    /* if the event is not for this display device, return */
-
-    if (!(event_struct->display_mask & ctk_object->display_device_mask)) {
-        return;
-    }
-
     ctk_color_controls_setup(ctk_object);
-    
+
     /* update status bar message */
     switch (event_struct->attribute) {
     case NV_CTRL_COLOR_RANGE:
@@ -557,10 +596,9 @@
     GtkWidget *menu, *menu_item;
     NVCTRLAttributeValidValuesRec valid;
 
-    ret = NvCtrlGetValidDisplayAttributeValues(ctk_color_controls->handle,
-                                               ctk_color_controls->display_device_mask,
-                                               NV_CTRL_COLOR_RANGE,
-                                               &valid);
+    ret = NvCtrlGetValidAttributeValues(ctk_color_controls->handle,
+                                        NV_CTRL_COLOR_RANGE,
+                                        &valid);
 
     if (valid.type != ATTRIBUTE_TYPE_INT_BITS) {
         return FALSE;
@@ -609,9 +647,9 @@
 
     /* color range */
     if (NvCtrlSuccess !=
-        NvCtrlGetDisplayAttribute(ctk_color_controls->handle,
-                                  ctk_color_controls->display_device_mask,
-                                  NV_CTRL_COLOR_RANGE, &val)) {
+        NvCtrlGetAttribute(ctk_color_controls->handle,
+                           NV_CTRL_COLOR_RANGE,
+                           &val)) {
         val = NV_CTRL_COLOR_RANGE_FULL;
     }
 
@@ -628,18 +666,16 @@
         (GTK_OPTION_MENU(ctk_color_controls->color_range_menu),
          val);
 
-    /* If dropdown only has one item, disable it */
-    if (ctk_color_controls->color_range_table_size > 1) {
-        gtk_widget_set_sensitive(ctk_color_controls->color_range_menu, True);
-    } else {
-        gtk_widget_set_sensitive(ctk_color_controls->color_range_menu, False);
-    }
-    
     g_signal_handlers_unblock_by_func
         (G_OBJECT(ctk_color_controls->color_range_menu),
          G_CALLBACK(color_range_menu_changed),
          (gpointer) ctk_color_controls);
 
+    /* If dropdown only has one item, disable it */
+    if (ctk_color_controls->color_range_table_size <= 1) {
+        return FALSE;
+    }
+
     return TRUE;
 
 } /* setup_color_range_dropdown() */

=== modified file 'src/gtk+-2.x/ctkcolorcontrols.h'
--- src/gtk+-2.x/ctkcolorcontrols.h	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkcolorcontrols.h	2012-07-30 04:30:25 +0000
@@ -55,14 +55,11 @@
     NvCtrlAttributeHandle *handle;
     CtkConfig *ctk_config;
     GtkWidget *reset_button;
-    GtkWidget *color_controls_main;
-    GtkWidget *color_space_box;
+    GtkWidget *color_controls_box;
 
     GtkWidget *color_range_menu;
     GtkWidget *color_space_menu;
-    GtkWidget *color_current_config;
 
-    gint display_device_mask;
     gint *color_space_table;
     gint color_space_table_size;
     gint *color_range_table;
@@ -81,7 +78,6 @@
 GtkWidget* ctk_color_controls_new (NvCtrlAttributeHandle *,
                                    CtkConfig *, CtkEvent *,
                                    GtkWidget *,
-                                   unsigned int display_device_mask,
                                    char *);
 
 void ctk_color_controls_reset (CtkColorControls*);

=== modified file 'src/gtk+-2.x/ctkcolorcorrection.c'
--- src/gtk+-2.x/ctkcolorcorrection.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkcolorcorrection.c	2012-07-30 04:30:25 +0000
@@ -143,6 +143,7 @@
             sizeof (CtkColorCorrection),
             0,    /* n_preallocs */
             NULL, /* instance_init */
+            NULL  /* value_table */
         };
 
         ctk_color_correction_type =
@@ -903,42 +904,42 @@
         switch (p->attr & (ALL_VALUES | ALL_CHANNELS)) {
         case (CONTRAST_VALUE | RED_CHANNEL):
             set_color_state(ctk_color_correction, CONTRAST,
-                            RED_CHANNEL, p->fval, TRUE); break;
+                            RED_CHANNEL, p->val.f, TRUE); break;
         case (CONTRAST_VALUE | GREEN_CHANNEL):
             set_color_state(ctk_color_correction, CONTRAST,
-                            GREEN_CHANNEL, p->fval, TRUE); break;
+                            GREEN_CHANNEL, p->val.f, TRUE); break;
         case (CONTRAST_VALUE | BLUE_CHANNEL):
             set_color_state(ctk_color_correction, CONTRAST,
-                            BLUE_CHANNEL, p->fval, TRUE); break;
+                            BLUE_CHANNEL, p->val.f, TRUE); break;
         case (CONTRAST_VALUE | ALL_CHANNELS):
             set_color_state(ctk_color_correction, CONTRAST,
-                            ALL_CHANNELS, p->fval, TRUE); break;
+                            ALL_CHANNELS, p->val.f, TRUE); break;
 
         case (BRIGHTNESS_VALUE | RED_CHANNEL):
             set_color_state(ctk_color_correction, BRIGHTNESS,
-                            RED_CHANNEL, p->fval, TRUE); break;
+                            RED_CHANNEL, p->val.f, TRUE); break;
         case (BRIGHTNESS_VALUE | GREEN_CHANNEL):
             set_color_state(ctk_color_correction, BRIGHTNESS,
-                            GREEN_CHANNEL, p->fval, TRUE); break;
+                            GREEN_CHANNEL, p->val.f, TRUE); break;
         case (BRIGHTNESS_VALUE | BLUE_CHANNEL):
             set_color_state(ctk_color_correction, BRIGHTNESS,
-                            BLUE_CHANNEL, p->fval, TRUE); break;
+                            BLUE_CHANNEL, p->val.f, TRUE); break;
         case (BRIGHTNESS_VALUE | ALL_CHANNELS):
             set_color_state(ctk_color_correction, BRIGHTNESS,
-                            ALL_CHANNELS, p->fval, TRUE); break;
+                            ALL_CHANNELS, p->val.f, TRUE); break;
 
         case (GAMMA_VALUE | RED_CHANNEL):
             set_color_state(ctk_color_correction, GAMMA,
-                            RED_CHANNEL, p->fval, TRUE); break;
+                            RED_CHANNEL, p->val.f, TRUE); break;
         case (GAMMA_VALUE | GREEN_CHANNEL):
             set_color_state(ctk_color_correction, GAMMA,
-                            GREEN_CHANNEL, p->fval, TRUE); break;
+                            GREEN_CHANNEL, p->val.f, TRUE); break;
         case (GAMMA_VALUE | BLUE_CHANNEL):
             set_color_state(ctk_color_correction, GAMMA,
-                            BLUE_CHANNEL, p->fval, TRUE); break;
+                            BLUE_CHANNEL, p->val.f, TRUE); break;
         case (GAMMA_VALUE | ALL_CHANNELS):
             set_color_state(ctk_color_correction, GAMMA,
-                            ALL_CHANNELS, p->fval, TRUE); break;
+                            ALL_CHANNELS, p->val.f, TRUE); break;
 
         default:
             goto next_attribute;

=== modified file 'src/gtk+-2.x/ctkconfig.c'
--- src/gtk+-2.x/ctkconfig.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkconfig.c	2012-07-30 04:30:25 +0000
@@ -102,6 +102,7 @@
             sizeof (CtkConfig),
             0,    /* n_preallocs */
             NULL, /* instance_init */
+            NULL  /* value_table */
         };
 
         ctk_config_type = g_type_register_static

=== modified file 'src/gtk+-2.x/ctkcursorshadow.c'
--- src/gtk+-2.x/ctkcursorshadow.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkcursorshadow.c	2012-07-30 04:30:25 +0000
@@ -176,6 +176,7 @@
             sizeof(CtkCursorShadow),
             0,    /* n_preallocs */
             NULL, /* instance_init */
+            NULL  /* value_table */
         };
         
         ctk_cursor_shadow_type = g_type_register_static

=== modified file 'src/gtk+-2.x/ctkcurve.c'
--- src/gtk+-2.x/ctkcurve.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkcurve.c	2012-07-30 04:30:25 +0000
@@ -68,6 +68,7 @@
             sizeof (CtkCurve),
             0, /* n_preallocs */
             NULL, /* instance_init */
+            NULL  /* value_table */
         };
 
         ctk_curve_type = g_type_register_static (GTK_TYPE_DRAWING_AREA,

=== modified file 'src/gtk+-2.x/ctkdisplayconfig-utils.c'
--- src/gtk+-2.x/ctkdisplayconfig-utils.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkdisplayconfig-utils.c	2012-07-30 04:30:25 +0000
@@ -41,7 +41,7 @@
 
 
 static void xconfig_update_buffer(GtkWidget *widget, gpointer user_data);
-
+static gchar *display_pick_config_name(nvDisplayPtr display, int be_generic);
 
 
 
@@ -432,6 +432,37 @@
 /*****************************************************************************/
 
 
+/** apply_mode_attribute_token() *************************************
+ *
+ * Modifies the nvMode structure (pointed to by data) with
+ * information from the token-value pair given.  Currently accepts
+ * stereo (mode) data.
+ *
+ * Unknown token and/or values are silently ignored.
+ *
+ **/
+static void apply_mode_attribute_token(char *token, char *value, void *data)
+{
+    nvModePtr mode = (nvModePtr)data;
+
+    if (!mode || !token || !strlen(token)) {
+        return;
+    }
+
+    /* stereo */
+    if (!strcasecmp("stereo", token)) {
+        if (!strcasecmp("PassiveLeft", value)) {
+            mode->passive_stereo_eye = PASSIVE_STEREO_EYE_LEFT;
+        } else if (!strcasecmp("PassiveRight", value)) {
+            mode->passive_stereo_eye = PASSIVE_STEREO_EYE_RIGHT;
+        }
+        return;
+    }
+
+} /* apply_mode_attribute_token() */
+
+
+
 /** mode_parse() *****************************************************
  *
  * Converts a mode string (dpy specific part of a metamode) to a
@@ -439,9 +470,10 @@
  *
  * Mode strings have the following format:
  *
- *   "mode_name +X+Y @WxH"
+ *   "mode_name +X+Y @WxH {token=value, ...}"
  *
  **/
+
 nvModePtr mode_parse(nvDisplayPtr display, const char *mode_str)
 {
     nvModePtr   mode;
@@ -484,7 +516,7 @@
         if (strcmp(mode_str, "NULL")) {
             nv_warning_msg("Mode name '%s' does not match any modelines for "
                            "display device '%s' in modeline '%s'.",
-                           mode_name, display->name, mode_str);
+                           mode_name, display->logName, mode_str);
         }
         mode->dim[W] = display->modelines->data.hdisplay;
         mode->dim[H] = display->modelines->data.vdisplay;
@@ -518,8 +550,29 @@
                                           &(mode->dim[X]), &(mode->dim[Y]));
         }
 
+        /* Read extra params */
+        else if (*str == '{') {
+            const char *end;
+            char *tmp;
+            str++;
+
+            end = strchr(str, '}');
+            if (!end) goto fail;
+
+            /* Dupe the string so we can parse it properly */
+            tmp = nvstrndup(str, (size_t)(end-str));
+            if (!tmp) goto fail;
+
+            parse_token_value_pairs(tmp, apply_mode_attribute_token, mode);
+            free(tmp);
+            if (end && (*end == '}')) {
+                str = ++end;
+            }
+        }
+
         /* Mode parse error - Ack! */
         else {
+            nv_error_msg("Unknown mode token: %s", str);
             str = NULL;
         }
 
@@ -567,46 +620,31 @@
 {
     gchar *mode_str;
     gchar *tmp;
-
+    gchar *flags_str;
+    nvDisplayPtr display = mode->display;
+    nvScreenPtr screen;
+    nvGpuPtr gpu;
 
     /* Make sure the mode has everything it needs to be displayed */
-    if (!mode || !mode->display || !mode->display->gpu || !mode->metamode) {
+    if (!mode || !mode->metamode || !display) {
         return NULL;
     }
 
-
     /* Don't display dummy modes */
     if (be_generic && mode->dummy && !mode->modeline) {
         return NULL;
     }
 
-
-    /* Only one display, be very generic (no 'CRT:' in metamode) */
-    if (be_generic && mode->display->gpu->num_displays == 1) {
-        mode_str = g_strdup("");
-
-    /* If there's more than one CRT/DFP/TV, we can't be generic. */
-    } else {
-        int generic = be_generic;
-
-        if ((mode->display->device_mask & 0x000000FF) &&
-            (mode->display->device_mask !=
-             (mode->display->gpu->connected_displays & 0x000000FF))) {
-            generic = 0;
-        }
-        if ((mode->display->device_mask & 0x0000FF00) &&
-            (mode->display->device_mask !=
-             (mode->display->gpu->connected_displays & 0x0000FF00))) {
-            generic = 0;
-        }
-        if ((mode->display->device_mask & 0x00FF0000) &&
-            (mode->display->device_mask !=
-             (mode->display->gpu->connected_displays & 0x00FF0000))) {
-            generic = 0;
-        }
-
-        /* Get the display type */
-        tmp = display_get_type_str(mode->display->device_mask, generic);
+    screen = display->screen;
+    gpu = display->gpu;
+    if (!screen || !gpu) {
+        return NULL;
+    }
+
+    /* Pick a suitable display name qualifier */
+    mode_str = display_pick_config_name(display, be_generic);
+    if (mode_str[0] != '\0') {
+        tmp = mode_str;
         mode_str = g_strconcat(tmp, ": ", NULL);
         g_free(tmp);
     }
@@ -663,6 +701,42 @@
     mode_str = tmp;
 
 
+    /* Mode Flags */
+    flags_str = NULL;
+
+    /* Passive Stereo Eye */
+    if (screen->stereo_supported && screen->stereo == 4) {
+        const char *eye;
+
+        switch (mode->passive_stereo_eye) {
+        case PASSIVE_STEREO_EYE_LEFT:
+            eye = "PassiveLeft";
+            break;
+        case PASSIVE_STEREO_EYE_RIGHT:
+            eye = "PassiveRight";
+            break;
+        case 0:
+        default:
+            eye = NULL;
+            break;
+        }
+
+        if (eye) {
+            tmp = g_strdup_printf("%s, stereo=%s", (flags_str ? flags_str : ""), eye);
+            g_free(flags_str);
+            flags_str = tmp;
+        }
+    }
+
+    if (flags_str) {
+        tmp = g_strdup_printf("%s {%s}",
+                              mode_str,
+                              flags_str+2 // Skip the first comma and whitespace
+                              );
+        g_free(mode_str);
+        mode_str = tmp;
+    }
+
     return mode_str;
 
 } /* mode_get_str() */
@@ -675,56 +749,67 @@
 /*****************************************************************************/
 
 
-/** display_get_type_str() *******************************************
- *
- * Returns the type name of a display (CRT, CRT-1, DFP ..)
- *
- * If 'generic' is set to 1, then a generic version of the name is
- * returned.
- *
- **/
-gchar *display_get_type_str(unsigned int device_mask, int be_generic)
-{
-    unsigned int  bit = 0;
-    int           num;
-    gchar        *name = NULL;
-    gchar        *type_name;
-
-
-    /* Get the generic type name of the display */
-    if (device_mask & 0x000000FF) {
-        name = g_strdup("CRT");
-        bit  = (device_mask & 0x000000FF);
-
-    } else if (device_mask & 0x0000FF00) {
-        name = g_strdup("TV");
-        bit  = (device_mask & 0x0000FF00) >> 8;
-
-    } else if (device_mask & 0x00FF0000) {
-        name = g_strdup("DFP");
-        bit  = (device_mask & 0x00FF0000) >> 16;
-    }
-
-    if (be_generic || !name) {
-        return name;
-    }
-
-    /* Add the specific display number to the name */
-    num = 0;
-    while (bit) {
-        num++;
-        bit >>= 1;
-    }
-    if (num) {
-        num--;
-    }
-
-    type_name = g_strdup_printf("%s-%d", name, num);
-    g_free(name);
-
-    return type_name;
-
-} /* display_get_type_str() */
+/** display_names_match() ********************************************
+ *
+ * Determines if two (display) names are the same.  Returns FALSE if
+ * either name is NULL.
+ *
+ **/
+
+static Bool display_names_match(const char *name1, const char *name2)
+{
+    if (!name1 || !name2) {
+        return FALSE;
+    }
+
+    return (strcasecmp(name1, name2) == 0) ? TRUE : FALSE;
+}
+
+
+
+/** display_pick_config_name() ***************************************
+ *
+ * Returns one of the display's names to be used for writing
+ * configuration.
+ *
+ * If 'generic' is TRUE, then the most generic name possible is
+ * returned.  This depends on the current existence of other display
+ * devices, and the name returned here will not collide with the name
+ * of other display devices.
+ *
+ **/
+static gchar *display_pick_config_name(nvDisplayPtr display, int be_generic)
+{
+    nvDisplayPtr other;
+
+    /* Be specific */
+    if (!be_generic) {
+        goto return_specific;
+    }
+
+    /* Only one display, so no need for a qualifier */
+    if (display->gpu->num_displays == 1) {
+        return g_strdup("");
+    }
+
+    /* Find the best generic name possible.  If any display connected to the
+     * GPU has the same typeBaseName, then return the typeIdName instead
+     */
+    for (other = display->gpu->displays; other; other = other->next_on_gpu) {
+        if (other == display) continue;
+        if (strcmp(other->typeBaseName, display->typeBaseName) == 0) {
+            goto return_specific;
+        }
+    }
+
+    /* No other display device on the GPU shares the same type basename,
+     * so we can use it
+     */
+    return g_strdup(display->typeBaseName);
+
+ return_specific:
+    return g_strdup(display->typeIdName);
+}
 
 
 
@@ -896,9 +981,9 @@
      */
     broken_doublescan_modelines = 1;
 
-    ret = NvCtrlGetAttribute(display->gpu->handle,
+    ret = NvCtrlGetAttribute(display->handle,
                              NV_CTRL_ATTR_NV_MAJOR_VERSION, &major);
-    ret1 = NvCtrlGetAttribute(display->gpu->handle,
+    ret1 = NvCtrlGetAttribute(display->handle,
                               NV_CTRL_ATTR_NV_MINOR_VERSION, &minor);
 
     if ((ret == NvCtrlSuccess) && (ret1 == NvCtrlSuccess) &&
@@ -912,17 +997,14 @@
 
 
     /* Get the validated modelines for the display */
-    ret = NvCtrlGetBinaryAttribute(display->gpu->handle,
-                                   display->device_mask,
+    ret = NvCtrlGetBinaryAttribute(display->handle, 0,
                                    NV_CTRL_BINARY_DATA_MODELINES,
                                    (unsigned char **)&modeline_strs, &len);
     if (ret != NvCtrlSuccess) {
         *err_str = g_strdup_printf("Failed to query modelines of display "
-                                   "device 0x%08x '%s'\nconnected to "
-                                   "GPU-%d '%s'.",
-                                   display->device_mask, display->name,
-                                   NvCtrlGetTargetId(display->gpu->handle),
-                                   display->gpu->name);
+                                  "device %d '%s'.",
+                                   NvCtrlGetTargetId(display->handle),
+                                   display->logName);
         nv_error_msg(*err_str);
         goto fail;
     }
@@ -936,12 +1018,9 @@
         if (!modeline) {
             *err_str = g_strdup_printf("Failed to parse the following "
                                        "modeline of display device\n"
-                                       "0x%08x '%s' connected to GPU-%d "
-                                       "'%s':\n\n%s",
-                                       display->device_mask,
-                                       display->name,
-                                       NvCtrlGetTargetId(display->gpu->handle),
-                                       display->gpu->name,
+                                      "%d '%s' :\n\n%s",
+                                       NvCtrlGetTargetId(display->handle),
+                                       display->logName,
                                        str);
             nv_error_msg(*err_str);
             goto fail;
@@ -1030,7 +1109,13 @@
     if (display) {
         display_remove_modes(display);
         display_remove_modelines(display);
-        XFree(display->name);
+        XFree(display->logName);
+        XFree(display->typeBaseName);
+        XFree(display->typeIdName);
+        XFree(display->dpGuidName);
+        XFree(display->edidHashName);
+        XFree(display->targetIdName);
+        XFree(display->randrName);
         free(display);
     }
 
@@ -1040,17 +1125,64 @@
 
 
 /*****************************************************************************/
-/** METAMODE FUNCTIONS *******************************************************/
-/*****************************************************************************/
-
-
-
-
-/*****************************************************************************/
 /** SCREEN FUNCTIONS *********************************************************/
 /*****************************************************************************/
 
 
+/** screen_find_named_display() **************************************
+ *
+ * Finds a display named 'display_name' in the list of displays on the
+ * given screen, or NULL if no display matched 'display_name'.
+ *
+ **/
+
+static nvDisplayPtr screen_find_named_display(nvScreenPtr screen,
+                                              char *display_name)
+{
+    nvDisplayPtr display;
+    nvDisplayPtr possible_display = NULL;
+
+    if (!display_name) {
+        return NULL;
+    }
+
+    /* Look for exact matches */
+    for (display = screen->displays;
+         display;
+         display = display->next_in_screen) {
+
+        /* Look for an exact match */
+        if (display_names_match(display->typeIdName, display_name)) {
+            return display;
+        }
+        if (display_names_match(display->dpGuidName, display_name)) {
+            return display;
+        }
+        if (display_names_match(display->targetIdName, display_name)) {
+            return display;
+        }
+        if (display_names_match(display->randrName, display_name)) {
+            return display;
+        }
+
+        /* Allow matching to generic names, but only return these
+         * if no other name matched
+         */
+        if (!possible_display) {
+            if (display_names_match(display->typeBaseName, display_name)) {
+                possible_display = display;
+            }
+            if (display_names_match(display->edidHashName, display_name)) {
+                possible_display = display;
+            }
+        }
+    }
+
+    return possible_display;
+}
+
+
+
 /** renumber_xscreens() **********************************************
  *
  * Ensures that the screens are numbered from 0 to (n-1).
@@ -1114,7 +1246,6 @@
             }
         }
     }
-    screen->displays_mask |= display->device_mask;
     screen->num_displays++;
 
 } /* screen_link_display() */
@@ -1147,7 +1278,6 @@
             cur = cur->next_in_screen;
         }
     }
-    screen->displays_mask &= ~(display->device_mask);
     screen->num_displays--;
 
     display->screen = NULL;
@@ -1292,6 +1422,47 @@
 
 
 
+ /** mode_strtok() ***************************************************
+ *
+ * Special strtok function for parsing modes.  This function ignores
+ * anything between curly braces, including commas when parsing tokens
+ * deliminated by commas.
+ *
+ **/
+static char *mode_strtok(char *str)
+{
+    static char *intStr = NULL;
+    char *start;
+
+    if (str) {
+        intStr = str;
+    }
+
+    if (!intStr || *intStr == '\0') {
+        return NULL;
+    }
+
+    /* Mark off the next token value */
+    start = intStr;
+    while (*intStr != '\0') {
+        if (*intStr == '{') {
+            while (*intStr != '}' && *intStr != '\0') {
+                intStr++;
+            }
+        }
+        if (*intStr == ',') {
+            *intStr = '\0';
+            intStr++;
+            break;
+        }
+        intStr++;
+    }
+
+    return start;
+}
+
+
+
 /** screen_add_metamode() ********************************************
  *
  * Parses a metamode string and adds the appropriate modes to the
@@ -1342,35 +1513,35 @@
     metamode_copy = strdup(metamode_modes);
     if (!metamode_copy) goto fail;
 
-    for (mode_str_itr = strtok(metamode_copy, ",");
+    for (mode_str_itr = mode_strtok(metamode_copy);
          mode_str_itr;
-         mode_str_itr = strtok(NULL, ",")) {
+         mode_str_itr = mode_strtok(NULL)) {
 
         nvModePtr     mode;
-        unsigned int  device_mask;
         nvDisplayPtr  display;
+        unsigned int  display_id;
         const char *orig_mode_str = parse_skip_whitespace(mode_str_itr);
         const char *mode_str;
 
-        /* Parse the display device bitmask from the name */
-        mode_str = parse_read_display_name(mode_str_itr, &device_mask);
+        /* Parse the display device (NV-CONTROL target) id from the name */
+        mode_str = parse_read_display_id(mode_str_itr, &display_id);
         if (!mode_str) {
             nv_warning_msg("Failed to read a display device name on screen %d "
-                           "(on GPU-%d)\nwhile parsing metamode:\n\n'%s'",
+                           "while parsing metamode:\n\n'%s'",
                            screen->scrnum,
-                           NvCtrlGetTargetId(screen->gpu->handle),
+
                            orig_mode_str);
             continue;
         }
 
-        /* Match device bitmask to an existing display */
-        display = gpu_get_display(screen->gpu, device_mask);
+        /* Match device id to an existing display */
+        display = layout_get_display(screen->layout, display_id);
         if (!display) {
-            nv_warning_msg("Failed to find display device 0x%08x on screen %d "
-                           "(on GPU-%d)\nwhile parsing metamode:\n\n'%s'",
-                           device_mask,
+            nv_warning_msg("Failed to find display device %d on screen %d "
+                           "while parsing metamode:\n\n'%s'",
+                           display_id,
                            screen->scrnum,
-                           NvCtrlGetTargetId(screen->gpu->handle),
+
                            orig_mode_str);
             continue;
         }
@@ -1378,10 +1549,10 @@
         /* Parse the mode */
         mode = mode_parse(display, mode_str);
         if (!mode) {
-            nv_warning_msg("Failed to parse mode '%s'\non screen %d (on GPU-%d)"
-                           "\nfrom metamode:\n\n'%s'",
-                           mode_str, screen->scrnum,
-                           NvCtrlGetTargetId(screen->gpu->handle),
+            nv_warning_msg("Failed to parse mode '%s'\non screen %d\n"
+                           "from metamode:\n\n'%s'",
+                           mode_str,
+                           screen->scrnum,
                            orig_mode_str);
             continue;
         }
@@ -1512,7 +1683,7 @@
  * match the top left of the first non-dummy mode
  *
  **/
-void screen_assign_dummy_metamode_positions(nvScreenPtr screen)
+static void screen_assign_dummy_metamode_positions(nvScreenPtr screen)
 {
     nvDisplayPtr display;
     nvModePtr ok_mode;
@@ -1565,7 +1736,7 @@
 
     /* Get the list of metamodes for the screen */
     ret = NvCtrlGetBinaryAttribute(screen->handle, 0,
-                                   NV_CTRL_BINARY_DATA_METAMODES,
+                                   NV_CTRL_BINARY_DATA_METAMODES_VERSION_2,
                                    (unsigned char **)&metamode_strs,
                                    &len);
     if (ret != NvCtrlSuccess) {
@@ -1580,7 +1751,7 @@
 
     /* Get the current metamode for the screen */
     ret = NvCtrlGetStringAttribute(screen->handle,
-                                   NV_CTRL_STRING_CURRENT_METAMODE,
+                                   NV_CTRL_STRING_CURRENT_METAMODE_VERSION_2,
                                    &cur_metamode_str);
     if (ret != NvCtrlSuccess) {
         *err_str = g_strdup_printf("Failed to query current metamode of\n"
@@ -1700,26 +1871,6 @@
 /*****************************************************************************/
 
 
-/** gpu_get_display() ************************************************
- *
- * Returns the display with the matching device_mask or NULL if not
- * found.
- *
- **/
-nvDisplayPtr gpu_get_display(nvGpuPtr gpu, unsigned int device_mask)
-{
-    nvDisplayPtr display;
-
-    for (display = gpu->displays; display; display = display->next_on_gpu) {
-        if (display->device_mask == device_mask) return display;
-    }
-
-    return NULL;
-
-} /* gpu_get_display() */
-
-
-
 /** gpu_remove_and_free_display() ************************************
  *
  * Removes a display from the GPU and frees it.
@@ -1756,7 +1907,6 @@
             }
         }
     }
-    gpu->connected_displays &= ~(display->device_mask);
     gpu->num_displays--;
 
     display_free(display);
@@ -1777,7 +1927,6 @@
     while (gpu->displays) {
         gpu_remove_and_free_display(gpu->displays);
     }
-    gpu->connected_displays = 0;
 
 } /* gpu_remove_displays() */
 
@@ -1808,7 +1957,6 @@
             }
         }
     }
-    gpu->connected_displays |= display->device_mask;
     gpu->num_displays++;
 
 } /* gpu_add_display() */
@@ -1857,17 +2005,74 @@
 }
 
 
+
+/** display_add_name_from_server() ***********************************
+ *
+ *  Queries and adds the NV-CONTROL name to the display device.
+ *
+ **/
+
+static const struct DisplayNameInfoRec {
+    int attr;
+    Bool canBeNull;
+    const char *nameDescription;
+    size_t offset;
+} DisplayNamesTable[] = {
+    { NV_CTRL_STRING_DISPLAY_DEVICE_NAME,        FALSE, "Log Name",
+      offsetof(nvDisplay, logName) },
+    { NV_CTRL_STRING_DISPLAY_NAME_TYPE_BASENAME, FALSE, "Type Base Name",
+      offsetof(nvDisplay, typeBaseName) },
+    { NV_CTRL_STRING_DISPLAY_NAME_TYPE_ID,       FALSE, "Type ID",
+      offsetof(nvDisplay, typeIdName) },
+    { NV_CTRL_STRING_DISPLAY_NAME_DP_GUID,       TRUE,  "DP GUID Name",
+      offsetof(nvDisplay, dpGuidName) },
+    { NV_CTRL_STRING_DISPLAY_NAME_EDID_HASH,     TRUE,  "EDID Hash Name",
+      offsetof(nvDisplay, edidHashName) },
+    { NV_CTRL_STRING_DISPLAY_NAME_TARGET_INDEX,  FALSE, "Target Index Name",
+      offsetof(nvDisplay, targetIdName) },
+    { NV_CTRL_STRING_DISPLAY_NAME_RANDR,         FALSE, "RandR Name",
+      offsetof(nvDisplay, randrName) },
+};
+
+static Bool display_add_name_from_server(nvDisplayPtr display,
+                                         const struct DisplayNameInfoRec *displayNameInfo,
+                                         gchar **err_str)
+{
+    ReturnStatus ret;
+    char *str;
+
+    ret = NvCtrlGetStringAttribute(display->handle,
+                                   displayNameInfo->attr,
+                                   &str);
+    if (ret == NvCtrlSuccess) {
+        *((char **)(((char *)display) + displayNameInfo->offset)) = str;
+
+    } else if (!displayNameInfo->canBeNull) {
+        *err_str = g_strdup_printf("Failed to query name '%s' of display "
+                                   "device DPY-%d.",
+                                   displayNameInfo->nameDescription,
+                                   NvCtrlGetTargetId(display->handle));
+        nv_error_msg(*err_str);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+
+
 /** gpu_add_display_from_server() ************************************
  *
- *  Adds the display with the device mask given to the GPU structure.
+ *  Adds the display with the device id given to the GPU structure.
  *
  **/
 nvDisplayPtr gpu_add_display_from_server(nvGpuPtr gpu,
-                                         unsigned int device_mask,
+                                         unsigned int display_id,
                                          gchar **err_str)
 {
     ReturnStatus ret;
     nvDisplayPtr display;
+    int i;
 
 
     /* Create the display structure */
@@ -1875,34 +2080,40 @@
     if (!display) goto fail;
 
 
-    /* Init the display structure */
-    display->device_mask = device_mask;
+    /* Make an NV-CONTROL handle to talk to the display */
+    display->handle =
+        NvCtrlAttributeInit(NvCtrlGetDisplayPtr(gpu->handle),
+                            NV_CTRL_TARGET_TYPE_DISPLAY,
+                            display_id,
+                            NV_CTRL_ATTRIBUTES_NV_CONTROL_SUBSYSTEM);
+    if (!display->handle) {
+        *err_str = g_strdup_printf("Failed to create NV-CONTROL handle for\n"
+                                   "display %d (on GPU-%d).",
+                                   display_id,
+                                   NvCtrlGetTargetId(gpu->handle));
+        nv_error_msg(*err_str);
+        goto fail;
+    }
 
 
     /* Query the display information */
-    ret = NvCtrlGetStringDisplayAttribute(gpu->handle,
-                                          device_mask,
-                                          NV_CTRL_STRING_DISPLAY_DEVICE_NAME,
-                                          &(display->name));
-    if (ret != NvCtrlSuccess) {
-        *err_str = g_strdup_printf("Failed to query name of display device\n"
-                                   "0x%08x connected to GPU-%d '%s'.",
-                                   device_mask, NvCtrlGetTargetId(gpu->handle),
-                                   gpu->name);
-        nv_error_msg(*err_str);
-        goto fail;
+    for (i = 0; i < ARRAY_LEN(DisplayNamesTable); i++) {
+        if (!display_add_name_from_server(display,
+                                          DisplayNamesTable + i, err_str)) {
+            goto fail;
+        }
     }
 
 
     /* Query if this display is an SDI display */
-    ret = NvCtrlGetDisplayAttribute(gpu->handle, device_mask,
-                                    NV_CTRL_IS_GVO_DISPLAY,
-                                    &(display->is_sdi));
+    ret = NvCtrlGetAttribute(display->handle,
+                             NV_CTRL_IS_GVO_DISPLAY,
+                             &(display->is_sdi));
     if (ret != NvCtrlSuccess) {
         nv_warning_msg("Failed to query if display device\n"
-                       "0x%08x connected to GPU-%d '%s' is an\n"
+                       "%d connected to GPU-%d '%s' is an\n"
                        "SDI device.",
-                       device_mask, NvCtrlGetTargetId(gpu->handle),
+                       display_id, NvCtrlGetTargetId(gpu->handle),
                        gpu->name);
         display->is_sdi = FALSE;
     }
@@ -1995,9 +2206,9 @@
 
     /* Query the modelines for the display device */
     if (!display_add_modelines_from_server(display, err_str)) {
-        nv_warning_msg("Failed to add modelines to display device 0x%08x "
+        nv_warning_msg("Failed to add modelines to display device %d "
                        "'%s'\nconnected to GPU-%d '%s'.",
-                       device_mask, display->name,
+                       display_id, display->logName,
                        NvCtrlGetTargetId(gpu->handle), gpu->name);
         goto fail;
     }
@@ -2023,38 +2234,44 @@
 static Bool gpu_add_displays_from_server(nvGpuPtr gpu, gchar **err_str)
 {
     ReturnStatus ret;
-    unsigned int mask;
+    int *pData;
+    int len;
+    int i;
 
 
     /* Clean up the GPU list */
     gpu_remove_displays(gpu);
 
-
-    /* Get the list of connected displays */
-    ret = NvCtrlGetAttribute(gpu->handle, NV_CTRL_CONNECTED_DISPLAYS,
-                             (int *)&(gpu->connected_displays));
+    /* Get list of displays connected to this GPU */
+    ret = NvCtrlGetBinaryAttribute(gpu->handle, 0,
+                                   NV_CTRL_BINARY_DATA_DISPLAYS_CONNECTED_TO_GPU,
+                                   (unsigned char **)(&pData), &len);
     if (ret != NvCtrlSuccess) {
-        *err_str = g_strdup_printf("Failed to query connected display "
-                                   "devices on GPU-%d '%s'.",
-                                   NvCtrlGetTargetId(gpu), gpu->name);
+        *err_str = g_strdup_printf("Failed to query list of displays \n"
+                                   "connected to GPU-%d '%s'.",
+                                   NvCtrlGetTargetId(gpu->handle), gpu->name);
         nv_error_msg(*err_str);
         goto fail;
     }
 
-
     /* Add each connected display */
-    for (mask = 1; mask; mask <<= 1) {
-
-        if (!(mask & (gpu->connected_displays))) continue;
-
-        if (!gpu_add_display_from_server(gpu, mask, err_str)) {
-            nv_warning_msg("Failed to add display device 0x%08x to GPU-%d "
+    for (i = 0; i < pData[0]; i++) {
+        if (!gpu_add_display_from_server(gpu, pData[i+1], err_str)) {
+            nv_warning_msg("Failed to add display device %d to GPU-%d "
+
+
+
+
+
                            "'%s'.",
-                           mask, NvCtrlGetTargetId(gpu->handle), gpu->name);
+                           pData[i+1], NvCtrlGetTargetId(gpu->handle),
+                           gpu->name);
+            XFree(pData);
             goto fail;
         }
     }
 
+    XFree(pData);
     return TRUE;
 
  fail:
@@ -2508,8 +2725,8 @@
         NvCtrlAttributeInit(display,
                             NV_CTRL_TARGET_TYPE_X_SCREEN,
                             screen_id,
-                            NV_CTRL_ATTRIBUTES_NV_CONTROL_SUBSYSTEM |
-                            NV_CTRL_ATTRIBUTES_XRANDR_SUBSYSTEM);
+                            NV_CTRL_ATTRIBUTES_NV_CONTROL_SUBSYSTEM);
+
     if (!screen->handle) {
         *err_str = g_strdup_printf("Failed to create NV-CONTROL handle for\n"
                                    "screen %d.",
@@ -2519,6 +2736,15 @@
     }
 
 
+    /* Query the current stereo mode */
+    ret = NvCtrlGetAttribute(screen->handle, NV_CTRL_STEREO, &val);
+    if (ret == NvCtrlSuccess) {
+        screen->stereo_supported = TRUE;
+        screen->stereo = val;
+    } else {
+        screen->stereo_supported = FALSE;
+    }
+
     /* See if the screen supports dynamic twinview */
     ret = NvCtrlGetAttribute(screen->handle, NV_CTRL_DYNAMIC_TWINVIEW, &val);
     if (ret != NvCtrlSuccess) {
@@ -2595,20 +2821,27 @@
 
         /* Query & parse the screen's primary display */
         screen->primaryDisplay = NULL;
-        ret = NvCtrlGetStringDisplayAttribute
-            (screen->handle,
-             0,
-             NV_CTRL_STRING_TWINVIEW_XINERAMA_INFO_ORDER,
-             &primary_str);
-
-        if (ret == NvCtrlSuccess) {
-            unsigned int  device_mask;
-
-            /* Parse the device mask */
-            parse_read_display_name(primary_str, &device_mask);
-
-            /* Find the matching primary display */
-            screen->primaryDisplay = gpu_get_display(screen->gpu, device_mask);
+        ret = NvCtrlGetStringAttribute(screen->handle,
+                                       NV_CTRL_STRING_NVIDIA_XINERAMA_INFO_ORDER,
+                                       &primary_str);
+
+        if (ret == NvCtrlSuccess && primary_str) {
+            char *str;
+
+            /* The TwinView Xinerana Info Order string may be a comma-separated
+             * list of display device names, though we could add full support
+             * for ordering these, just keep track of a single display here.
+             */
+            str = strchr(primary_str, ',');
+            if (!str) {
+                str = nvstrdup(primary_str);
+            } else {
+                str = nvstrndup(primary_str, str-primary_str);
+            }
+            XFree(primary_str);
+
+            screen->primaryDisplay = screen_find_named_display(screen, str);
+            nvfree(str);
         }
     }
 
@@ -2724,7 +2957,7 @@
 {
     nvLayoutPtr layout = NULL;
     ReturnStatus ret;
-
+    int tmp;
 
     /* Allocate the layout structure */
     layout = (nvLayoutPtr)calloc(1, sizeof(nvLayout));
@@ -2744,6 +2977,19 @@
         goto fail;
     }
 
+    /* does the driver know about NV_CTRL_CURRENT_METAMODE_ID? */
+    ret = NvCtrlGetAttribute(handle, NV_CTRL_CURRENT_METAMODE_ID, &tmp);
+    if (ret != NvCtrlSuccess) {
+        char *displayName = NvCtrlGetDisplayName(handle);
+        *err_str = g_strdup_printf("The NVIDIA X driver on %s is not new\n"
+                                   "enough to support the nvidia-settings "
+                                   "Display Configuration page.",
+                                   displayName ? displayName : "this X server");
+        free(displayName);
+        nv_warning_msg(*err_str);
+        goto fail;
+    }
+
     if (!layout_add_gpus_from_server(layout, err_str)) {
         nv_warning_msg("Failed to add GPU(s) to layout for display "
                        "configuration page.");
@@ -2807,6 +3053,35 @@
 
 
 
+/** layout_get_display() *********************************************
+ *
+ * Returns the display with the matching display id or NULL if not
+ * found.
+ *
+ **/
+nvDisplayPtr layout_get_display(const nvLayoutPtr layout,
+                                const unsigned int display_id)
+{
+    nvGpuPtr gpu;
+    nvDisplayPtr display;
+
+    for (gpu = layout->gpus; gpu; gpu = gpu->next_in_layout) {
+        for (display = gpu->displays;
+             display;
+             display = display->next_on_gpu) {
+
+            if (NvCtrlGetTargetId(display->handle) == display_id) {
+                return display;
+            }
+        }
+    }
+
+    return NULL;
+
+} /* layout_get_display() */
+
+
+
 
 /*****************************************************************************/
 /** XCONFIG FUNCTIONS ********************************************************/

=== modified file 'src/gtk+-2.x/ctkdisplayconfig-utils.h'
--- src/gtk+-2.x/ctkdisplayconfig-utils.h	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkdisplayconfig-utils.h	2012-07-30 04:30:25 +0000
@@ -59,7 +59,6 @@
 
 /* Display functions */
 
-gchar * display_get_type_str(unsigned int device_mask, int be_generic);
 int display_find_closest_mode_matching_modeline(nvDisplayPtr display,
                                                 nvModeLinePtr modeline);
 Bool display_has_modeline(nvDisplayPtr display, nvModeLinePtr modeline);
@@ -82,10 +81,9 @@
 
 /* GPU functions */
 
-nvDisplayPtr gpu_get_display(nvGpuPtr gpu, unsigned int device_mask);
 void gpu_remove_and_free_display(nvDisplayPtr display);
 nvDisplayPtr gpu_add_display_from_server(nvGpuPtr gpu,
-                                         unsigned int device_mask,
+                                         unsigned int display_id,
                                          gchar **err_str);
 
 Bool gpu_add_screenless_modes_to_displays(nvGpuPtr gpu);
@@ -98,6 +96,8 @@
 nvLayoutPtr layout_load_from_server(NvCtrlAttributeHandle *handle,
                                     gchar **err_str);
 nvScreenPtr layout_get_a_screen(nvLayoutPtr layout, nvGpuPtr preferred_gpu);
+nvDisplayPtr layout_get_display(const nvLayoutPtr layout,
+                                const unsigned int display_id);
 void layout_remove_and_free_screen(nvScreenPtr screen);
 
 

=== modified file 'src/gtk+-2.x/ctkdisplayconfig.c'
--- src/gtk+-2.x/ctkdisplayconfig.c	2012-02-18 10:21:04 +0000
+++ src/gtk+-2.x/ctkdisplayconfig.c	2012-07-30 04:30:25 +0000
@@ -48,12 +48,19 @@
 
 static void setup_layout_frame(CtkDisplayConfig *ctk_object);
 
+static void setup_selected_item_dropdown(CtkDisplayConfig *ctk_object);
+
+static void selected_item_changed(GtkWidget *widget, gpointer user_data);
+
+static void update_selected_page(CtkDisplayConfig *ctk_object);
+
 static void setup_display_page(CtkDisplayConfig *ctk_object);
 
 static void display_config_changed(GtkWidget *widget, gpointer user_data);
 static void display_resolution_changed(GtkWidget *widget, gpointer user_data);
 static void display_refresh_changed(GtkWidget *widget, gpointer user_data);
-static void display_modelname_changed(GtkWidget *widget, gpointer user_data);
+
+static void display_stereo_changed(GtkWidget *widget, gpointer user_data);
 
 static void display_position_type_changed(GtkWidget *widget, gpointer user_data);
 static void display_position_offset_activate(GtkWidget *widget, gpointer user_data);
@@ -71,6 +78,8 @@
 
 static void screen_depth_changed(GtkWidget *widget, gpointer user_data);
 
+static void screen_stereo_changed(GtkWidget *widget, gpointer user_data);
+
 static void screen_position_type_changed(GtkWidget *widget, gpointer user_data);
 static void screen_position_offset_activate(GtkWidget *widget, gpointer user_data);
 static void screen_position_relative_changed(GtkWidget *widget, gpointer user_data);
@@ -157,12 +166,12 @@
 "this option will require restarting your X server.  Note that when Xinerama "
 "is enabled, resolution changes will also require restarting your X server.";
 
+static const char * __selected_item_help =
+"The Selection drop-down allows you to pick which X screen or display device "
+"to configure.";
 
 /* Display tooltips */
 
-static const char * __dpy_model_help =
-"The Display drop-down allows you to select a desired display device.";
-
 static const char * __dpy_configuration_mnu_help =
 "The Configure drop-down allows you to select the desired configuration "
 "for the currently selected display device.";
@@ -176,6 +185,11 @@
 "for the currently selected display device.  Note that the selected "
 "resolution may restrict the available refresh rates.";
 
+static const char * __dpy_stereo_help =
+"The Display Passive Stereo Eye drop-down allows you to select a desired "
+"stereo eye the display should output when Passive Stereo (Mode 4) is "
+"selected enabled.";
+
 static const char * __dpy_position_type_help =
 "The Position Type drop-down allows you to set how the selected display "
 "device is placed within the X screen.  This is only available when "
@@ -213,6 +227,10 @@
 "The Depth drop-down allows setting of the color quality for the selected "
 "screen; changing this option will require restarting your X server.";
 
+static const char * __screen_stereo_help =
+"The Stereo Mode drop-down allows setting of the stereo mode for the selected "
+"screen; changing this option will require restarting your X server.";
+
 static const char * __screen_position_type_help =
 "The Position Type drop-down appears when two or more display devices are active.  "
 "This allows you to set how the selected screen "
@@ -381,12 +399,7 @@
         if (!screen->handle) continue;
 
         g_signal_connect(G_OBJECT(screen->ctk_event),
-                         CTK_EVENT_NAME(NV_CTRL_STRING_TWINVIEW_XINERAMA_INFO_ORDER),
-                         G_CALLBACK(display_config_attribute_changed),
-                         (gpointer) ctk_object);
-
-        g_signal_connect(G_OBJECT(screen->ctk_event),
-                         CTK_EVENT_NAME(NV_CTRL_ASSOCIATED_DISPLAY_DEVICES),
+                         CTK_EVENT_NAME(NV_CTRL_STRING_NVIDIA_XINERAMA_INFO_ORDER),
                          G_CALLBACK(display_config_attribute_changed),
                          (gpointer) ctk_object);
 
@@ -497,33 +510,12 @@
 
 /** update_btn_apply() **************************************************
  *
- * Updates the apply button's sensitvity (if possible)
+ * Updates the apply button's sensitivity
  *
  **/
 
-void update_btn_apply(CtkDisplayConfig *ctk_object, Bool sensitive)
+static void update_btn_apply(CtkDisplayConfig *ctk_object, Bool sensitive)
 {
-    Bool xrandr_available = FALSE;
-    nvLayoutPtr layout = ctk_object->layout;
-    nvScreenPtr screen;
-
-
-    if (sensitive) {
-        /* If none of the screens support XRandR, we can't apply */
-        for (screen = layout->screens;
-             screen;
-             screen = screen->next_in_layout) {
-            if (NvCtrlGetXrandrEventBase(screen->handle) >= 0) {
-                xrandr_available = TRUE;
-                break;
-            }
-        }
-
-        if (!xrandr_available && !ctk_object->primary_display_changed) {
-            sensitive = FALSE;
-        }
-    }
-
     gtk_widget_set_sensitive(ctk_object->btn_apply, sensitive);
 
 } /* update_btn_apply() */
@@ -697,7 +689,7 @@
                  GTK_DIALOG_DESTROY_WITH_PARENT,
                  GTK_MESSAGE_WARNING,
                  GTK_BUTTONS_NONE,
-                 msg);
+                 "%s", msg);
             
             gtk_dialog_add_buttons(GTK_DIALOG(dlg),
                                    "Truncate MetaModes",
@@ -874,6 +866,7 @@
             sizeof(CtkDisplayConfig),
             0, /* n_preallocs */
             NULL, /* instance_init */
+            NULL  /* value_table */
         };
 
         ctk_display_config_type = g_type_register_static
@@ -892,7 +885,7 @@
  *
  **/
 
-GtkWidget * create_validation_dialog(CtkDisplayConfig *ctk_object)
+static GtkWidget * create_validation_dialog(CtkDisplayConfig *ctk_object)
 {
     GtkWidget *dialog;
     GtkWidget *image;
@@ -989,7 +982,7 @@
  *
  **/
 
-GtkWidget * create_validation_apply_dialog(CtkDisplayConfig *ctk_object)
+static GtkWidget * create_validation_apply_dialog(CtkDisplayConfig *ctk_object)
 {
     GtkWidget *dialog;
     GtkWidget *image;
@@ -1013,7 +1006,7 @@
          GTK_DIALOG_DESTROY_WITH_PARENT,
          NULL);
     ctk_object->dlg_validation_apply = dialog;
-    
+
     /* Main horizontal box */
     hbox = gtk_hbox_new(FALSE, 5);
     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
@@ -1024,11 +1017,11 @@
                                      GTK_ICON_SIZE_DIALOG);
     gtk_misc_set_alignment(GTK_MISC(image), 0.0f, 0.0f);
     gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 5);
-    
+
     /* Main vertical box */
     vbox = gtk_vbox_new(FALSE, 5);
     gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5);
-    
+
     /* Pack the main message */
     str = g_strdup_printf("The current settings cannot be completely applied\n"
                           "due to one or more of the following reasons:\n"
@@ -1047,7 +1040,7 @@
     g_free(str);
     gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.0f);
     gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
-        
+
     /* Action Buttons */
     gtk_dialog_add_button(GTK_DIALOG(dialog), "Apply What Is Possible",
                           GTK_RESPONSE_ACCEPT);
@@ -1129,6 +1122,24 @@
 
 
 
+/** update_gui() *****************************************************
+ *
+ * Sync state of all widgets to reflect current configuration
+ *
+ **/
+
+static void update_gui(CtkDisplayConfig *ctk_object)
+{
+    setup_display_page(ctk_object);
+    setup_screen_page(ctk_object);
+    setup_selected_item_dropdown(ctk_object);
+    update_selected_page(ctk_object);
+    setup_layout_frame(ctk_object);
+
+} /* update_gui() */
+
+
+
 /** ctk_display_config_new() *****************************************
  *
  * Display Configuration widget creation.
@@ -1143,14 +1154,17 @@
 
     GtkWidget *banner;
     GtkWidget *frame;
-    GtkWidget *notebook;
     GtkWidget *hbox;
     GtkWidget *vbox;
     GdkScreen *screen;
     GtkWidget *label;
     GtkWidget *eventbox;
+    GtkWidget *hseparator;
     GtkRequisition req;
 
+    GSList *labels = NULL;
+    GSList *slitem;
+    gint max_width;
 
     GtkWidget *menu;
     GtkWidget *menu_item;
@@ -1286,12 +1300,12 @@
                      (gpointer) ctk_object);
 
 
-    /* Display model name */
-    ctk_object->mnu_display_model = gtk_option_menu_new();
-    ctk_config_set_tooltip(ctk_config, ctk_object->mnu_display_model,
-                           __dpy_model_help);
-    g_signal_connect(G_OBJECT(ctk_object->mnu_display_model), "changed",
-                     G_CALLBACK(display_modelname_changed),
+    /* Selected display/X screen dropdown */
+    ctk_object->mnu_selected_item = gtk_option_menu_new();
+    ctk_config_set_tooltip(ctk_config, ctk_object->mnu_selected_item,
+                           __selected_item_help);
+    g_signal_connect(G_OBJECT(ctk_object->mnu_selected_item), "changed",
+                     G_CALLBACK(selected_item_changed),
                      (gpointer) ctk_object);
 
     /* Display configuration (Disabled, TwinView, Separate X screen) */
@@ -1352,6 +1366,23 @@
     ctk_object->txt_display_modename = gtk_label_new("");
     gtk_label_set_selectable(GTK_LABEL(ctk_object->txt_display_modename), TRUE);
 
+    /* Display passive stereo eye dropdown */
+    ctk_object->mnu_display_stereo = gtk_option_menu_new();
+    menu = gtk_menu_new();
+    menu_item = gtk_menu_item_new_with_label("None");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("Left");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("Right");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    gtk_option_menu_set_menu
+        (GTK_OPTION_MENU(ctk_object->mnu_display_stereo), menu);
+    ctk_config_set_tooltip(ctk_config, ctk_object->mnu_display_stereo,
+                           __dpy_stereo_help);
+    g_signal_connect(G_OBJECT(ctk_object->mnu_display_stereo),
+                     "changed", G_CALLBACK(display_stereo_changed),
+                     (gpointer) ctk_object);
+
     /* Display Position Type (Absolute/Relative Menu) */
     ctk_object->mnu_display_position_type = gtk_option_menu_new();
     menu = gtk_menu_new();
@@ -1404,11 +1435,6 @@
                      G_CALLBACK(display_panning_focus_out),
                      (gpointer) ctk_object);
 
-    /* X screen number */
-    ctk_object->txt_screen_num = gtk_label_new("");
-    gtk_label_set_selectable(GTK_LABEL(ctk_object->txt_screen_num), TRUE);
-    gtk_misc_set_alignment(GTK_MISC(ctk_object->txt_screen_num), 0.0f, 0.5f);
-
     /* X screen virtual size */
     ctk_object->txt_screen_virtual_size = gtk_entry_new();
     ctk_config_set_tooltip(ctk_config, ctk_object->txt_screen_virtual_size,
@@ -1429,6 +1455,41 @@
                      G_CALLBACK(screen_depth_changed),
                      (gpointer) ctk_object);
 
+    /* Screen Stereo Mode */
+    ctk_object->mnu_screen_stereo = gtk_option_menu_new();
+    menu = gtk_menu_new();
+    menu_item = gtk_menu_item_new_with_label("Disabled");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("DCC Glasses");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("BlueLine Glasses");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("Onboard (DIN)");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("Passive Eye Per Display");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("Vertical Interlaced");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("Color Interleaved");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("Horizontal Interlaced");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("Checkerboard 3D DLP");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("Inverse Checkerboard 3D DLP");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("NVIDIA 3D Vision");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    menu_item = gtk_menu_item_new_with_label("NVIDIA 3D Vision Pro");
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+    gtk_option_menu_set_menu
+        (GTK_OPTION_MENU(ctk_object->mnu_screen_stereo), menu);
+    ctk_config_set_tooltip(ctk_config, ctk_object->mnu_screen_stereo,
+                           __screen_stereo_help);
+    g_signal_connect(G_OBJECT(ctk_object->mnu_screen_stereo),
+                     "changed", G_CALLBACK(screen_stereo_changed),
+                     (gpointer) ctk_object);
+
     /* Screen Position Type (Absolute/Relative Menu) */
     ctk_object->mnu_screen_position_type = gtk_option_menu_new();
     menu = gtk_menu_new();
@@ -1599,14 +1660,6 @@
                      G_CALLBACK(save_clicked),
                      (gpointer) ctk_object);
 
-
-
-    /****
-     *
-     * Pack the widgets
-     *
-     ***/
-
     { /* Layout section */
 
         frame = gtk_frame_new("Layout"); /* main panel */
@@ -1624,52 +1677,42 @@
         gtk_box_pack_start(GTK_BOX(vbox), ctk_object->chk_xinerama_enabled,
                            FALSE, FALSE, 0);
     }
-    
-
-    /* Panel for the notebook sections */
-    notebook = gtk_notebook_new();
-    ctk_object->notebook = notebook;
-    gtk_box_pack_start(GTK_BOX(ctk_object), notebook, FALSE, FALSE, 0);
+
+
+    /* Selection */