def help_credits(app, timeout=0, sound=True):
    if sound:
        app.audio.playSample("credits")
    t = ""
    if TOOLKIT == "tk":
        t = "Tcl/Tk"
    elif TOOLKIT == "gtk":
        t = "PyGTK"
    elif TOOLKIT == "kde":
        t = "pyKDE"
    elif TOOLKIT == "wx":
        t = "wxPython"
    elif TOOLKIT == "kivy":
        t = "kivy"
    d = MfxMessageDialog(
        app.top, title=_("Credits"), timeout=timeout,
        text=TITLE+_(''' credits go to:

Volker Weidner for getting me into Solitaire
Guido van Rossum for the initial example program
T. Kirk for lots of contributed games and cardsets
Carl Larsson for the background music
The Gnome AisleRiot team for parts of the documentation
Natascha

The Python, %s, SDL & Linux crews
for making this program possible''') % t,
        image=app.gimages.logos[3], image_side="right",
        separator=True)
    return d.status

 def initKw(self, kw):
     strings=[_('&Start'), _('&Play'), _('&New'), _('&Close'),]
     kw = KwStruct(kw,
                   strings=strings,
                   default=0,
                   )
     return MfxDialog.initKw(self, kw)

 def initKw(self, kw):
     strings = [_("&OK"), _("&Apply"), _("&Cancel"), ]
     kw = KwStruct(kw,
                   strings=strings,
                   default=0,
                   )
     return MfxDialog.initKw(self, kw)

 def _addCardsetsByType(self, store, root_label, all_cardsets,
                        cardset_types, selecter_type, registered):
     manager = self.manager
     root_iter = store.append(None)
     store.set(root_iter, 0, root_label, 1, -1)
     items = cardset_types.items()
     items.sort(lambda a, b: cmp(a[1], b[1]))
     added = False
     for key, label in items:
         if key not in getattr(manager, registered):
             continue
         cardsets = []
         for cs in all_cardsets:
             si = getattr(cs.si, selecter_type)
             if isinstance(si, int): # type
                 if key == si:
                     cardsets.append((cs.index, cs.name))
             else: # style, nationality, date
                 if key in si:
                     cardsets.append((cs.index, cs.name))
         if cardsets:
             added = True
             self._addCardsets(store, root_iter, label, cardsets)
     if added:
         selecter = lambda cs, selecter_type=selecter_type: \
                        not getattr(cs.si, selecter_type)
         cs = self._selectCardset(all_cardsets, selecter)
         if cs:
             self._addCardsets(store, root_iter, _('Uncategorized'), cs)
     else:
         iter = store.append(root_iter)
         store.set(iter, 0, _('(no cardsets)'), 1, -1)

 def initKw(self, kw):
     kw = KwStruct(kw,
                   strings=(_("&OK"), (_("Session &log..."), 104),
                            (_("&Save to file"), 203)), default=0,
                   width=76*self.CHAR_W,
                   )
     return AllGames_StatsDialog.initKw(self, kw)

 def initKw(self, kw):
     kw = KwStruct(kw,
                   strings=((_("&Rules"), 10), 'sep',
                            _("&Select"), _("&Cancel"),),
                   default=0,
                   )
     return SelectGameDialog.initKw(self, kw)

 def __init__(self, parent, title, app, player, gameid, **kw):
     self.app = app
     self.selected_game = None
     kw = self.initKw(kw)
     MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
     top_frame, bottom_frame = self.createFrames(kw)
     self.top_frame = top_frame
     self.createBitmaps(top_frame, kw)
     #
     self.player = player or _("Demo games")
     self.top.wm_minsize(200, 200)
     self.button = kw.default
     #
     # createChart = self.create3DBarChart
     createChart = self.createPieChart
     # createChart = self.createSimpleChart
     #  if parent.winfo_screenwidth() < 800 or parent.winfo_screenheight() <
     #        600:
     #      createChart = self.createPieChart
     #      createChart = self.createSimpleChart
     #
     self.font = self.app.getFont("default")
     self.tk_font = tkinter_font.Font(self.top, self.font)
     self.font_metrics = self.tk_font.metrics()
     self._calc_tabs()
     #
     won, lost = app.stats.getStats(player, gameid)
     createChart(app, won, lost, _("Total"))
     won, lost = app.stats.getSessionStats(player, gameid)
     createChart(app, won, lost, _("Current session"))
     #
     focus = self.createButtons(bottom_frame, kw)
     self.mainloop(focus, kw.timeout)

    def __init__(self, parent, app=None, home=None):
        self.parent = parent
        self.app = app
        self.home = home
        self.url = None
        self.history = Struct(
            list = [],
            index = 0,
        )
        self.visited_urls = []
        self.images = {}    # need to keep a reference because of garbage collection
        self.defcursor = parent["cursor"]
        ##self.defcursor = 'xterm'
        self.handcursor = "hand2"

        # create buttons
        button_width = 8
        self.homeButton = Tkinter.Button(parent, text=_("Index"),
                                         width=button_width,
                                         command=self.goHome)
        self.homeButton.grid(row=0, column=0, sticky='w')
        self.backButton = Tkinter.Button(parent, text=_("Back"),
                                         width=button_width,
                                         command=self.goBack)
        self.backButton.grid(row=0, column=1, sticky='w')
        self.forwardButton = Tkinter.Button(parent, text=_("Forward"),
                                            width=button_width,
                                            command=self.goForward)
        self.forwardButton.grid(row=0, column=2, sticky='w')
        self.closeButton = Tkinter.Button(parent, text=_("Close"),
                                          width=button_width,
                                          command=self.destroy)
        self.closeButton.grid(row=0, column=3, sticky='e')

        # create text widget
        text_frame = Tkinter.Frame(parent)
        text_frame.grid(row=1, column=0, columnspan=4, sticky='nsew')
        text_frame.grid_propagate(False)
        vbar = Tkinter.Scrollbar(text_frame)
        vbar.pack(side='right', fill='y')
        self.text = Tkinter.Text(text_frame,
                                 fg='black', bg='white',
                                 bd=1, relief='sunken',
                                 cursor=self.defcursor,
                                 wrap='word', padx=10)
        self.text.pack(side='left', fill='both', expand=True)
        self.text["yscrollcommand"] = vbar.set
        vbar["command"] = self.text.yview

        # statusbar
        self.statusbar = HtmlStatusbar(parent, row=2, column=0, columnspan=4)

        parent.columnconfigure(2, weight=1)
        parent.rowconfigure(1, weight=1)

        # load images
        for name, fn in self.symbols_fn.items():
            self.symbols_img[name] = self.getImage(fn)

        self.initBindings()

 def initKw(self, kw):
     kwdefault(kw,
               strings=(_("&Select"), _("&Rules"), _("&Cancel"),),
               default=0,
               width=600, height=400,
               )
     return MfxDialog.initKw(self, kw)

    def startSolving(self):
        from gettext import ungettext

        self._reset()
        game = self.app.game
        solver = game.Solver_Class(game, self)  # create solver instance
        game.solver = solver
        preset = self.preset_var.get()
        max_iters = self._getMaxIters()
        progress = self.app.opt.solver_show_progress
        solver.config(preset=preset, max_iters=max_iters, progress=progress)
        try:
            solver.computeHints()
        except RuntimeError:
            self.result_label['text'] = _('Solver not found in the PATH')
            return
        hints_len = len(solver.hints)-1
        if hints_len > 0:
            t = ungettext('This game is solvable in %d move.',
                          'This game is solvable in %d moves.',
                          hints_len) % hints_len
            self.result_label['text'] = t
            self.play_button.config(state='normal')
        else:
            self.result_label['text'] = \
                (_('I could not solve this game.')
                 if solver.solver_state == 'unsolved'
                 else _('Iterations count exceeded (Intractable)'))
            self.play_button.config(state='disabled')

 def __init__(self, values_map, default, var_name,
              label, widget='menu'):
     self.values_map = values_map
     self.default = default
     ##self.values_dict = dict(self.values_map)
     self.translation_map = {}       # for backward translation
     if widget == 'menu':
         self.values = []
         for k, v in self.values_map:
             self.values.append(k)
             self.translation_map[_(k)] = k
         assert self.default in self.values
     elif widget == 'preset':
         self.values = []
         for v in self.values_map:
             self.values.append(v)
             self.translation_map[_(v)] = v
         assert self.default in self.values
     else:
         self.values = self.values_map
     self.var_name = var_name
     self.label = label
     self.widget = widget
     self.variable = None            # Tk variable
     self.current_value = None

 def _calc_tabs(self):
     #
     font = self.dialog.tkfont
     t0 = self.oval_width+70
     t = ''
     for i in (_("Won:"),
               _("Lost:"),
               _("Total:")):
         if len(i) > len(t):
             t = i
     t1 = font.measure(t)
     #  t1 = max(font.measure(_("Won:")),
     #           font.measure(_("Lost:")),
     #           font.measure(_("Total:")))
     t1 += 10
     # t2 = font.measure('99999')+10
     t2 = 45
     # t3 = font.measure('100%')+10
     t3 = 45
     tx = (t0, t0+t1+t2, t0+t1+t2+t3, t0+t1+t2+t3+20)
     #
     ls = self.dialog.font_metrics['linespace']
     ls += 5
     # ls = max(ls, 20)
     ty = (5, 5+ls, 5+2*ls+15, max(85, 5+3*ls+15))
     #
     self.tab_x, self.tab_y = tx, ty

 def _createChartTexts(self, tx, ty, won, lost):
     c, tfont, fg = self.canvas, self.font, self.fg
     pwon, plost = self._getPwon(won, lost)
     #
     x = tx[0]
     dy = int(self.font_metrics['ascent']) - 10
     dy = dy / 2
     c.create_text(x, ty[0] - dy, text=_("Won:"),
                   anchor="nw", font=tfont, fill=fg)
     c.create_text(x, ty[1] - dy, text=_("Lost:"),
                   anchor="nw", font=tfont, fill=fg)
     c.create_text(x, ty[2] - dy, text=_("Total:"),
                   anchor="nw", font=tfont, fill=fg)
     x = tx[1] - 16
     c.create_text(x, ty[0] - dy, text="%d" %
                   won, anchor="ne", font=tfont, fill=fg)
     c.create_text(x, ty[1] - dy, text="%d" %
                   lost, anchor="ne", font=tfont, fill=fg)
     c.create_text(x, ty[2] - dy, text="%d" %
                   (won + lost), anchor="ne", font=tfont, fill=fg)
     y = ty[2] - 11
     c.create_line(tx[0], y, x, y, fill=fg)
     if won + lost > 0:
         x = tx[2]
         pw = int(round(100.0 * pwon))
         c.create_text(x, ty[0] - dy, text="%d%%" %
                       pw, anchor="ne", font=tfont, fill=fg)
         c.create_text(x, ty[1] - dy, text="%d%%" %
                       (100 - pw), anchor="ne", font=tfont, fill=fg)

    def _createStore(self):
        store = gtk.TreeStore(gobject.TYPE_STRING,
                              gobject.TYPE_INT)
        manager = self.manager
        all_cardsets = manager.getAllSortedByName()
        all_cardsets = [obj for obj in all_cardsets if not obj.error]

        cs = self._selectCardset(all_cardsets, None)
        self._addCardsets(store, None, 'All cadsets', cs)

        root_iter = store.append(None)
        store.set(root_iter, 0, _('by Size'), 1, -1)
        for label, selecter in (
            (_("Tiny cardsets"),   lambda cs: cs.si.size == CSI.SIZE_TINY),
            (_("Small cardsets"),  lambda cs: cs.si.size == CSI.SIZE_SMALL),
            (_("Medium cardsets"), lambda cs: cs.si.size == CSI.SIZE_MEDIUM),
            (_("Large cardsets"),  lambda cs: cs.si.size == CSI.SIZE_LARGE),
            (_("XLarge cardsets"), lambda cs: cs.si.size == CSI.SIZE_XLARGE),):
            cs = self._selectCardset(all_cardsets, selecter)
            if cs:
                self._addCardsets(store, root_iter, label, cs)

        self._addCardsetsByType(store, _('by Type'), all_cardsets,
                                CSI.TYPE, 'type', 'registered_types')
        self._addCardsetsByType(store, _('by Style'), all_cardsets,
                                CSI.STYLE, 'styles', 'registered_styles')
        self._addCardsetsByType(store, _('by Nationality'), all_cardsets,
                                CSI.NATIONALITY, 'nationalities',
                                'registered_nationalities')
        self._addCardsetsByType(store, _('by Date'), all_cardsets,
                                CSI.DATE, 'dates', 'registered_dates')

        self._cardset_store = store

 def initKw(self, kw):
     strings = [_('&Start'), _('&Play'), _('&New'), 'sep', _('&Close'), ]
     kw = KwStruct(kw,
                   strings=strings,
                   default=0,
                   )
     return self._calc_MfxDialog().initKw(self, kw)

 def _createLogList(self, name):
     #
     treeview = self.widgets_tree.get_widget(name)
     n = 0
     for label in (
         _('Game'),
         _('Game number'),
         _('Started at'),
         _('Status'),
             ):
         column = gtk.TreeViewColumn(label, gtk.CellRendererText(),
                                     text=n)
         column.set_resizable(True)
         column.set_sort_column_id(n)
         treeview.append_column(column)
         n += 1
     #
     store = gtk.ListStore(gobject.TYPE_STRING,  # game name
                           gobject.TYPE_STRING,  # game number
                           gobject.TYPE_STRING,  # started at
                           gobject.TYPE_STRING,  # status
                           gobject.TYPE_INT,     # gameid
                           )
     treeview.set_model(store)
     treeview.set_rules_hint(True)
     return store

 def initKw(self, kw):
     kw = KwStruct(kw,
                   strings=(_('&OK'), _('&Cancel')),
                   default=0,
                   separator=False,
                   )
     return MfxDialog.initKw(self, kw)

 def __init__(self, parent, title, app, **kw):
     kw = self.initKw(kw)
     MfxDialog.__init__(self, parent, title, **kw)
     #
     top_box, bottom_box = self.createVBox()
     #
     label = gtk.Label('Please enter your name')
     label.show()
     top_box.pack_start(label)
     self.player_entry = gtk.Entry()
     self.player_entry.show()
     top_box.pack_start(self.player_entry, expand=False)
     completion = gtk.EntryCompletion()
     self.player_entry.set_completion(completion)
     model = gtk.ListStore(gobject.TYPE_STRING)
     for name in app.getAllUserNames():
         iter = model.append()
         model.set(iter, 0, name)
     completion.set_model(model)
     completion.set_text_column(0)
     self.player_entry.set_text(app.opt.player)
     #
     self.confirm_quit_check = gtk.CheckButton(_('Confirm quit'))
     self.confirm_quit_check.show()
     top_box.pack_start(self.confirm_quit_check)
     self.confirm_quit_check.set_active(app.opt.confirm != 0)
     #
     self.update_stats_check = gtk.CheckButton(_('Update statistics and logs'))
     self.update_stats_check.show()
     top_box.pack_start(self.update_stats_check)
     self.update_stats_check.set_active(app.opt.update_player_stats != 0)
     #
     self.createButtons(bottom_box, kw)
     self.show_all()
     gtk.main()

 def mEditGameComment(self, *args):
     if self._cancelDrag(break_pause=False): return
     game, gi = self.game, self.game.gameinfo
     t = " " + game.getGameNumber(format=1)
     cc = _("Comments for %s:\n\n") % (gi.name + t)
     c = game.gsaveinfo.comment or cc
     d = EditTextDialog(game.top, _("Comments for ")+t, text=c)
     if d.status == 0 and d.button == 0:
         text = d.text
         if text.strip() == cc.strip():
             game.gsaveinfo.comment = ""
         else:
             game.gsaveinfo.comment = d.text
             # save to file
             fn = os.path.join(self.app.dn.config, "comments.txt")
             fn = os.path.normpath(fn)
             if not text.endswith(os.linesep):
                 text += os.linesep
             enc = locale.getpreferredencoding()
             try:
                 fd = open(fn, 'a')
                 fd.write(text.encode(enc, 'replace'))
             except Exception, err:
                 d = MfxExceptionDialog(self.top, err,
                                        text=_("Error while writing to file"))
             else:
                 if fd: fd.close()
                 d = MfxMessageDialog(self.top, title=TITLE+_(" Info"), bitmap="info",
                                      text=_("Comments were appended to\n\n") + fn)

    def _mahjonggShuffle(self):
        talon = self.s.talon
        rows = []
        cards = []

        for r in self.s.rows:
            if r.cards:
                rows.append(r)
                cards.append(r.cards[0])
        if not rows:
            return

        if self.app.opt.mahjongg_create_solvable == 0:
            self.playSample('turnwaste')
            old_state = self.enterState(self.S_FILL)
            self.saveSeedMove()
            for r in rows:
                self.moveMove(1, r, talon, frames=0)
            self.shuffleStackMove(talon)
            for r in rows:
                self.moveMove(1, talon, r, frames=0)
            self.leaveState(old_state)
            self.finishMove()
            return

        self.playSample('turnwaste')
        old_state = self.enterState(self.S_FILL)
        self.saveSeedMove()

        new_cards = self._shuffleHook2(rows, cards)
        if new_cards is None:
            if TOOLKIT != 'kivy':
                MfxMessageDialog(self.top, title=_('Warning'),
                                 text=_('''\
Sorry, I can\'t find
a solvable configuration.'''),
                                 bitmap='warning')

            self.leaveState(old_state)
            # self.finishMove()
            # hack
            am = self.moves.current[0]
            am.undo(self)               # restore random
            self.moves.current = []
            return

        self.stats.shuffle_moves += 1
        # move new_cards to talon
        for c in new_cards:
            for r in rows:
                if r.cards and r.cards[0] is c:
                    self.moveMove(1, r, talon, frames=0)
                    break
        # deal
        for r in rows:
            self.moveMove(1, talon, r, frames=0)

        self.leaveState(old_state)
        self.finishMove()