From b3082aae2d49769c62d9c5911705324da15fb632 Mon Sep 17 00:00:00 2001 From: Eric Mehl Date: Thu, 22 Aug 2024 14:43:53 -0400 Subject: [PATCH] fixup! ColorChooser : Maintain options state per-session --- python/GafferUI/ColorChooser.py | 9 + .../GafferUI/ColorChooserPlugValueWidget.py | 113 ++++++--- python/GafferUI/ColorSwatchPlugValueWidget.py | 74 +++--- python/GafferUITest/ColorChooserTest.py | 219 ++++++++---------- 4 files changed, 222 insertions(+), 193 deletions(-) diff --git a/python/GafferUI/ColorChooser.py b/python/GafferUI/ColorChooser.py index b10fb6945a..50a6a124d2 100644 --- a/python/GafferUI/ColorChooser.py +++ b/python/GafferUI/ColorChooser.py @@ -570,6 +570,7 @@ def __init__( self, color=imath.Color3f( 1 ), **kw ) : self.__visibleComponentsChangedSignal = Gaffer.Signals.Signal1() self.__staticComponentChangedSignal = Gaffer.Signals.Signal1() self.__colorFieldVisibleChangedSignal = Gaffer.Signals.Signal1() + self.__optionsMenuSignal = Gaffer.Signals.Signal2() self.__updateUIFromColor() self.__activateComponentIcons() @@ -683,6 +684,13 @@ def colorFieldVisibleChangedSignal( self ) : return self.__colorFieldVisibleChangedSignal + ## A signal emitted whenever the options menu is opened. + # Slots should have the signature slot( ColorChooser, menuDefinition ) + # and add menu items to `menuDefinition`. + def optionsMenuSignal( self ) : + + return self.__optionsMenuSignal + ## Returns True if a user would expect the specified sequence # of changes to be merged into a single undoable event. @classmethod @@ -740,6 +748,7 @@ def __optionsMenuDefinition( self ) : } ) + self.__optionsMenuSignal( self, result ) return result diff --git a/python/GafferUI/ColorChooserPlugValueWidget.py b/python/GafferUI/ColorChooserPlugValueWidget.py index ab189e1f41..9f6f07e3b1 100644 --- a/python/GafferUI/ColorChooserPlugValueWidget.py +++ b/python/GafferUI/ColorChooserPlugValueWidget.py @@ -53,16 +53,17 @@ def __init__( self, plugs, **kw ) : self.__colorChooser.setSwatchesVisible( False ) - options = self.__colorChooserOptions() + visibleComponents = self.__colorChooserOption( "visibleComponents" ) + if visibleComponents is not None : + self.__colorChooser.setVisibleComponents( visibleComponents ) - if "visibleComponents" in options : - self.__colorChooser.setVisibleComponents( options["visibleComponents"].value ) + staticComponent = self.__colorChooserOption( "staticComponent" ) + if staticComponent is not None : + self.__colorChooser.setColorFieldStaticComponent( staticComponent ) - if "staticComponent" in options : - self.__colorChooser.setColorFieldStaticComponent( options["staticComponent"].value ) - - if "colorFieldVisible" in options : - self.__colorChooser.setColorFieldVisible( options["colorFieldVisible"].value ) + colorFieldVisible = self.__colorChooserOption( "colorFieldVisible" ) + if colorFieldVisible is not None : + self.__colorChooser.setColorFieldVisible( colorFieldVisible ) self.__colorChangedConnection = self.__colorChooser.colorChangedSignal().connect( Gaffer.WeakMethod( self.__colorChanged ) @@ -77,6 +78,10 @@ def __init__( self, plugs, **kw ) : self.__colorChooser.colorFieldVisibleChangedSignal().connect( functools.partial( Gaffer.WeakMethod( self.__colorChooserColorFieldVisibleChanged ) ) ) + self.__colorChooser.optionsMenuSignal().connect( + functools.partial( Gaffer.WeakMethod( self.__colorChooserOptionsMenu ) ), + scoped = False + ) self.__lastChangedReason = None self.__mergeGroupId = 0 @@ -114,45 +119,43 @@ def __colorChanged( self, colorChooser, reason ) : for plug in self.getPlugs() : plug.setValue( self.__colorChooser.getColor() ) - def __colorChooserOptionChanged( self, value, key ) : - - if Gaffer.Metadata.value( "colorChooser:inlineOptions", "userDefault" ) is None : - sessionOptions = Gaffer.Metadata.value( "colorChooser:inlineOptions", "sessionDefault" ) - if sessionOptions is None : - sessionOptions = IECore.CompoundData() - Gaffer.Metadata.registerValue( "colorChooser:inlineOptions", "sessionDefault", sessionOptions ) - - sessionOptions.update( { key: value } ) + def __colorChooserOptionChanged( self, keySuffix, value ) : for p in self.getPlugs() : - plugOptions = Gaffer.Metadata.value( p, "colorChooser:inlineOptions" ) - if plugOptions is None : - plugOptions = IECore.CompoundData() - Gaffer.Metadata.registerValue( p, "colorChooser:inlineOptions", plugOptions, persistent = False ) + Gaffer.Metadata.deregisterValue( p, "colorChooser:inline:" + keySuffix ) + Gaffer.Metadata.registerValue( p, "colorChooser:inline:" + keySuffix, value, persistent = False ) + + def __colorChooserOption( self, keySuffix ) : - plugOptions.update( { key: value } ) + return sole( Gaffer.Metadata.value( p, "colorChooser:inline:" + keySuffix ) for p in self.getPlugs() ) def __colorChooserVisibleComponentsChanged( self, colorChooser ) : - self.__colorChooserOptionChanged( colorChooser.getVisibleComponents(), "visibleComponents" ) + self.__colorChooserOptionChanged( "visibleComponents", colorChooser.getVisibleComponents() ) def __colorChooserStaticComponentChanged( self, colorChooser ) : - self.__colorChooserOptionChanged( colorChooser.getColorFieldStaticComponent(), "staticComponent" ) + self.__colorChooserOptionChanged( "staticComponent", colorChooser.getColorFieldStaticComponent() ) def __colorChooserColorFieldVisibleChanged( self, colorChooser ) : - self.__colorChooserOptionChanged( colorChooser.getColorFieldVisible(), "colorFieldVisible" ) + self.__colorChooserOptionChanged( "colorFieldVisible", colorChooser.getColorFieldVisible() ) - def __colorChooserOptions( self ) : + def __colorChooserOptionsMenu( self, colorChooser, menuDefinition ) : - v = sole( Gaffer.Metadata.value( p, "colorChooser:inlineOptions" ) for p in self.getPlugs() ) - if v is None : - v = Gaffer.Metadata.value( "colorChooser:inlineOptions", "userDefault" ) - if v is None : - v = Gaffer.Metadata.value( "colorChooser:inlineOptions", "sessionDefault" ) or IECore.CompoundData() + menuDefinition.append( "/__saveDefaultOptions__", { "divider": True, "label": "Defaults" } ) - return v + menuDefinition.append( + "/Save Inline Defaults", + { + "command": functools.partial( + saveDefaultOptions, + colorChooser, + "colorChooser:inline:", + self.ancestor( GafferUI.ScriptWindow ).scriptNode().applicationRoot().preferencesLocation() / "__colorChooser.py" + ), + } + ) def __allComponentsEditable( self ) : @@ -168,3 +171,49 @@ def __allComponentsEditable( self ) : return False return True + +def saveDefaultOptions( colorChooser, keyPrefix, scriptPath = None ) : + + for k in [ "visibleComponents", "staticComponent", "colorFieldVisible" ] : + Gaffer.Metadata.deregisterValue( Gaffer.Color3fPlug, keyPrefix + k ) + Gaffer.Metadata.deregisterValue( Gaffer.Color4fPlug, keyPrefix + k ) + + visibleComponents = colorChooser.getVisibleComponents() + Gaffer.Metadata.registerValue( Gaffer.Color3fPlug, keyPrefix + "visibleComponents", visibleComponents ) + Gaffer.Metadata.registerValue( Gaffer.Color4fPlug, keyPrefix + "visibleComponents", visibleComponents ) + + staticComponent = colorChooser.getColorFieldStaticComponent() + Gaffer.Metadata.registerValue( Gaffer.Color3fPlug, keyPrefix + "staticComponent", staticComponent ) + Gaffer.Metadata.registerValue( Gaffer.Color4fPlug, keyPrefix + "staticComponent", staticComponent ) + + colorFieldVisible = colorChooser.getColorFieldVisible() + Gaffer.Metadata.registerValue( Gaffer.Color3fPlug, keyPrefix + "colorFieldVisible", colorFieldVisible ) + Gaffer.Metadata.registerValue( Gaffer.Color4fPlug, keyPrefix + "colorFieldVisible", colorFieldVisible ) + + if scriptPath is None : + return + + if scriptPath.is_dir() : + raise RuntimeError( f"Cannot write Color Chooser default options script \"{scriptPath}\", a directory at that path exists.") + + if scriptPath.exists() : + with open( scriptPath, "r" ) as inFile : + script = inFile.readlines() + else : + script = [ + "# This file was automatically generated by Gaffer.\n", + "# Do not edit this file - it will be overwritten.\n", + "\n", + "import Gaffer\n", + "\n" + ] + + newScript = [l for l in script if keyPrefix not in l] + + for c in [ "3", "4" ] : + newScript.append( f"Gaffer.Metadata.registerValue( Gaffer.Color{c}fPlug, \"{keyPrefix}visibleComponents\", \"{visibleComponents}\" )\n" ) + newScript.append( f"Gaffer.Metadata.registerValue( Gaffer.Color{c}fPlug, \"{keyPrefix}staticComponent\", \"{staticComponent}\" )\n" ) + newScript.append( f"Gaffer.Metadata.registerValue( Gaffer.Color{c}fPlug, \"{keyPrefix}colorFieldVisible\", {colorFieldVisible} )\n" ) + + with open( scriptPath, "w" ) as outFile : + outFile.writelines( newScript ) \ No newline at end of file diff --git a/python/GafferUI/ColorSwatchPlugValueWidget.py b/python/GafferUI/ColorSwatchPlugValueWidget.py index a81f60d1fe..a204cc2711 100644 --- a/python/GafferUI/ColorSwatchPlugValueWidget.py +++ b/python/GafferUI/ColorSwatchPlugValueWidget.py @@ -44,6 +44,7 @@ import Gaffer import GafferUI from GafferUI.PlugValueWidget import sole +from GafferUI.ColorChooserPlugValueWidget import saveDefaultOptions class ColorSwatchPlugValueWidget( GafferUI.PlugValueWidget ) : @@ -146,6 +147,10 @@ def __init__( self, plugs, parentWindow ) : self.colorChooser().colorFieldVisibleChangedSignal().connect( functools.partial( Gaffer.WeakMethod( self.__colorChooserColorFieldVisibleChanged ) ) ) + self.colorChooser().optionsMenuSignal().connect( + functools.partial( Gaffer.WeakMethod( self.__colorChooserOptionsMenu ) ), + scoped = False + ) self.confirmButton.clickedSignal().connect( Gaffer.WeakMethod( self.__buttonClicked ) ) self.cancelButton.clickedSignal().connect( Gaffer.WeakMethod( self.__buttonClicked ) ) @@ -166,16 +171,17 @@ def __init__( self, plugs, parentWindow ) : self.__plugSet( plug ) - options = self.__colorChooserOptions() - - if "visibleComponents" in options : - self.colorChooser().setVisibleComponents( options["visibleComponents"].value ) + visibleComponents = self.__colorChooserOption( "visibleComponents" ) + if visibleComponents is not None : + self.colorChooser().setVisibleComponents( visibleComponents ) - if "staticComponent" in options : - self.colorChooser().setColorFieldStaticComponent( options["staticComponent"].value ) + staticComponent = self.__colorChooserOption( "staticComponent" ) + if staticComponent is not None : + self.colorChooser().setColorFieldStaticComponent( staticComponent ) - if "colorFieldVisible" in options : - self.colorChooser().setColorFieldVisible( options["colorFieldVisible"].value ) + colorFieldVisible = self.__colorChooserOption( "colorFieldVisible" ) + if colorFieldVisible is not None : + self.colorChooser().setColorFieldVisible( colorFieldVisible ) parentWindow.addChildWindow( self, removeOnClose = True ) @@ -237,6 +243,22 @@ def __buttonClicked( self, button ) : assert( not self.visible() ) GafferUI.WidgetAlgo.keepUntilIdle( self ) + def __colorChooserOptionsMenu( self, colorChooser, menuDefinition ) : + + menuDefinition.append( "/__saveDefaultOptions__", { "divider": True, "label": "Defaults" } ) + + menuDefinition.append( + "/Save Dialogue Defaults", + { + "command": functools.partial( + saveDefaultOptions, + colorChooser, + "colorChooser:dialogue:", + self.ancestor( GafferUI.ScriptWindow ).scriptNode().applicationRoot().preferencesLocation() / "__colorChooser.py" + ) + } + ) + def __destroy( self, *unused ) : self.parent().removeChild( self ) @@ -244,42 +266,24 @@ def __destroy( self, *unused ) : # \todo Extract these two methods to share with `ColorChooserPlugValueWidget` which has # an almost identical implementation. - def __colorChooserOptionChanged( self, value, key ) : - - if Gaffer.Metadata.value( "colorChooser:dialogueOptions", "userDefault" ) is None : - sessionOptions = Gaffer.Metadata.value( "colorChooser:dialogueOptions", "sessionDefault" ) - if sessionOptions is None : - sessionOptions = IECore.CompoundData() - Gaffer.Metadata.registerValue( "colorChooser:dialogueOptions", "sessionDefault", sessionOptions ) - - sessionOptions.update( { key: value } ) + def __colorChooserOptionChanged( self, keySuffix, value ) : for p in self.__plugs : - plugOptions = Gaffer.Metadata.value( p, "colorChooser:dialogueOptions" ) - if plugOptions is None : - plugOptions = IECore.CompoundData() - Gaffer.Metadata.registerValue( p, "colorChooser:dialogueOptions", plugOptions, persistent = False ) + Gaffer.Metadata.deregisterValue( p, "colorChooser:dialogue:" + keySuffix ) + Gaffer.Metadata.registerValue( p, "colorChooser:dialogue:" + keySuffix, value, persistent = False ) + + def __colorChooserOption( self, keySuffix ) : - plugOptions.update( { key: value } ) + return sole( Gaffer.Metadata.value( p, "colorChooser:dialogue:" + keySuffix ) for p in self.__plugs ) def __colorChooserVisibleComponentsChanged( self, colorChooser ) : - self.__colorChooserOptionChanged( colorChooser.getVisibleComponents(), "visibleComponents" ) + self.__colorChooserOptionChanged( "visibleComponents", colorChooser.getVisibleComponents() ) def __colorChooserStaticComponentChanged( self, colorChooser ) : - self.__colorChooserOptionChanged( colorChooser.getColorFieldStaticComponent(), "staticComponent" ) + self.__colorChooserOptionChanged( "staticComponent", colorChooser.getColorFieldStaticComponent() ) def __colorChooserColorFieldVisibleChanged( self, colorChooser ) : - self.__colorChooserOptionChanged( colorChooser.getColorFieldVisible(), "colorFieldVisible" ) - - def __colorChooserOptions( self ) : - - v = sole( Gaffer.Metadata.value( p, "colorChooser:dialogueOptions" ) for p in self.__plugs ) - if v is None : - v = Gaffer.Metadata.value( "colorChooser:dialogueOptions", "userDefault" ) - if v is None : - v = Gaffer.Metadata.value( "colorChooser:dialogueOptions", "sessionDefault" ) or IECore.CompoundData() - - return v + self.__colorChooserOptionChanged( "colorFieldVisible", colorChooser.getColorFieldVisible() ) diff --git a/python/GafferUITest/ColorChooserTest.py b/python/GafferUITest/ColorChooserTest.py index 3bcb49436b..d00150dbed 100644 --- a/python/GafferUITest/ColorChooserTest.py +++ b/python/GafferUITest/ColorChooserTest.py @@ -46,6 +46,7 @@ import GafferUI from GafferUI.ColorChooser import _tmiToRGB from GafferUI.ColorChooser import _rgbToTMI +from GafferUI.ColorChooserPlugValueWidget import saveDefaultOptions import GafferUITest class ColorChooserTest( GafferUITest.TestCase ) : @@ -130,178 +131,144 @@ def testMetadata( self ) : script["node"]["rgbPlug1"] = Gaffer.Color3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) script["node"]["rgbPlug2"] = Gaffer.Color3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) - widget1 = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug1"] ) + widget = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug1"] ) # Default state for c in "rgbhsvtmi" : - self.assertTrue( self.__sliderFromWidget( widget1, c ).getVisible() ) - self.assertIsNone( Gaffer.Metadata.value( "colorChooser:inlineOptions", "sessionDefault" ) ) + self.assertTrue( self.__sliderFromWidget( widget, c ).getVisible() ) + self.assertEqual( self.__getStaticComponent( widget ), "s" ) + self.assertTrue( self.__getColorFieldVisibility( widget ) ) + for p in [ "rgbPlug1", "rgbPlug2" ] : - self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inlineOptions" ) ) - self.assertEqual( self.__getStaticComponent( widget1 ), "s" ) - self.assertTrue( self.__getColorFieldVisibility( widget1 ) ) + self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inline:visibleComponents" ) ) + self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inline:staticComponent" ) ) + self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inline:colorFieldVisible" ) ) - # Modify widget1 + # Modify widget - self.__setVisibleComponents( widget1, "rgbtmi" ) - self.__setStaticComponent( widget1, "t" ) - self.__setColorFieldVisibility( widget1, False ) + self.__setVisibleComponents( widget, "rgbtmi" ) + self.__setStaticComponent( widget, "t" ) + self.__setColorFieldVisibility( widget, False ) for c in "rgbtmi" : - self.assertTrue( self.__sliderFromWidget( widget1, c ).getVisible() ) + self.assertTrue( self.__sliderFromWidget( widget, c ).getVisible() ) for c in "hsv" : - self.assertFalse( self.__sliderFromWidget( widget1, c ).getVisible() ) - self.assertEqual( self.__getStaticComponent( widget1 ), "t" ) - self.assertFalse( self.__getColorFieldVisibility( widget1 ) ) - - sessionOptions = Gaffer.Metadata.value( "colorChooser:inlineOptions", "sessionDefault" ) - plug1Options = Gaffer.Metadata.value( script["node"]["rgbPlug1"], "colorChooser:inlineOptions" ) - self.assertEqual( set( sessionOptions["visibleComponents"].value ), set( "rgbtmi" ) ) - self.assertEqual( set( plug1Options["visibleComponents"].value ), set( "rgbtmi" ) ) - self.assertEqual( sessionOptions["staticComponent"].value, "t" ) - self.assertEqual( plug1Options["staticComponent"].value, "t" ) - self.assertFalse( sessionOptions["colorFieldVisible"].value ) - self.assertFalse( plug1Options["colorFieldVisible"].value ) - - # Recreate widget1 and should have the same state - del widget1 - widget1 = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug1"] ) + self.assertFalse( self.__sliderFromWidget( widget, c ).getVisible() ) + self.assertEqual( self.__getStaticComponent( widget ), "t" ) + self.assertFalse( self.__getColorFieldVisibility( widget ) ) - for c in "rgbtmi" : - self.assertTrue( self.__sliderFromWidget( widget1, c ).getVisible() ) - for c in "hsv" : - self.assertFalse( self.__sliderFromWidget( widget1, c ).getVisible() ) - self.assertEqual( self.__getStaticComponent( widget1 ), "t" ) - self.assertFalse( self.__getColorFieldVisibility( widget1 ) ) + for p in [ "rgbPlug2" ] : + self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inline:visibleComponents" ) ) + self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inline:staticComponent" ) ) + self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inline:colorFieldVisible" ) ) - # A widget for a second plug should adopt the same state as widget1 + self.assertEqual( set( Gaffer.Metadata.value( script["node"]["rgbPlug1"], "colorChooser:inline:visibleComponents" ) ), set( "rgbtmi" ) ) + self.assertEqual( Gaffer.Metadata.value( script["node"]["rgbPlug1"], "colorChooser:inline:staticComponent" ), "t" ) + self.assertFalse( Gaffer.Metadata.value( script["node"]["rgbPlug1"], "colorChooser:inline:colorFieldVisible" ) ) - widget2 = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug2"] ) + # Recreate widget and should have the same state + + del widget + widget = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug1"] ) for c in "rgbtmi" : - self.assertTrue( self.__sliderFromWidget( widget2, c ).getVisible() ) + self.assertTrue( self.__sliderFromWidget( widget, c ).getVisible() ) for c in "hsv" : - self.assertFalse( self.__sliderFromWidget( widget2, c ).getVisible() ) - self.assertEqual( self.__getStaticComponent( widget2 ), "t" ) - self.assertFalse( self.__getColorFieldVisibility( widget2 ) ) + self.assertFalse( self.__sliderFromWidget( widget, c ).getVisible() ) + self.assertEqual( self.__getStaticComponent( widget ), "t" ) + self.assertFalse( self.__getColorFieldVisibility( widget ) ) - # Changing widget2 should not affect widget1, but should change `sessionDefault` - self.__setVisibleComponents( widget2, "rgb" ) - self.__setStaticComponent( widget2, "r" ) - self.__setColorFieldVisibility( widget2, True ) + # We haven't saved the defaults, so a widget for a second plug + # gets the original defaults. - for c in "rgbtmi" : - self.assertTrue( self.__sliderFromWidget( widget1, c ).getVisible() ) - for c in "hsv" : - self.assertFalse( self.__sliderFromWidget( widget1, c ).getVisible() ) - self.assertEqual( self.__getStaticComponent( widget1 ), "t" ) - self.assertFalse( self.__getColorFieldVisibility( widget1 ) ) + widget2 = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug2"] ) - for c in "rgb" : + for c in "rgbhsvtmi" : self.assertTrue( self.__sliderFromWidget( widget2, c ).getVisible() ) - for c in "hsvtmi" : - self.assertFalse( self.__sliderFromWidget( widget2, c ).getVisible() ) - self.assertEqual( self.__getStaticComponent( widget2 ), "r" ) + self.assertEqual( self.__getStaticComponent( widget2 ), "s" ) self.assertTrue( self.__getColorFieldVisibility( widget2 ) ) - sessionOptions = Gaffer.Metadata.value( "colorChooser:inlineOptions", "sessionDefault" ) - plug1Options = Gaffer.Metadata.value( script["node"]["rgbPlug1"], "colorChooser:inlineOptions" ) - plug2Options = Gaffer.Metadata.value( script["node"]["rgbPlug2"], "colorChooser:inlineOptions" ) - - self.assertEqual( set( plug1Options["visibleComponents"].value ), set( "rgbtmi" ) ) - self.assertEqual( set( plug2Options["visibleComponents"].value ), set( "rgb" ) ) - self.assertEqual( set( sessionOptions["visibleComponents"].value ), set( "rgb" ) ) - self.assertEqual( plug1Options["staticComponent"].value, "t" ) - self.assertEqual( plug2Options["staticComponent"].value, "r" ) - self.assertEqual( sessionOptions["staticComponent"].value, "r" ) - self.assertFalse( plug1Options["colorFieldVisible"].value ) - self.assertTrue( plug2Options["colorFieldVisible"].value ) - self.assertTrue( sessionOptions["colorFieldVisible"].value ) + for p in [ "rgbPlug2" ] : + self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inline:visibleComponents" ) ) + self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inline:staticComponent" ) ) + self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inline:colorFieldVisible" ) ) # Don't serialize state - del widget1 - del widget2 - Gaffer.Metadata.deregisterValue( "colorChooser:inlineOptions", "sessionDefault" ) + + del widget script2 = Gaffer.ScriptNode() script2.execute( script.serialise() ) - widget1 = GafferUI.ColorPlugValueWidget( script2["node"]["rgbPlug1"] ) - widget2 = GafferUI.ColorPlugValueWidget( script2["node"]["rgbPlug2"] ) + widget = GafferUI.ColorPlugValueWidget( script2["node"]["rgbPlug1"] ) for c in "rgbhsvtmi" : - self.assertTrue( self.__sliderFromWidget( widget1, c ).getVisible() ) - self.assertTrue( self.__sliderFromWidget( widget2, c ).getVisible() ) - self.assertEqual( self.__getStaticComponent( widget1 ), "s" ) - self.assertEqual( self.__getStaticComponent( widget2 ), "s" ) - self.assertIsNone( Gaffer.Metadata.value( "colorChooser:inlineOptions", "sessionDefault" ) ) - for p in [ "rgbPlug1", "rgbPlug2" ] : - self.assertIsNone( Gaffer.Metadata.value( script2["node"][p], "colorChooser:inlineOptions" ) ) + self.assertTrue( self.__sliderFromWidget( widget, c ).getVisible() ) + self.assertEqual( self.__getStaticComponent( widget ), "s" ) + self.assertTrue( self.__getColorFieldVisibility( widget ) ) - def testUserDefaultMetadata( self ) : + for p in [ "rgbPlug1", "rgbPlug2" ] : + self.assertIsNone( Gaffer.Metadata.value( script2["node"][p], "colorChooser:inline:visibleComponents" ) ) + self.assertIsNone( Gaffer.Metadata.value( script2["node"][p], "colorChooser:inline:staticComponent" ) ) + self.assertIsNone( Gaffer.Metadata.value( script2["node"][p], "colorChooser:inline:colorFieldVisible" ) ) - # Set `userDefault` - Gaffer.Metadata.registerValue( - "colorChooser:inlineOptions", - "userDefault", - { - "visibleComponents": "rgb", - "staticComponent": "r", - "colorFieldVisible": False - } - ) + def testSaveDefaultOptions( self ) : script = Gaffer.ScriptNode() script["node"] = Gaffer.Node() - script["node"]["rgbPlug1"] = Gaffer.Color3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) - script["node"]["rgbPlug2"] = Gaffer.Color3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) + script["node"]["rgbPlug"] = Gaffer.Color3fPlug() + script["node"]["rgbaPlug"] = Gaffer.Color4fPlug() + script["node"]["rgbaPlug"].setValue( imath.Color4f( 0.1 ) ) - widget1 = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug1"] ) + rgbWidget = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug"] ) + rgbaWidget = GafferUI.ColorPlugValueWidget( script["node"]["rgbaPlug"] ) - # Should get `userDefault` values - for c in "rgb" : - self.assertTrue( self.__sliderFromWidget( widget1, c ).getVisible() ) - for c in "hsvtmi" : - self.assertFalse( self.__sliderFromWidget( widget1, c ).getVisible() ) - self.assertEqual( self.__getStaticComponent( widget1 ), "r" ) - self.assertFalse( self.__getColorFieldVisibility( widget1 ) ) + GafferUITest.PlugValueWidgetTest.waitForUpdate( rgbWidget._ColorPlugValueWidget__colorChooser ) + GafferUITest.PlugValueWidgetTest.waitForUpdate( rgbaWidget._ColorPlugValueWidget__colorChooser ) - self.assertIsNone( Gaffer.Metadata.value( "colorChooser:inlineOptions", "sessionDefault" ) ) - for p in [ "rgbPlug1", "rgbPlug2" ] : - self.assertIsNone( Gaffer.Metadata.value( script["node"][p], "colorChooser:inlineOptions" ) ) - - # Change widget1 and recreate it - self.__setVisibleComponents( widget1, "rgbhsv" ) - self.__setStaticComponent( widget1, "g" ) - self.__setColorFieldVisibility( widget1, True ) - - del widget1 + # Default state + for c in "rgbhsvtmi" : + self.assertTrue( self.__sliderFromWidget( rgbWidget, c ).getVisible() ) + self.assertTrue( self.__sliderFromWidget( rgbaWidget, c ).getVisible() ) + self.assertTrue( self.__sliderFromWidget( rgbaWidget, "a" ).getVisible() ) + self.assertEqual( self.__getStaticComponent( rgbWidget ), "s" ) + self.assertEqual( self.__getStaticComponent( rgbaWidget ), "s" ) + self.assertTrue( self.__getColorFieldVisibility( rgbWidget ) ) + self.assertTrue( self.__getColorFieldVisibility( rgbaWidget ) ) - widget1 = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug1"] ) + # Modify `rgbWidget` - # Should have HSV, static component G, visible color field - for c in "rgbhsv" : - self.assertTrue( self.__sliderFromWidget( widget1, c ).getVisible() ) - for c in "tmi" : - self.assertFalse( self.__sliderFromWidget( widget1, c ).getVisible() ) - self.assertEqual( self.__getStaticComponent( widget1 ), "g" ) - self.assertTrue( self.__getColorFieldVisibility( widget1 ) ) + self.__setVisibleComponents( rgbWidget, "rgbhsv" ) + self.__setStaticComponent( rgbWidget, "g" ) + self.__setColorFieldVisibility( rgbWidget, False ) - # A new widget, without any per-plug metadata should get `userDefault` + # Save defaults + colorChooser = self.__colorChooserFromWidget( rgbWidget ) + saveDefaultOptions( colorChooser, "colorChooser:inline:" ) - widget2 = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug2"] ) + del rgbWidget + del rgbaWidget - for c in "rgb" : - self.assertTrue( self.__sliderFromWidget( widget2, c ).getVisible() ) - for c in "hsvtmi" : - self.assertFalse( self.__sliderFromWidget( widget2, c ).getVisible() ) - self.assertEqual( self.__getStaticComponent( widget2 ), "r" ) - self.assertFalse( self.__getColorFieldVisibility( widget2 ) ) + # Both color types get the same value + rgbWidget = GafferUI.ColorPlugValueWidget( script["node"]["rgbPlug"] ) + rgbaWidget = GafferUI.ColorPlugValueWidget( script["node"]["rgbaPlug"] ) - self.assertIsNone( Gaffer.Metadata.value( "colorChooser:inlineOptions", "sessionDefault" ) ) + GafferUITest.PlugValueWidgetTest.waitForUpdate( rgbWidget._ColorPlugValueWidget__colorChooser ) + GafferUITest.PlugValueWidgetTest.waitForUpdate( rgbaWidget._ColorPlugValueWidget__colorChooser ) + for c in "rgbhsv" : + self.assertTrue( self.__sliderFromWidget( rgbWidget, c ).getVisible() ) + self.assertTrue( self.__sliderFromWidget( rgbaWidget, c ).getVisible() ) + for c in "tmi" : + self.assertFalse( self.__sliderFromWidget( rgbWidget, c ).getVisible() ) + self.assertFalse( self.__sliderFromWidget( rgbaWidget, c ).getVisible() ) + self.assertTrue( self.__sliderFromWidget( rgbaWidget, "a" ).getVisible() ) + self.assertEqual( self.__getStaticComponent( rgbWidget ), "g" ) + self.assertEqual( self.__getStaticComponent( rgbaWidget ), "g" ) + self.assertFalse( self.__getColorFieldVisibility( rgbWidget ) ) + self.assertFalse( self.__getColorFieldVisibility( rgbaWidget ) ) if __name__ == "__main__" : unittest.main() \ No newline at end of file