Example #1
0
 def make_saved_game_model (self):
     # Description, Image, Last-Access time (for sorting), Puzzle (jar)
     self.saved_game_model = gtk.ListStore(str, gtk.gdk.Pixbuf, int, gobject.TYPE_PYOBJECT)
     for g in self.saved_games:
         game = g['game'].split('\n')[0]
         grid = sudoku.sudoku_grid_from_string(game)
         sr = sudoku.SudokuRater(grid.grid)
         sdifficulty = sr.difficulty()
         lastPlayedText = _("Last Played %(timeAgo)s") % {'timeAgo': format_friendly_date(g['saved_at'])}
         levelText =  _("%(level)s puzzle") % {'level': sdifficulty.value_string()}
         durationText = _("Played for %(duration)s") % {
                 'duration': format_time(g['timer.active_time'], round_at = 15, friendly = True)}
         desc = "<b><i>%s</i></b>\n<span size='small'><i>%s</i>\n<i>%s.</i></span>" % (
             levelText,
             lastPlayedText,
             durationText,
             )
         self.saved_game_model.append((
             desc,
             sudoku_thumber.make_pixbuf(grid.grid,
                                        sudoku.sudoku_grid_from_string(g['game'].split('\n')[1].replace(' ', '')).grid,
                                        color_from_difficulty(sdifficulty.value)
                                        ),
             g['saved_at'],
             g
             ))
Example #2
0
 def make_new_game_model (self):
     # Description, Pixbuf, Puzzle (str)
     self.new_game_model = gtk.ListStore(str, gtk.gdk.Pixbuf, str)
     saved_games_to_exclude = [
         g['game'].split('\n')[0] for g in self.saved_games
         ]
     for cat in sudoku.DifficultyRating.ordered_categories:
         label = sudoku.DifficultyRating.label_by_cat[cat]
         puzzles = self.sudoku_maker.get_puzzles(1, [cat], new = True,
                                                 exclude = saved_games_to_exclude
                                                 )
         if puzzles:
             puzzle, diff_val = puzzles[0]
         else:
             print 'WARNING: Repeating puzzle for difficulty %s -- generate more puzzles to avoid this.' % cat
             puzzles = self.sudoku_maker.get_puzzles(1, [cat], new = False)
             if puzzles:
                 puzzle, diff_val = puzzles[0]
                 lpuz = list(puzzle)
                 lpuz.reverse() # we reverse the puzzle so it at least looks different :-)
                 puzzle = ''
                 for n in lpuz:
                     puzzle += n
             else:
                 print 'WARNING: No puzzle for difficulty', cat
                 continue
         grid = sudoku.sudoku_grid_from_string(puzzle).grid
         self.new_game_model.append(('<b><i>' + label + '</i></b>',
                                     sudoku_thumber.make_pixbuf(grid,
                                                                None,
                                                                color_from_difficulty(diff_val)
                                                                ),
                                     puzzle
                                     ))
Example #3
0
 def make_saved_game_model (self):
     # Description, Image, Last-Access time (for sorting), Puzzle (jar)
     self.saved_game_model = Gtk.ListStore(str, GdkPixbuf.Pixbuf, int, GObject.TYPE_PYOBJECT)
     for g in self.saved_games:
         game = g['game'].split('\n')[0]
         grid = sudoku.sudoku_grid_from_string(game)
         sr = sudoku.SudokuRater(grid.grid)
         sdifficulty = sr.difficulty()
         lastPlayedText = self.format_friendly_date(g['saved_at'])
         try:
             levelText = {'easy': _('Easy puzzle'),
                          'medium': _('Medium puzzle'),
                          'hard': _('Hard puzzle'),
                          'very hard': _('Very hard puzzle')}[sdifficulty.value_category()]
         except KeyError:
             levelText = sdifficulty.value_category()
         tim = g['timer.active_time']
         if tim >= 3600.0:
             hours = int(tim / 3600)
             durationText = ngettext("Played for %d hour", "Played for %d hours", hours) % hours
         elif tim >= 60.0:
             minutes = int(tim / 60)
             durationText = ngettext("Played for %d minute", "Played for %d minutes", minutes) % minutes
         else:
             seconds = int(tim)
             durationText = ngettext("Played for %d second", "Played for %d seconds", seconds) % seconds            
         desc = "<b><i>%s</i></b>\n<span size='small'><i>%s</i>\n<i>%s.</i></span>" % (
             levelText,
             lastPlayedText,
             durationText,
             )
         self.saved_game_model.append((
             desc,
             sudoku_thumber.make_pixbuf(grid.grid,
                                        sudoku.sudoku_grid_from_string(g['game'].split('\n')[1].replace(' ', '')).grid,
                                        color_from_difficulty(sdifficulty.value)
                                        ),
             g['saved_at'],
             g
             ))
Example #4
0
    def response_cb (self, dialog, response):
        if response not in (Gtk.ResponseType.ACCEPT, Gtk.ResponseType.OK):
            self.dialog.hide()
            return
        # Otherwise, we're printing!
        levels = []
        for cat in sudoku.DifficultyRating.categories:
            if getattr(self,
                       cat.replace(' ', '_') + 'CheckButton'
                       ).get_active():
                levels.append(cat)
        if not levels:
            levels = sudoku.DifficultyRating.categories.keys()
        nsudokus = self.sudokusToPrintSpinButton.get_adjustment().get_value()
        sudokus = self.sudoku_maker.get_puzzles(
            nsudokus,
            levels,
            new = not self.includeOldGamesToggle.get_active()
            )
        # Convert floating point difficulty into a label string
        sudokus.sort(cmp = lambda a, b: cmp(a[1], b[1]))
        labels = {'easy': _('Easy'),
                  'medium': _('Medium'),
                  'hard': _('Hard'),
                  'very hard': _('Very hard')}
        sudokus = [(sudoku.sudoku_grid_from_string(puzzle),
                    "%s (%.2f)" % (labels[sudoku.get_difficulty_category(d)], d)
                    ) for puzzle, d in sudokus]
        sp = SudokuPrinter(sudokus,
                           self.dialog,
                           sudokus_per_page = self.sudokusPerPageSpinButton.get_adjustment().get_value())

        self.sudokus_printed = sudokus
        response = sp.print_op.run(Gtk.PrintOperationAction.PRINT_DIALOG, sp.main_window)

        if response   == Gtk.PrintOperationResult.ERROR:
            pass
        elif response == Gtk.PrintOperationResult.APPLY:
            if self.markAsPlayedToggle.get_active():
                for sud, lab in self.sudokus_printed:
                    jar = {}
                    jar['game'] = sud.to_string()
                    jar['printed'] = True
                    jar['printed_at'] = time.time()
                    tracker = saver.SudokuTracker()
                    tracker.finish_jar(jar)
            self.dialog.hide()
Example #5
0
    def response_cb(self, dialog, response):
        if response not in (gtk.RESPONSE_ACCEPT, gtk.RESPONSE_OK):
            self.dialog.hide()
            return
        # Otherwise, we're printing!
        levels = []
        for cat in sudoku.DifficultyRating.categories:
            if getattr(self,
                       cat.replace(' ', '_') + 'CheckButton').get_active():
                levels.append(cat)
        if not levels:
            levels = sudoku.DifficultyRating.categories.keys()
        nsudokus = self.sudokusToPrintSpinButton.get_adjustment().get_value()
        sudokus = self.sudoku_maker.get_puzzles(
            nsudokus, levels, new=not self.includeOldGamesToggle.get_active())
        # Convert floating point difficulty into a label string
        sudokus.sort(cmp=lambda a, b: cmp(a[1], b[1]))
        sudokus = [(sudoku.sudoku_grid_from_string(puzzle),
                    "%s (%.2f)" % (sudoku.get_difficulty_category_name(d), d))
                   for puzzle, d in sudokus]
        sp = SudokuPrinter(sudokus,
                           self.dialog,
                           sudokus_per_page=self.sudokusPerPageSpinButton.
                           get_adjustment().get_value())

        self.sudokus_printed = sudokus
        response = sp.print_op.run(gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG,
                                   sp.main_window)

        if response == gtk.PRINT_OPERATION_RESULT_ERROR:
            pass
        elif response == gtk.PRINT_OPERATION_RESULT_APPLY:
            if self.markAsPlayedToggle.get_active():
                for sud, lab in self.sudokus_printed:
                    jar = {}
                    jar['game'] = sud.to_string()
                    jar['printed'] = True
                    jar['printed_at'] = time.time()
                    tracker = saver.SudokuTracker()
                    tracker.finish_jar(jar)
            self.dialog.hide()