~e93b5ae3/+junk/github-import-readonly

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# pylint: disable-msg=r0201
"""
    4digits - A guess-the-number game, aka Bulls and Cows
    Copyright (c) 2004-2011 Yongzhi Pan <http://fourdigits.sourceforge.net>

    4digits is a guess-the-number puzzle game. You are given eight times
    to guess a four-digit number. One digit is marked A if its value and
    position are both correct, and marked B if only its value is correct.
    You win the game when you get 4A0B. Good luck!

    4digits is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.

    4digits is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with 4digits; if not, write to the Free Software Foundation,
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""

import os
import cPickle
import random
import pango
import sys
import time
import webbrowser

try:
    import pygtk
    pygtk.require('2.0')
    import gtk
    import gtk.glade
except ImportError:
    print _('python-gtk2 is required to run 4digits.')
    print _('No python-gtk2 was found on your system.')
    sys.exit(1)

__version__ = '1.0'
__appdata_dir__ = os.path.join(os.path.expanduser('~'), '.4digits')
__config_path__ = os.path.join(__appdata_dir__, 'prefs.pickle')
__prefs__ = {
        'show toolbar': True,
        'show hint table': False,
        'auto fill hints': False
        }

# The first is the current directory, so you do not have to install 
# 4digits to play it. The second is the installation directory.
__gladefiles__ = [os.path.join(os.path.dirname(__file__), '4digits.glade'),
    os.path.normpath(os.path.join(
    os.path.dirname(__file__), '../share/4digits/4digits.glade'))]
__helpfiles__ = [os.path.join(os.path.dirname(__file__), 'doc', 'index.html'),
    os.path.normpath(os.path.join(
    os.path.dirname(__file__), '../share/doc/4digits/index.html'))]
__score_filename__ = os.path.join(__appdata_dir__, '4digits.4digits.scores')

# For future gettext support. I cannot figure out i18n now.
# I wish someone could help me with it.
try: 
    _()
except NameError:
    def _(arg):
        """Mark translatable strings."""
        return arg

def load_glade(dialog = None):
    """Try to load dialog from the different possible glade files."""
    for gladefile in __gladefiles__:
        try:
            return gtk.glade.XML(gladefile, dialog) 
        except RuntimeError:
            continue # Just ignore the error, the next file will be tested
    # Still here
    print "Gladefile not found! Checked paths were:"
    print __gladefiles__
    sys.exit(2)
    

class MainWindow(object):
    """The main game window."""
    def __init__(self):
        """GUI initialization."""
        self.widget_tree = load_glade()
        self.toolbar = self.widget_tree.get_widget('toolbar')
        self.view_toolbar = self.widget_tree.get_widget('view_toolbar')
        self.hint_table = self.widget_tree.get_widget('hint_table')
        self.hint_hseparator = self.widget_tree.get_widget(
                'hint_hseparator')
        self.view_hint_table = self.widget_tree.get_widget(
                'view_hint_table')
        self.auto_fill_hints = self.widget_tree.get_widget(
                'view_auto_fill_hints')

        # Input box
        self.entry = self.widget_tree.get_widget('entry')
        self.entry.grab_focus()
        fontsize = self.entry.get_pango_context().\
                get_font_description().get_size()/pango.SCALE
        self.entry.modify_font(pango.FontDescription(str(int(fontsize*3))))

        self.ok_button = self.widget_tree.get_widget('ok_button')
        for widget in ('g0', 'g1', 'g2', 'g3', 'g4', 'g5', 'g6', 'g7',
                'r0', 'r1', 'r2', 'r3', 'r4', 'r5', 'r6', 'r7'):
            setattr(self, widget, self.widget_tree.get_widget(widget))
        self.info_label = self.widget_tree.get_widget('info_label')
        self.time_label = self.widget_tree.get_widget('time_label')
        self.score_view = self.widget_tree.get_widget('score_view')

        self.cb_hint = [] # container for check boxes in the hint table
        self.label_hint = []
        self.build_hint_table()

        # parse preferences
        self.read_preferences_file()
        if __prefs__['show toolbar']:
            self.toolbar.show()
            self.view_toolbar.set_active(True)
        else:
            self.toolbar.hide()
            self.view_toolbar.set_active(False)
        if __prefs__['show hint table']:
            self.hint_table.show_all()
            self.hint_hseparator.show()
            self.view_hint_table.set_active(True)
        else:
            self.hint_table.hide_all()
            self.hint_hseparator.hide()
            self.view_hint_table.set_active(False)
        if __prefs__['auto fill hints']:
            self.auto_fill_hints.set_active(True)
        else:
            self.auto_fill_hints.set_active(False)
        
        # connect signals and callbacks
        dic = {'on_main_window_destroy': self.terminate_program,
                'on_quit_activate': self.terminate_program,
                'on_ok_clicked': self.on_entry_activate,
                'on_new_game_activate': self.on_new_game_activate,
                'on_view_toolbar_toggled': self.on_view_toolbar_toggled,
                'on_view_hint_table_toggled'
                : self.on_view_hint_table_toggled,
                'on_view_auto_fill_hints_toggled'
                : self.on_view_auto_fill_hints_toggled,
                'on_entry_activate': self.on_entry_activate,
                'on_entry_changed': self.on_entry_changed,
                'on_help_activate' : self.on_help_activate,
                'on_about_activate' : self.on_about_activate,
                'on_score_activate': self.on_score_activate}
        self.widget_tree.signal_autoconnect(dic)
        # new game initialization
        self.game = NewRound()

    def read_preferences_file(self):
        """Read preferences data from disk.
        Copied from Comix.
        """
        if os.path.isfile(__config_path__):
            try:
                config = open(__config_path__)
                old___prefs__ = cPickle.load(config)
                config.close()
            except Exception:
                print 'Corrupted preferences file \
                "%s", deleting...' % __config_path__
                os.remove(__config_path__)
            else:
                for key in old___prefs__:
                    if key in __prefs__:
                        __prefs__[key] = old___prefs__[key]

    def write_preferences_file(self):
        """Write preference data to disk.
        Copied from Comix.
        """
        config = open(__config_path__, 'w')
        cPickle.dump(__prefs__, config, cPickle.HIGHEST_PROTOCOL)
        config.close()

    def build_hint_table(self):
        """Create the controls for the hint table."""
        hint_table = self.widget_tree.get_widget('hint_table')
        for name in (0, 40):
            table = gtk.Table(rows=11, columns=6)
            hint_table.pack_start(table)

            # Create row labels
            for row in range(0, 10):
                label = gtk.CheckButton(str(row))
                table.attach(label, 0, 1, row+1, row+2)
                label.connect('toggled', self.change_row, row+name)
                self.label_hint.append(label)

            for col in range(1, 5):
                # Create column labels
                #label = gtk.Label(str(col))
                #table.attach(label, col, col+1, 0, 1)
                # Create Checkboxes
                for row in range(0, 10):
                    checkbutton = gtk.CheckButton()
                    table.attach(checkbutton, col, col+1, row+1, row+2)
                    self.cb_hint.append(checkbutton)

            if name == 0: # First table
                hint_table.pack_start(gtk.VSeparator())
        self.init_hint_table()

    def change_row(self, widget, row):
        """Toggle a rows state."""
        enable = widget.get_active()
        for col in range(0, 4):
            self.cb_hint[10 * col + row].set_sensitive(enable)

    def init_hint_table(self):
        """Reset all controls in the hinttable to their default state."""
        for i in range(0, 40):
            self.cb_hint[i].set_active(True)
            self.cb_hint[i+40].set_active(False)
            self.cb_hint[i+40].set_sensitive(False)
        self.cb_hint[0].set_active(False)
        for row in range(0, 10):
            self.label_hint[row].set_active(True)
            self.label_hint[row+10].set_active(False)
    
    #         1    2    3    4                   1    2    3    4
    #  0/0    00   10   20   30          0/10    40   50   60   70
    #  1/1    01   11   21   31          1/11    41   51   61   71
    #  2/2    02   12   22   32          2/12    42   52   62   72
    # ...

    def get_checkbox(self, row, col, tablenr=0):
        """Get the checkbox at the specified position."""
        return self.cb_hint[tablenr * 40 + col * 10 + row]

    def get_label(self, row, tablenr=0):
        """Get the label at the specified position."""
        return self.label_hint[tablenr*10 + row]

    def on_entry_activate(self, widget):
        """when input is accepted."""
        bulls, cows = 0, 0
        number = ''
        # check input
        if self.game.guess < 8:
            number = self.entry.get_text()
            if number == '':
                self.process_error(_('Must input something.'))
                return False
            elif number[0] == '0':
                self.process_error(_('First digit cannot be zero.'))
                return False
            try:
                number = repr(int(number))
            except ValueError:
                self.process_error(_('Must input a number.'))
                return False
            if len(number) < 4:
                self.process_error(_('Must input four digits.'))
                return False
            elif len(set(number)) < 4:
                self.process_error(_('Four digits must be unique.'))
                return False
            elif number in self.game.guesses:
                self.process_error(_("You've already guessed it."))
                return False
            self.game.guesses.append(number)
            # process input
            for i in xrange(4):
                for j in xrange(4):
                    if self.game.answer[i] == int(number[j]):
                        if i == j:
                            bulls += 1
                        else:
                            cows += 1
            guess_label = getattr(self, 'g' + repr(self.game.guess))
            result_label = getattr(self, 'r' + repr(self.game.guess))
            guess_label.set_text(number)
            result_label.set_text('%dA%dB' % (bulls, cows))

            if self.auto_fill_hints.get_active():
                self.fill_hints(number, bulls, cows)
            
            # win
            if bulls == 4:
                self.info_label.set_text(_('You win! :)'))
                self.get_time_taken_till_now()
                self.time_label.set_text(_('Used %.1f s.') % 
                    self.game.time_taken)
                self.ok_button.set_sensitive(False)
                self.entry.set_sensitive(False)
                if self.is_high_score(self.game.time_taken):
                    new_score_rank = self.write_score(self.game.time_taken)
                    self.show_score(new_score_rank)
            # lose
            elif self.game.guess == 7:
                answer = ''
                for i in xrange(4):
                    answer += repr(self.game.answer[i])
                self.info_label.set_text(_('Haha, you lose. It is %s.') % 
                    answer)
                self.get_time_taken_till_now()
                self.time_label.set_text(_('Wasted %.1f s.') % 
                    self.game.time_taken)
                self.ok_button.set_sensitive(False)
                self.entry.set_sensitive(False)
        self.game.guess += 1
        self.entry.grab_focus()

    def clear_row(self, row):
        """Clear a complete row."""
        self.get_label(row, 0).set_active(False)
        for col in range(0, 4):
            self.get_checkbox(row, col, 0).set_active(False)
            self.get_checkbox(row, col, 1).set_active(False)

    def fill_hints(self, number, bulls, cows):
        """Auto filling some obvious cases in the hint table."""
        number = [int(x) for x in number]
        if bulls == 0 and cows == 0:
            for digit in number:
                self.clear_row(digit)
            return

        if bulls+cows == 4:
            for digit in range(0, 10):
                if digit in number:
                    self.get_label(digit, 0).set_active(True)
                    self.get_label(digit, 1).set_active(True)
                else:
                    self.clear_row(digit)

        if bulls == 0: # Only cows
            for digit_pos in range(0, 4):
                self.get_checkbox(number[digit_pos], digit_pos, 
                    0).set_active(False)
                self.get_checkbox(number[digit_pos], digit_pos, 
                    1).set_active(False)

        if cows == 0: # Only bulls
        # Only digits which are either in the right place or completely wrong
            for digit_pos in range(0, 4):
                for pos2 in range(0, 4):
                    if pos2 == digit_pos:
                        continue
                    # uncheck impossible boxes in first column
                    self.get_checkbox(number[digit_pos], pos2, 
                        0).set_active(False)

    def on_entry_changed(self, widget):
        """Start timer as soon as the user enters the first digit."""
        self.info_label.set_text('')
        if self.game.on_entry_cb_first_called == True:
            self.time_label.set_text(_('Timer started...'))
            self.game.time_start = time.time()
            self.game.on_entry_cb_first_called = False
  
    def on_view_toolbar_toggled(self, widget):
        """Toggle toolbar visibility."""
        if self.toolbar.get_property('visible'):
            self.toolbar.hide()
            __prefs__['show toolbar'] = False
        else:
            self.toolbar.show()
            __prefs__['show toolbar'] = True

    def on_view_hint_table_toggled(self, widget):
        """Toggle hint table visibility."""
        if self.hint_table.get_property('visible'):
            self.hint_table.hide_all()
            self.hint_hseparator.hide()
            __prefs__['show hint table'] = False
        else:
            self.hint_table.show_all()
            self.hint_hseparator.show()
            __prefs__['show hint table'] = True
    
    def on_view_auto_fill_hints_toggled(self, widget):
        """Toggle auto filling of hint table."""
        if self.auto_fill_hints.get_active():
            __prefs__['auto fill hints'] = True
        else:
            __prefs__['auto fill hints'] = False

    @classmethod
    def on_help_activate(cls, widget):
        """Show help."""
        for helpfile in __helpfiles__:
            try:
                file(helpfile)
            except IOError:
                continue
            webbrowser.open(helpfile)

    @classmethod
    def on_about_activate(cls, widget):
        """Show about dialog."""
        about = AboutDialog().about_dialog
        about.run()
        about.destroy()
    
    @classmethod
    def on_score_activate(cls, new_score_rank):
        """Show high scores."""
        score_dialog = ScoreDialog()
        dlg = score_dialog.score_dialog
        score_view = score_dialog.score_view
        sv_selection = score_view.get_selection()
        sv_selection.set_mode(gtk.SELECTION_NONE)
        column = gtk.TreeViewColumn(
                _('Name'), gtk.CellRendererText(), text = 0)
        score_view.append_column(column)
        column = gtk.TreeViewColumn(
                _('Score'), gtk.CellRendererText(), text = 1)
        score_view.append_column(column)
        column = gtk.TreeViewColumn(
                _('Date'), gtk.CellRendererText(), text = 2)
        score_view.append_column(column)
        dlg.scoreList = gtk.ListStore(str, str, str)
        score_view.set_model(dlg.scoreList)

        try:
            scores = [line.split(' ', 6) 
                    for line in file(__score_filename__, 'r')]
        except IOError:
            scores = []

        for line in scores:
            score_tup = line[0], line[1], ' '.join(line[2:]).rstrip('\n')
            dlg.scoreList.append(score_tup)
        # high light the current high score entry
        try:
            sv_selection.set_mode(gtk.SELECTION_SINGLE)
            sv_selection.select_path(new_score_rank)
        except TypeError:
            sv_selection.set_mode(gtk.SELECTION_NONE)

        dlg.run()
        dlg.destroy()

    def on_new_game_activate(self, widget):
        """New game initialization."""
        self.game = NewRound()
        self.ok_button.set_sensitive(True)
        self.entry.set_sensitive(True)
        self.entry.grab_focus()
        # won't start the timer when you just start a new game
        self.game.on_entry_cb_first_called = False
        self.entry.set_text('')
        self.game.on_entry_cb_first_called = True
        self.info_label.set_text(_('Ready'))
        self.time_label.set_text('')

        for i in xrange(8):
            getattr(self, 'g' + repr(i)).set_text('')
            getattr(self, 'r' + repr(i)).set_text('')
        
        self.init_hint_table()

    def process_error(self, msg):
        """Show error message in statusbar."""
        self.info_label.set_text(msg)
        self.entry.grab_focus()

    def get_time_taken_till_now(self):
        """Get time since start of the game."""
        self.game.time_end = time.time()
        self.game.time_taken = self.game.time_end - self.game.time_start
        self.game.time_taken = round(self.game.time_taken, 1)

    @classmethod
    def is_high_score(cls, time_taken):
        """Is this time a highscore."""
        try:
            scores = [line.split(' ', 6) 
                    for line in file(__score_filename__, 'r')]
        except IOError:
            return True # List does not exist yet
        if len(scores) < 10:
            return True
        scores = sorted(scores, key = lambda x: float(x[1][:-1]))
        if time_taken < float(scores[-1][1][:-1]):
            return True
        else:
            return False

    @classmethod
    def write_score(cls, time_taken):
        """Write highscore file."""
        date = time.strftime("%a %b %d %H:%M:%S %Y") 
        new_score = "%s %ss %s\n" % (
                os.getenv('USERNAME'), time_taken, date)
        try:
            saved_scores = open(__score_filename__, 'r').readlines()
        except IOError:
            saved_scores = [] 
        saved_scores.append(new_score)
        scores = [line.split(' ', 6) for line in saved_scores]
        scores = sorted(scores, key = lambda x: float(x[1][:-1]))
        scores = scores[:10]

        # find the index of the new score
        new_score = new_score.split(' ', 6)
        new_score_rank = scores.index(new_score)
        try:
            scorefile = open(__score_filename__, 'w')
        except IOError:
            # Most likely the directory does not exist
            new_dir = os.path.dirname(__score_filename__)
            os.mkdir(new_dir)
            scorefile = open(__score_filename__, 'w') # Try again
        for score in scores:
            scorefile.write(' '.join(score))
        scorefile.close()
        return new_score_rank

    def show_score(self, new_score_rank):
        """Show highscore dialog."""
        self.on_score_activate(new_score_rank)
    
    def terminate_program(self, widget):
        """Run clean-up tasks and exit.
        Copied from comix.        
        """
        self.write_preferences_file()
        gtk.main_quit()


class AboutDialog(object):
    """The about dialog."""
    def __init__(self):
        self.widget_tree = load_glade('about_dialog')
        self.about_dialog = self.widget_tree.get_widget("about_dialog")
        gtk.about_dialog_set_url_hook(
                lambda about_dialog, url: webbrowser.open(url))
        self.about_dialog.set_website(
                'http://fourdigits.sourceforge.net')
        self.about_dialog.set_website_label(
                'http://fourdigits.sourceforge.net')


class ScoreDialog(object):
    """The score dialog."""
    def __init__(self):
        self.widget_tree = load_glade('score_dialog')
        self.score_dialog = self.widget_tree.get_widget('score_dialog')
        self.score_view = self.widget_tree.get_widget('score_view')


class NewRound(object):
    """Contains data in one round of the game."""
    def __init__(self):
        while True:
            self.answer = random.sample(range(10), 4)
            if self.answer[0] != 0: # first digit cannot be zero
                break
        #print self.answer
        if self.answer == [4, 6, 1, 9]:
            gtk.MessageDialog(message_format
                    ='4619: You are the luckiest guy on the planet!').show()
        self.guess = 0
        self.guesses = []
        self.time_start = 0
        self.time_end = 0
        self.time_taken = 0
        self.on_entry_cb_first_called = True

if __name__ == "__main__":
    MainWindow()
    gtk.main()