New version, but still the same.

Author: Zerline

examples/FlippingDominos.ipynb

@@ -66,7 +66,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "w = FlippingDominosWidget(g)\n",
+    "w = FlippingDominosWidget(g, css_classes=['b0', 'b1', 'b2', 'b3', 'b4'])\n",
     "w"
    ]
   },

examples/dominos/flipping_dominos.py

@@ -5,8 +5,9 @@
 from sage_widget_adapters.graphs.graph_grid_view_adapter import GraphGridViewAdapter
 from sage_combinat_widgets.grid_view_widget import GridViewWidget, ButtonCell, BlankButton, styled_button_cell
 from ipywidgets import Layout
-from traitlets import dlink, HasTraits, Bool
+from traitlets import dlink, HasTraits, Bool, observe, All
 from contextlib import contextmanager
+from sage_combinat_widgets.grid_view_editor import extract_coordinates
 
 smallblyt = Layout(width='12px',height='12px', margin='0', padding='0')
 
@@ -26,7 +27,7 @@ def set_cell(self, obj, pos, val, dirty={}):
         if dirty: # if i'm a neighbor, then flip and return a new obj ; else return an error
             # Consider the relevant matching(s)
             for p in dirty:
-                if not dirty[p]: # check this position is pressed
+                if not dirty[p]: # check this position was pressed
                     continue
                 d2 = obj.domino_for_position(p)
                 if d2 == d1 or not d2 in d1.neighbors():
@@ -98,8 +99,8 @@ def _busy_updating(self):
             self.updating = False
 
     def _update(self, change):
-        if self.updating:
-            return
+        #if self.updating or self.target[0].donottrack:
+        #    return
         with self._busy_updating():
             if self.logic == 'and':
                 if self.intermediate_value == False: # aucun bouton pressé avant
@@ -155,23 +156,25 @@ def __init__(self, parent, b1, b2):
         self.link = None
         self.direction = None
         self.orientation = None
-        self.compute(None)
+        self.compute()
+        self.donottrack = False
 
     def __repr__(self):
         if self.value:
             return repr(self.first) + ' -> ' + repr(self.second) + " PRESSED"
         return repr(self.first) + ' -> ' + repr(self.second)
 
-    def compute(self, css_classes=None):
+    def compute(self, css_classes=['b0', 'b1', 'b2', 'b3', 'b4']):
         """Compute buttons relative positions.
         Create double directional link from both buttons"""
         self.geometry.compute()
+        #print(self.geometry.__dict__)
         if css_classes:
             for cl in css_classes:
                 self.first.remove_class(cl)
                 self.second.remove_class(cl)
-            self.first.add_class(css_classes[self.geometry.index_for_display-1])
-            self.second.add_class(css_classes[self.geometry.index_for_display-1])
+            self.first.add_class(css_classes[self.geometry.index_for_display])
+            self.second.add_class(css_classes[self.geometry.index_for_display])
         if self.geometry.orientation == 1:
             self.key = self.first.position
         else:
@@ -199,19 +202,19 @@ def is_pressed(self):
         """Is the domino pressed?"""
         return self.value
 
-    def set_value(self, value):
-        """Set domino value
-        As we have a directional link,
-        the domino value will also be set.
-        """
-        self.link.unlink()
-        self.first.value = value
-        self.second.value = value
-        self.link = ddlink(((self.first, 'value'), (self.second, 'value')), (self, 'value'), logic='and', set_at_init=False) # Fresh ddlink
+#    def set_value(self, value):
+#        """Set domino value
+#        As we have a directional link,
+#        the domino value will also be set.
+#        """
+#        self.link.unlink()
+#        self.first.value = value
+#        self.second.value = value
+#        self.link = ddlink(((self.first, 'value'), (self.second, 'value')), (self, 'value'), logic='and', set_at_init=False) # Fresh ddlink
 
     def reset(self):
         """Full domino reset"""
-        self.set_value(False)
+        #self.set_value(False)
         self.link.unlink()
 
     def flip(self, other):
@@ -237,11 +240,12 @@ def cell_widget_class_index(pos):
 class FlippingDominosWidget(GridViewWidget):
     """A widget with dominos"""
 
-    def __init__(self, g):
+    def __init__(self, g, css_classes=['b0', 'b1', 'b2', 'b3', 'b4']):
         r"""
         Init a flipping dominos widget
         with flipping aztec diamond graph `g`
         """
+        self.css_classes = css_classes
         super(FlippingDominosWidget, self).__init__(g, adapter = FlippingDominosAdapter(),
                                             cell_layout = smallblyt,
                                             cell_widget_classes=[styled_button_cell(),
@@ -252,19 +256,11 @@ def __init__(self, g):
                                             ],
                                             cell_widget_class_index=make_cell_widget_class_index(g),
                                             blank_widget_class = BlankButton)
-        self.css_classes = ['b1', 'b2', 'b3', 'b4']
-
     def draw(self):
         self.dominos = {}
         super(FlippingDominosWidget, self).draw()
         self.apply_matching(self.value.matching)
 
-    def update(self):
-        self.apply_matching(self.value.matching)
-        for k,d in self.dominos.items():
-            d.compute(self.css_classes)
-            d.set_value(False) # unpress buttons
-
     def match(self, b1, b2):
         """Match buttons b1 and b2, that is: create a domino"""
         try:
@@ -286,7 +282,64 @@ def apply_matching(self, matching):
             self.match(self.children[d.first[0]].children[d.first[1]],
                        self.children[d.second[0]].children[d.second[1]])
 
-    def set_value(self, value):
-        """Need to call self.update() manually, as the change is not obvious to the observer!"""
+    def update(self):
+        self.apply_matching(self.value.matching)
+        for k,d in self.dominos.items():
+            d.compute(self.css_classes)
+            #d.set_value(False) # unpress buttons
+
+    def domino_for_position(self, pos):
+        geometry = self.value.domino_for_position(pos)
+        for t in (geometry.first, geometry.second):
+            if t in self.dominos:
+                print("domino for position", t, ":", self.dominos[t].geometry, self.dominos[t].value)
+                return self.dominos[t]
+
+    def not_tracking(self, value):
+        self.donottrack = value
+        for d in self.dominos.values():
+            d.donottrack = value
+
+    @observe(All)
+    def set_cell(self, change):
+        if self.donottrack:
+            return
+        if change.name.startswith('cell_'):
+            print("set_cell()", change.name, change.old, change.new)
+        else:
+            print("set_cell()", change.name)
+        # Try to reset everything right now to avoid unwanted propagations
+        domino = self.domino_for_position(extract_coordinates(change.name))
+        # First, we want to make the pressed domino visible to the user
+        self.not_tracking(True)
+        domino.first.value = True
+        domino.second.value = True
+        # Any pressed neighbor?
+        other = None
+        if self.dirty:
+            for pos in self.dirty:
+                other = self.domino_for_position(pos)
+                if other and not other.geometry in domino.geometry.neighbors():
+                    other = None
+                    continue # we don't have to reset everything, I guess(hope)
+        if not other:
+            self.dirty[domino.geometry.first] = True
+            self.dirty[domino.geometry.second] = True
+            self.not_tracking(False)
+            return
+        if domino.link:
+            domino.link.unlink()
+        if other.link:
+            other.link.unlink()
+        self.not_tracking(False)
+        super(FlippingDominosWidget, self).set_cell(change)
+        self.not_tracking(True)
+        # And now, we want to reset everything before the flip
+        domino.first.value = False
+        domino.second.value = False
+        other.first.value = False
+        other.second.value = False
+        # Now, recreate the 2 dominos and compute style
         self.reset_dirty()
         self.update()
+        self.not_tracking(False)