[gnome-games/sudoku-tube] Can restore the grid from saved game

[Zhang Sen <zhangsen src gnome org>]

commit 3bd53cb9b4506375888e18bb5c5b5771bce9ff11
Author: Zhang Sen <zh jesse gmail com>
Date:   Tue Jul 21 11:58:10 2009 +0800

    Can restore the grid from saved game
    
    Haven't got upon other saved attrbutes

 gnome-sudoku/src/lib/gsudoku.py |   74 +++++++++++++-------------------------
 gnome-sudoku/src/lib/main.py    |   33 +++++++++++++++--
 gnome-sudoku/src/lib/saver.py   |   19 ----------
 3 files changed, 54 insertions(+), 72 deletions(-)
---
diff --git a/gnome-sudoku/src/lib/gsudoku.py b/gnome-sudoku/src/lib/gsudoku.py
index 0961b58..ec6a53b 100644
--- a/gnome-sudoku/src/lib/gsudoku.py
+++ b/gnome-sudoku/src/lib/gsudoku.py
@@ -181,10 +181,11 @@ class SudokuView(SudokuNumberGrid, gobject.GObject):
         model.add_observer(self)
         for x in range(self.group_size):
             for y in range(self.group_size):
-                val = model.grid._get_(x, y)
+                val = model.get_value(x, y)
                 if val:
-                    self.set_readonly_appearance(x, y, True)
                     self.set_value(x, y, val)
+                    if model.get_virgin_value(x, y):
+                        self.set_readonly_appearance(x, y, True)
 
     def connect_to_notes_model(self, model):
         self._notes_model = model
@@ -415,17 +416,22 @@ class NotesModel:
 
 class SudokuModel:
 
-    def __init__ (self, grid, group_size):
+    def __init__ (self, virgin_grid, group_size, initial_grid=None):
         self.auto_fills = 0
         self.show_impossible_implications = False
         self.impossible_hints = 0
         self.impossibilities = []
         self.__trackers_tracking__ = {}
         self.group_size = group_size
-        self._setup_grid(grid, group_size)
-
+        self.grid = None
+        self._virgin_grid = None
         self._observers = []
 
+        self.__error_pairs__ = ParallelDict()
+        self._setup_virgin_grid(virgin_grid)
+        if initial_grid:
+            self._setup_initial_grid(initial_grid)
+
     def add_observer(self, observer):
         self._observers.append(observer)
 
@@ -448,51 +454,18 @@ class SudokuModel:
                     # set_value on all the entries, instead of only filled ones
                     self.set_value(x, y, 0)
 
-    def _blank_grid(self):
-        for x in range(self.group_size):
-            for y in range(self.group_size):
-                e = self.__entries__[(x, y)]
-                if e.get_value():
-                    self.remove(x, y)
-                e.set_read_only(False)
-        self.grid = None
-        self.clear_notes()
+    def _setup_virgin_grid(self, virgin):
+        """both grid and initial_grid should be str"""
+        self._virgin_grid = [int(c) for c in virgin.split()]
+        self.grid = sudoku.InteractiveSudoku(virgin, self.group_size)
 
-    def change_grid (self, grid, group_size):
-        self.auto_fills = 0
-        self.hints = 0
-        self.impossible_hints = 0
-        self._blank_grid()
-        self._setup_grid(grid, group_size)
-
-    def load_game (self, game):
-        """Load a game.
-
-        A game is simply a two lined string where the first line represents our
-        virgin self and line two represents our game-in-progress.
-        """
-        self._blank_grid()
-        if '\n' in game:
-            virgin, in_prog = game.split('\n')
-        else:
-            virgin, in_prog = game, ''
-        group_size = int(math.sqrt(len(virgin.split())))
-        self.change_grid(virgin, group_size = group_size)
-        # This int() will break if we go to 16x16 grids...
-        if in_prog:
-            values = [int(c) for c in in_prog.split()]
-            for row in range(group_size):
-                for col in range(group_size):
-                    index = row * 9 + col
-                    if values[index] and not self.grid._get_(col, row):
-                        self.add_value(col, row, values[index])
-
-    def _setup_grid(self, grid, group_size):
-        self.__error_pairs__ = ParallelDict()
-        if isinstance(grid, sudoku.SudokuGrid):
-            self.grid = sudoku.InteractiveSudoku(grid.grid, group_size = grid.group_size)
-        else:
-            self.grid = sudoku.InteractiveSudoku(grid, group_size = group_size)
+    def _setup_initial_grid(self, initial_grid):
+        values = [int(c) for c in initial_grid.split()]
+        for row in range(self.group_size):
+            for col in range(self.group_size):
+                index = row * 9 + col
+                if values[index] and not self.grid._get_(col, row):
+                    self.set_value(col, row, values[index])
 
     def set_value(self, x, y, value):
         result = []
@@ -521,6 +494,9 @@ class SudokuModel:
     def get_value(self, x, y):
         return self.grid._get_(x, y)
 
+    def get_virgin_value(self, x, y):
+        return self._virgin_grid[9 * y + x]
+
     def _remove_old_conficts(self, x, y):
         result = []
         old_conflicts = self._remove_related_conflicts(x, y)
diff --git a/gnome-sudoku/src/lib/main.py b/gnome-sudoku/src/lib/main.py
index 167d7dc..7e985a4 100644
--- a/gnome-sudoku/src/lib/main.py
+++ b/gnome-sudoku/src/lib/main.py
@@ -120,13 +120,38 @@ class UI (gconf_wrapper.GConfWrapper):
         if game_type == game_selector.NewOrSavedGameSelector.NEW_GAME:
             self._main_model = gsudoku.SudokuModel(puzzle, 9)
             self._notes_model = gsudoku.NotesModel(self._main_model, group_size=9)
-
-            self._main_grid_vew.connect_to_model(self._main_model)
-            self._main_grid_vew.connect_to_notes_model(self._notes_model)
         elif game_type == game_selector.NewOrSavedGameSelector.SAVED_GAME:
-            saver.open_game(self, puzzle)
+            self._open_saved_game(puzzle)
+        else:
+            logger.fatal("shouldn't be here")
+
+        self._main_grid_vew.connect_to_model(self._main_model)
+        self._main_grid_vew.connect_to_notes_model(self._notes_model)
         self._post_open_setup()
 
+    def _open_saved_game(self, jar):
+        virgin, in_prog = jar["game"].split('\n')
+        self._main_model = gsudoku.SudokuModel(virgin, 9, in_prog)
+        self._notes_model = gsudoku.NotesModel(self._main_model, group_size=9)
+        return
+
+        # this is a bit easily breakable... we take advantage of the fact
+        # that we create tracker IDs sequentially and that {}.items()
+        # sorts by keys by default
+        for tracker, tracked in jar.get('trackers', {}).items():
+            # add 1 tracker per existing tracker...
+            self.tracker_ui.add_tracker()
+            for x, y, val in tracked:
+                self.gsd.add_tracker(x, y, tracker, val = val)
+        for tracker, tracking in jar.get('tracking', {}).items():
+            if tracking:
+                ui.tracker_ui.select_tracker(tracker)
+        set_value_from_jar(ui, jar)
+        if jar.has_key('notes') and jar['notes']:
+            for x, y, top, bot in jar['notes']:
+                ui.gsd.__entries__[(x, y)].set_note_text(top, bot)
+
+
     def _post_open_setup(self):
         """Properly do the setup after entering game
 
diff --git a/gnome-sudoku/src/lib/saver.py b/gnome-sudoku/src/lib/saver.py
index 6fe0a0b..0477c92 100644
--- a/gnome-sudoku/src/lib/saver.py
+++ b/gnome-sudoku/src/lib/saver.py
@@ -64,25 +64,6 @@ def set_value_from_jar (dest, jar):
     for attr in SAVE_ATTRIBUTES:
         super_setattr(dest, attr, jar[attr])
 
-def open_game (ui, jar):
-    ui.gsd.load_game(jar['game'])
-    # this is a bit easily breakable... we take advantage of the fact
-    # that we create tracker IDs sequentially and that {}.items()
-    # sorts by keys by default
-    for tracker, tracked in jar.get('trackers', {}).items():
-        # add 1 tracker per existing tracker...
-        ui.tracker_ui.add_tracker()
-        for x, y, val in tracked:
-            ui.gsd.add_tracker(x, y, tracker, val = val)
-    for tracker, tracking in jar.get('tracking', {}).items():
-        if tracking:
-            ui.tracker_ui.select_tracker(tracker)
-    set_value_from_jar(ui, jar)
-    if jar.has_key('notes') and jar['notes']:
-        for x, y, top, bot in jar['notes']:
-            ui.gsd.__entries__[(x, y)].set_note_text(top, bot)
-
-
 class SudokuTracker:
 
     """A class to track games in progress and games completed.