[gnome-games/applygsoc2009: 45/76] Can restore the grid from saved game

[Pablo Castellano <pablog src gnome org>]

commit 0b164f6001f24ca96e9d026fbdf26c655acabd57
Author: Pablo Castellano <pablog src gnome org>
Date:   Thu Aug 26 16:20:19 2010 +0200

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

 gnome-sudoku/src/lib/gsudoku.py |   80 ++++++++++++--------------------------
 gnome-sudoku/src/lib/main.py    |   31 +++++++++++++-
 gnome-sudoku/src/lib/saver.py   |   35 -----------------
 3 files changed, 53 insertions(+), 93 deletions(-)
---
diff --git a/gnome-sudoku/src/lib/gsudoku.py b/gnome-sudoku/src/lib/gsudoku.py
index 9bd4b2a..11686fd 100644
--- a/gnome-sudoku/src/lib/gsudoku.py
+++ b/gnome-sudoku/src/lib/gsudoku.py
@@ -109,10 +109,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
@@ -326,7 +327,7 @@ class NotesModel:
 
 class SudokuModel:
 
-    def __init__ (self, grid, group_size):
+	def __init__ (self, virgin_grid, group_size, initial_grid=None):
         self.hints = 0
         self.auto_fills = 0
         self.show_impossible_implications = False
@@ -334,10 +335,16 @@ class SudokuModel:
         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)
 
@@ -428,58 +435,18 @@ class SudokuModel:
         # Redraw the notes
         self.update_all_notes()
 
-    def _blank_grid (self):
-        '''Wipe out everything on the grid.
-
-        This blanks all values, notes, tracked values, virgin values.  You end
-        up with a blank grid ready for a new puzzle.
-        '''
-        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)
-        for imp_cell in self.impossibilities:
-            self.__entries__[imp_cell].set_text('')
-        self.impossibilities = []
-        self.grid = None
-        self.clear_notes('All')
-        self.tinfo.reset()
+    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.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):
-        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 update_all_notes (self):
         '''Display the notes for all the cells
@@ -531,6 +498,9 @@ class SudokuModel:
         self._signal_observers(result)
         self._check_for_completeness()
 
+    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 49a3aba..d93270e 100644
--- a/gnome-sudoku/src/lib/main.py
+++ b/gnome-sudoku/src/lib/main.py
@@ -115,13 +115,38 @@ class UI (gconf_wrapper.GConfWrapper):
             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)
 #            self._main_grid_vew.connect('puzzle-finished', self.you_win_callback)
         elif game_type == game_selector.NewOrSavedGameSelector.SAVED_GAME:
-            saver.open_game(self, puzzle)
+            saver._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 b559d05..c9a48ed 100644
--- a/gnome-sudoku/src/lib/saver.py
+++ b/gnome-sudoku/src/lib/saver.py
@@ -62,41 +62,6 @@ def set_value_from_jar (dest, jar):
     for attr in SAVE_ATTRIBUTES:
         super_setattr(dest, attr, jar[attr])
 
-def open_game (ui, jar):
-    tinfo = tracker_info.TrackerInfo()
-    tinfo.set_tracker(tracker_info.NO_TRACKER)
-    ui.gsd.load_game(jar['game'])
-    # The 'notes' and 'trackers' sections are for transition from the old
-    # style tracker storage.  The tracker values and notes are stored in the
-    # 'tracked_notes' and 'tracker_info' sections now.
-    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)
-    if jar.has_key('trackers'):
-        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:
-                tinfo.add_trace(x, y, val)
-    set_value_from_jar(ui, jar)
-    if jar.has_key('tracking'):
-        for tracker, tracking in jar.get('tracking', {}).items():
-            if tracking:
-                ui.tracker_ui.select_tracker(tracker)
-    if jar.has_key('tracked_notes') and jar['tracked_notes']:
-        for x, y, top, bot in jar['tracked_notes']:
-            ui.gsd.__entries__[(x, y)].set_notelist(top, bot)
-    if jar.has_key('tracker_info'):
-        trackers = jar['tracker_info'][2]
-        for tracking in trackers.keys():
-            ui.tracker_ui.add_tracker(tracker_id = tracking)
-        tinfo.load(jar['tracker_info'])
-        ui.tracker_ui.select_tracker(tinfo.current_tracker)
-        if tinfo.showing_tracker != tracker_info.NO_TRACKER:
-            ui.gsd.show_track()
-    # Display the notes
-    ui.gsd.update_all_notes()
-
 
 class SudokuTracker: