Ejemplo n.º 1
0
 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
Ejemplo n.º 2
0
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
Ejemplo n.º 3
0
 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()
Ejemplo n.º 4
0
 def _calc_tabs(self):
     #
     font = self.tk_font
     t0 = 160
     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)
     #
     ls = self.font_metrics['linespace']
     ls += 5
     ls = max(ls, 20)
     ty = (ls, 2*ls, 3*ls+15, 3*ls+25)
     #
     self.tab_x, self.tab_y = tx, ty
Ejemplo n.º 5
0
 def initKw(self, kw):
     kw = KwStruct(
         kw,
         strings=(_("&OK"), (_("&Full log..."), 103),
                  (_("&Save to file"), 204)),
         default=0,)
     return FullLog_StatsDialog.initKw(self, kw)
Ejemplo n.º 6
0
 def initKw(self, kw):
     kw = KwStruct(kw,
                   strings=(_('&OK'), _('&Cancel')),
                   default=0,
                   separator=False,
                   )
     return MfxDialog.initKw(self, kw)
Ejemplo n.º 7
0
 def initKw(self, kw):
     strings = [_('&Start'), _('&Play'), _('&New'), 'sep', _('&Close'), ]
     kw = KwStruct(kw,
                   strings=strings,
                   default=0,
                   )
     return self._calc_MfxDialog().initKw(self, kw)
Ejemplo n.º 8
0
 def initKw(self, kw):
     kw = KwStruct(kw,
                   strings=((_("&Rules"), 10), 'sep',
                            _("&Select"), _("&Cancel"),),
                   default=0,
                   )
     return SelectGameDialog.initKw(self, kw)
Ejemplo n.º 9
0
 def initKw(self, kw):
     kwdefault(kw,
               strings=(_("&Select"), _("&Rules"), _("&Cancel"),),
               default=0,
               width=600, height=400,
               )
     return MfxDialog.initKw(self, kw)
Ejemplo n.º 10
0
 def initKw(self, kw):
     strings=[_('&Start'), _('&Play'), _('&New'), _('&Close'),]
     kw = KwStruct(kw,
                   strings=strings,
                   default=0,
                   )
     return MfxDialog.initKw(self, kw)
Ejemplo n.º 11
0
 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)
Ejemplo n.º 12
0
 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
Ejemplo n.º 13
0
 def initKw(self, kw):
     strings = [_("&OK"), _("&Apply"), _("&Cancel"), ]
     kw = KwStruct(kw,
                   strings=strings,
                   default=0,
                   )
     return MfxDialog.initKw(self, kw)
Ejemplo n.º 14
0
 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)
Ejemplo n.º 15
0
    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()
Ejemplo n.º 16
0
 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)
Ejemplo n.º 17
0
    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')
Ejemplo n.º 18
0
 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)
Ejemplo n.º 19
0
 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
Ejemplo n.º 20
0
    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
Ejemplo n.º 21
0
 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)
Ejemplo n.º 22
0
    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()
Ejemplo n.º 23
0
    def mOptSoundDirectX(self, *event):
        ##print self.sound_mode.get()
        d = MfxMessageDialog(self.top, title=_("Sound preferences info"),
                      text=_("""\
Changing DirectX settings will take effect
the next time you restart """)+TITLE,
                      bitmap="warning",
                      default=0, strings=(_("&OK"),))
Ejemplo n.º 24
0
 def initKw(self, kw):
     kw = KwStruct(kw,
                   strings=(_("&OK"), _("&Cancel")),
                   default=-1,
                   resizable=False,
                   separator=False,
                   )
     return MfxDialog.initKw(self, kw)
Ejemplo n.º 25
0
 def initKw(self, kw):
     kw = KwStruct(kw,
                   strings=(_("&OK"), _("&Cancel")),
                   default=-1,
                   resizable=self._calc_Resizable(),
                   separator=False,
                   )
     return self._calc_MfxDialog().initKw(self, kw)
Ejemplo n.º 26
0
 def initKw(self, kw):
     kw = KwStruct(kw,
                   strings=(_("&OK"), _("&Cancel")),
                   default=0,
                   padx=10, pady=10,
                   buttonpadx=10, buttonpady=5,
                   )
     return MfxDialog.initKw(self, kw)
Ejemplo n.º 27
0
 def mRestart(self, *args):
     if self._cancelDrag(): return
     if self.game.moves.index == 0:
         return
     if self.changed(restart=1):
         if not self.game.areYouSure(_("Restart game"),
                                     _("Restart this game ?")):
             return
     self.game.restartGame()
Ejemplo n.º 28
0
 def mClearBookmarks(self, *args):
     if self._cancelDrag(): return
     if not self.app.opt.bookmarks: return
     if not self.game.gsaveinfo.bookmarks: return
     if not self.game.areYouSure(_("Clear bookmarks"),
                                 _("Clear all bookmarks ?")):
         return
     self.game.gsaveinfo.bookmarks = {}
     self.game.updateMenus()
Ejemplo n.º 29
0
 def initKw(self, kw):
     kwdefault(kw,
               strings=(_('&OK'), _('&Solid color...'), _('&Cancel'),),
               default=0,
               resizable=1,
               padx=10, pady=10,
               width=600, height=400,
               )
     return MfxDialog.initKw(self, kw)
Ejemplo n.º 30
0
    def __init__(self, parent, title, top, **kw):
        kw = self.initKw(kw)
        MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
        top_frame, bottom_frame = self.createFrames(kw)
        self.createBitmaps(top_frame, kw)

        cnf = {'master': top_frame,
               'highlightthickness': 1,
               'highlightbackground': 'black',
               }
        frame = tkinter.Frame(**cnf)
        frame.pack(expand=True, fill='both', padx=10, pady=10)
        frame.columnconfigure(0, weight=1)
        cnf['master'] = frame
        cnf['text'] = _('N')
        label = tkinter.Label(**cnf)
        label.grid(row=0, column=0, sticky='ew')
        cnf['text'] = _('Game number')
        label = tkinter.Label(**cnf)
        label.grid(row=0, column=1, sticky='ew')
        cnf['text'] = _('Started at')
        label = tkinter.Label(**cnf)
        label.grid(row=0, column=2, sticky='ew')
        cnf['text'] = _('Result')
        label = tkinter.Label(**cnf)
        label.grid(row=0, column=3, sticky='ew')

        row = 1
        for i in top:
            # N
            cnf['text'] = str(row)
            label = tkinter.Label(**cnf)
            label.grid(row=row, column=0, sticky='ew')
            # Game number
            cnf['text'] = '#'+str(i.game_number)
            label = tkinter.Label(**cnf)
            label.grid(row=row, column=1, sticky='ew')
            # Start time
            t = time.strftime(
                '%Y-%m-%d %H:%M', time.localtime(i.game_start_time))
            cnf['text'] = t
            label = tkinter.Label(**cnf)
            label.grid(row=row, column=2, sticky='ew')
            # Result
            if isinstance(i.value, float):
                # time
                s = format_time(i.value)
            else:
                # moves
                s = str(i.value)
            cnf['text'] = s
            label = tkinter.Label(**cnf)
            label.grid(row=row, column=3, sticky='ew')
            row += 1

        focus = self.createButtons(bottom_frame, kw)
        self.mainloop(focus, kw.timeout)
Ejemplo n.º 31
0
 def writeSessionLog(self, player):
     if player is None:
         player = _('Demo')
     header = _("Session log for %(player)s") % {'player': player}
     prev_games = self.app.stats.session_games.get(player)
     return self.writeLog(player, header, prev_games)
Ejemplo n.º 32
0
    def display(self, url, add=1, relpath=1, position=(0, 0)):
        # print 'display:', url, position
        # for some reason we have to stop the PySol demo
        # (is this a multithread problem with tkinter ?)
        try:
            # self.app.game.stopDemo()
            # self.app.game._cancelDrag()
            pass
        except Exception:
            pass

        # ftp: and http: would work if we use urllib, but this widget is
        # far too limited to display anything but our documentation...
        for p in REMOTE_PROTOCOLS:
            if url.startswith(p):
                if not openURL(url):
                    self.errorDialog(_('''%(app)s HTML limitation:
The %(protocol)s protocol is not supported yet.

Please use your standard web browser
to open the following URL:
%(url)s
''') % {'app': TITLE, 'protocol': p, 'url': url})
                return

        # locate the file relative to the current url
        url = self.basejoin(url, relpath=relpath)

        # read the file
        try:
            file = None
            if 0:
                import urllib
                file = urllib.urlopen(url)
            else:
                file, url = self.openfile(url)
            data = file.read()
            file.close()
            file = None
        except Exception as ex:
            if file:
                file.close()
            self.errorDialog(
                _('Unable to service request:\n') + url + '\n\n' + str(ex))
            return
        except Exception:
            if file:
                file.close()
            self.errorDialog(_('Unable to service request:\n') + url)
            return

        self.url = url
        if self.home is None:
            self.home = self.url
        if add:
            self.addHistory(self.url, position=position)

        # print self.history.index, self.history.list
        if self.history.index > 1:
            self.backButton.set_sensitive(True)
        else:
            self.backButton.set_sensitive(False)
        if self.history.index < len(self.history.list):
            self.forwardButton.set_sensitive(True)
        else:
            self.forwardButton.set_sensitive(False)

        start, end = self.textbuffer.get_bounds()
        self.textbuffer.delete(start, end)

        writer = tkHTMLWriter(self.textbuffer, self, self.app)
        fmt = pysollib.formatter.AbstractFormatter(writer)
        parser = tkHTMLParser(fmt)
        parser.feed(data)
        parser.close()

        self.set_position(position)

        self.parent.set_title(parser.title)
Ejemplo n.º 33
0
 def errorDialog(self, msg):
     MfxMessageDialog(
         self.parent, title=TITLE+' HTML Problem',
         text=msg, bitmap='warning',
         strings=(_('&OK'),), default=0)
Ejemplo n.º 34
0
 def __init__(self, parent, title, app, manager, key=None, **kw):
     kw = self.initKw(kw)
     MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
     top_frame, bottom_frame = self.createFrames(kw)
     self.createBitmaps(top_frame, kw)
     #
     if key is None:
         key = manager.getSelected()
     self.manager = manager
     self.key = key
     self.app = app
     self.cardset_values = None
     # padx, pady = kw.padx, kw.pady
     padx, pady = 5, 5
     if self.TreeDataHolder_Class.data is None:
         self.TreeDataHolder_Class.data = self.TreeData_Class(manager, key)
     #
     self.top.wm_minsize(400, 200)
     if self.top.winfo_screenwidth() >= 800:
         w1, w2 = 240, 400
     else:
         w1, w2 = 200, 300
     paned_window = ttk.PanedWindow(top_frame, orient='horizontal')
     paned_window.pack(expand=True, fill='both')
     left_frame = ttk.Frame(paned_window)
     right_frame = ttk.Frame(paned_window)
     paned_window.add(left_frame)
     paned_window.add(right_frame)
     font = app.getFont("default")
     self.tree = self.Tree_Class(self,
                                 left_frame,
                                 key=key,
                                 default=kw.default,
                                 font=font,
                                 width=w1)
     self.tree.frame.grid(row=0,
                          column=0,
                          sticky='nsew',
                          padx=padx,
                          pady=pady)
     if USE_PIL:
         #
         var = tkinter.DoubleVar()
         var.set(app.opt.scale_x)
         self.scale_x = PysolScale(left_frame,
                                   label=_('Scale X:'),
                                   from_=0.5,
                                   to=4.0,
                                   resolution=0.1,
                                   orient='horizontal',
                                   variable=var,
                                   value=app.opt.scale_x,
                                   command=self._updateScale)
         self.scale_x.grid(row=1,
                           column=0,
                           sticky='ew',
                           padx=padx,
                           pady=pady)
         #
         var = tkinter.DoubleVar()
         var.set(app.opt.scale_y)
         self.scale_y = PysolScale(left_frame,
                                   label=_('Scale Y:'),
                                   from_=0.5,
                                   to=4.0,
                                   resolution=0.1,
                                   orient='horizontal',
                                   variable=var,
                                   value=app.opt.scale_y,
                                   command=self._updateScale)
         self.scale_y.grid(row=2,
                           column=0,
                           sticky='ew',
                           padx=padx,
                           pady=pady)
         #
         self.auto_scale = tkinter.BooleanVar()
         self.auto_scale.set(app.opt.auto_scale)
         check = ttk.Checkbutton(left_frame,
                                 text=_('Auto scaling'),
                                 variable=self.auto_scale,
                                 takefocus=False,
                                 command=self._updateAutoScale)
         check.grid(row=3,
                    column=0,
                    columnspan=2,
                    sticky='ew',
                    padx=padx,
                    pady=pady)
         #
         self.preserve_aspect = tkinter.BooleanVar()
         self.preserve_aspect.set(app.opt.preserve_aspect_ratio)
         self.aspect_check = ttk.Checkbutton(
             left_frame,
             text=_('Preserve aspect ratio'),
             variable=self.preserve_aspect,
             takefocus=False,
             # command=self._updateScale
         )
         self.aspect_check.grid(row=4,
                                column=0,
                                sticky='ew',
                                padx=padx,
                                pady=pady)
         self._updateAutoScale()
     #
     left_frame.rowconfigure(0, weight=1)
     left_frame.columnconfigure(0, weight=1)
     #
     self.preview = MfxScrolledCanvas(right_frame, width=w2)
     self.preview.setTile(app, app.tabletile_index, force=True)
     self.preview.pack(fill='both', expand=True, padx=padx, pady=pady)
     self.preview.canvas.preview = 1
     # create a preview of the current state
     self.preview_key = -1
     self.preview_images = []
     self.scale_images = []
     self.updatePreview(key)
     #
     focus = self.createButtons(bottom_frame, kw)
     focus = self.tree.frame
     self.mainloop(focus, kw.timeout)
Ejemplo n.º 35
0
    def __init__(self, parent, title, cardset, images, **kw):
        kw = self.initKw(kw)
        MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
        top_frame, bottom_frame = self.createFrames(kw)
        self.createBitmaps(top_frame, kw)
        frame = ttk.Frame(top_frame)
        frame.pack(fill="both", expand=True, padx=5, pady=10)
        #
        #
        row = 0
        info_frame = ttk.LabelFrame(frame, text=_('About cardset'))
        info_frame.grid(row=row,
                        column=0,
                        columnspan=2,
                        sticky='ew',
                        padx=0,
                        pady=5,
                        ipadx=5,
                        ipady=5)
        row += 1
        styles = nationalities = year = None
        if cardset.si.styles:
            styles = '\n'.join([CSI.STYLE[i] for i in cardset.si.styles])
        if cardset.si.nationalities:
            nationalities = '\n'.join(
                [CSI.NATIONALITY[i] for i in cardset.si.nationalities])
        if cardset.year:
            year = str(cardset.year)
        frow = 0
        for n, t in (
                # ('Version:', str(cardset.version)),
            (_('Type:'), CSI.TYPE[cardset.type]),
            (_('Styles:'), styles),
            (_('Nationality:'), nationalities),
            (_('Year:'), year),
                # (_('Number of cards:'), str(cardset.ncards)),
            (_('Size:'), '%d x %d' % (cardset.CARDW, cardset.CARDH)),
        ):
            if t is not None:
                label = ttk.Label(info_frame,
                                  text=n,
                                  anchor='w',
                                  justify='left')
                label.grid(row=frow, column=0, sticky='nw', padx=4)
                label = ttk.Label(info_frame,
                                  text=t,
                                  anchor='w',
                                  justify='left')
                label.grid(row=frow, column=1, sticky='nw', padx=4)
                frow += 1
        if images:
            try:
                from random import choice
                im = choice(images)
                f = os.path.join(cardset.dir, cardset.backname)
                self.back_image = loadImage(file=f)  # store the image
                label = ttk.Label(info_frame, image=im, padding=5)
                label.grid(row=0, column=2, rowspan=frow + 1, sticky='ne')
                label = ttk.Label(info_frame,
                                  image=self.back_image,
                                  padding=(0, 5, 5, 5))  # left margin = 0
                label.grid(row=0, column=3, rowspan=frow + 1, sticky='ne')

                info_frame.columnconfigure(2, weight=1)
                info_frame.rowconfigure(frow, weight=1)
            except Exception:
                pass
        if USE_PIL:
            padx = 4
            pady = 0
            settings_frame = ttk.LabelFrame(frame, text=_('Settings'))
            settings_frame.grid(row=row,
                                column=0,
                                columnspan=2,
                                sticky='ew',
                                padx=0,
                                pady=5,
                                ipadx=5,
                                ipady=5)
            row += 1
            var = tkinter.IntVar()
            self.x_offset = PysolScale(
                settings_frame,
                label=_('X offset:'),
                from_=5,
                to=40,
                resolution=1,
                orient='horizontal',
                variable=var,
                value=cardset.CARD_XOFFSET,
                # command=self._updateScale
            )
            self.x_offset.grid(row=0,
                               column=0,
                               sticky='ew',
                               padx=padx,
                               pady=pady)
            var = tkinter.IntVar()
            self.y_offset = PysolScale(
                settings_frame,
                label=_('Y offset:'),
                from_=5,
                to=40,
                resolution=1,
                orient='horizontal',
                variable=var,
                value=cardset.CARD_YOFFSET,
                # command=self._updateScale
            )
            self.y_offset.grid(row=1,
                               column=0,
                               sticky='ew',
                               padx=padx,
                               pady=pady)
            row += 1

        # bg = top_frame["bg"]
        bg = 'white'
        text_w = tkinter.Text(frame,
                              bd=1,
                              relief="sunken",
                              wrap="word",
                              padx=4,
                              width=64,
                              height=16,
                              bg=bg)
        text_w.grid(row=row, column=0, sticky='nsew')
        sb = ttk.Scrollbar(frame)
        sb.grid(row=row, column=1, sticky='ns')
        text_w.configure(yscrollcommand=sb.set)
        sb.configure(command=text_w.yview)
        frame.columnconfigure(0, weight=1)
        frame.rowconfigure(1, weight=1)
        #
        text = ''
        f = os.path.join(cardset.dir, "COPYRIGHT")
        try:
            text = open(f).read()
        except Exception:
            pass
        if text:
            text_w.config(state="normal")
            text_w.insert("insert", text)
        text_w.config(state="disabled")
        #
        focus = self.createButtons(bottom_frame, kw)
        # focus = text_w
        self.mainloop(focus, kw.timeout)
Ejemplo n.º 36
0
 def __init__(self, manager, key):
     SelectDialogTreeData.__init__(self)
     self.all_objects = manager.getAllSortedByName()
     self.all_objects = [obj for obj in self.all_objects if not obj.error]
     self.no_contents = [
         SelectCardsetLeaf(None, None, _("(no cardsets)"), key=None),
     ]
     #
     select_by_type = None
     items = list(CSI.TYPE.items())
     items.sort(key=lambda x: x[1])
     nodes = []
     for key, name in items:
         if manager.registered_types.get(key):
             nodes.append(
                 SelectCardsetNode(None,
                                   name,
                                   lambda cs, key=key: key == cs.si.type))
     if nodes:
         select_by_type = SelectCardsetNode(None,
                                            _("by Type"),
                                            tuple(nodes),
                                            expanded=1)
     #
     select_by_style = None
     items = list(CSI.STYLE.items())
     items.sort(key=lambda x: x[1])
     nodes = []
     for key, name in items:
         if manager.registered_styles.get(key):
             nodes.append(
                 SelectCardsetNode(None,
                                   name,
                                   lambda cs, key=key: key in cs.si.styles))
     if nodes:
         nodes.append(
             SelectCardsetNode(None, _("Uncategorized"),
                               lambda cs: not cs.si.styles))
         select_by_style = SelectCardsetNode(None, _("by Style"),
                                             tuple(nodes))
     #
     select_by_nationality = None
     items = list(CSI.NATIONALITY.items())
     items.sort(key=lambda x: x[1])
     nodes = []
     for key, name in items:
         if manager.registered_nationalities.get(key):
             nodes.append(
                 SelectCardsetNode(
                     None,
                     name,
                     lambda cs, key=key: key in cs.si.nationalities))
     if nodes:
         nodes.append(
             SelectCardsetNode(None, _("Uncategorized"),
                               lambda cs: not cs.si.nationalities))
         select_by_nationality = SelectCardsetNode(None,
                                                   _("by Nationality"),
                                                   tuple(nodes))
     #
     select_by_date = None
     items = list(CSI.DATE.items())
     items.sort(key=lambda x: x[1])
     nodes = []
     for key, name in items:
         if manager.registered_dates.get(key):
             nodes.append(
                 SelectCardsetNode(None,
                                   name,
                                   lambda cs, key=key: key in cs.si.dates))
     if nodes:
         nodes.append(
             SelectCardsetNode(None, _("Uncategorized"),
                               lambda cs: not cs.si.dates))
         select_by_date = SelectCardsetNode(None, _("by Date"),
                                            tuple(nodes))
     #
     self.rootnodes = [
         _f for _f in (
             SelectCardsetNode(None,
                               _("All Cardsets"),
                               lambda cs: 1,
                               expanded=len(self.all_objects) <= 12),
             SelectCardsetNode(None,
                               _("by Size"), (
                                   SelectCardsetNode(
                                       None, _("Tiny cardsets"), lambda cs:
                                       cs.si.size == CSI.SIZE_TINY),
                                   SelectCardsetNode(
                                       None, _("Small cardsets"), lambda cs:
                                       cs.si.size == CSI.SIZE_SMALL),
                                   SelectCardsetNode(
                                       None, _("Medium cardsets"), lambda
                                       cs: cs.si.size == CSI.SIZE_MEDIUM),
                                   SelectCardsetNode(
                                       None, _("Large cardsets"), lambda cs:
                                       cs.si.size == CSI.SIZE_LARGE),
                                   SelectCardsetNode(
                                       None, _("XLarge cardsets"), lambda
                                       cs: cs.si.size == CSI.SIZE_XLARGE),
                               ),
                               expanded=1),
             select_by_type,
             select_by_style,
             select_by_date,
             select_by_nationality,
         ) if _f
     ]
Ejemplo n.º 37
0
 def mPlayerStats(self, *args, **kw):
     wasPaused = False
     if not self.game.pause:
         self.game.doPause()
         wasPaused = True
     mode = kw.get("mode", 101)
     demo = 0
     gameid = None
     while mode > 0:
         if mode > 1000:
             demo = not demo
             mode = mode % 1000
         #
         d = Struct(status=-1, button=-1)
         if demo:
             player = None
         else:
             player = self.app.opt.player
         n = self.game.gameinfo.name
         # translation keywords
         transkw = {'app': TITLE,
                    'player': player,
                    'game': n,
                    'tops': TOP_SIZE}
         #
         if mode == 100:
             d = Status_StatsDialog(self.top, game=self.game)
         elif mode == 101:
             header = (_("%(app)s Demo Statistics for %(game)s") if demo
                       else _("Statistics for %(game)s")) % transkw
             d = SingleGame_StatsDialog(
                self.top, header, self.app, player, gameid=self.game.id)
             gameid = d.selected_game
         elif mode == 102:
             header = (_("%(app)s Demo Statistics") if demo
                       else _("Statistics for %(player)s")) % transkw
             d = AllGames_StatsDialog(self.top, header, self.app, player)
             gameid = d.selected_game
         elif mode == 103:
             header = (_("%(app)s Demo Full log") if demo
                       else _("Full log for %(player)s")) % transkw
             d = FullLog_StatsDialog(self.top, header, self.app, player)
         elif mode == 104:
             header = (_("%(app)s Demo Session log") if demo
                       else _("Session log for %(player)s")) % transkw
             d = SessionLog_StatsDialog(self.top, header, self.app, player)
         elif mode == 105:
             # TRANSLATORS: eg. top 10 or top 5 results for a certain game
             header = (_("%(app)s Demo Top %(tops)d for %(game)s") if demo
                       else _("Top %(tops)d for %(game)s")) % transkw
             d = Top_StatsDialog(
                 self.top, header, self.app, player, gameid=self.game.id)
         elif mode == 106:
             header = _("Game Info")
             d = GameInfoDialog(self.top, header, self.app)
         elif mode == 107:
             header = _("Statistics progression")
             d = ProgressionDialog(
                 self.top, header, self.app, player, gameid=self.game.id)
         elif mode == 202:
             # print stats to file
             write_method = FileStatsFormatter.writeStats
             self._mStatsSave(player, "stats", write_method)
         elif mode == 203:
             # print full log to file
             write_method = FileStatsFormatter.writeFullLog
             self._mStatsSave(player, "log", write_method)
         elif mode == 204:
             # print session log to file
             write_method = FileStatsFormatter.writeSessionLog
             self._mStatsSave(player, "log", write_method)
         elif mode == 301:
             # reset all player stats
             if self.game.areYouSure(
                 _("Reset all statistics"),
                 _("Reset ALL statistics and logs for player\n" +
                   "%(player)s?") % transkw,
                 confirm=1, default=1
             ):
                 self.app.stats.resetStats(player, 0)
                 self.game.updateStatus(stats=self.app.stats.getStats(
                     self.app.opt.player, self.game.id))
         elif mode == 302:
             # reset player stats for current game
             if self.game.areYouSure(
                 _("Reset game statistics"),
                 _('Reset statistics and logs for player\n%(player)s\n'
                   'and game\n%(game)s?') % transkw,
                 confirm=1, default=1
             ):
                 self.app.stats.resetStats(player, self.game.id)
                 self.game.updateStatus(stats=self.app.stats.getStats(
                     self.app.opt.player, self.game.id))
         elif mode == 401:
             # start a new game with a gameid
             if gameid and gameid != self.game.id:
                 self.game.endGame()
                 self.game.quitGame(gameid)
         elif mode == 402:
             # start a new game with a gameid / gamenumber
             # TODO
             pass
         else:
             print_err("stats problem: %s %s %s" % (mode, demo, player))
             pass
         if d.status != 0:
             break
         mode = d.button
     if self.game.pause:
         if wasPaused:
             self.game.doPause()
Ejemplo n.º 38
0
                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


WizardPresets = WizSetting(
    values_map=list(presets.keys()),
    default='None',
    widget='preset',
    label=_('Initial setting:'),
    var_name='preset',
)
GameName = WizSetting(
    values_map=(),
    default=_('My Game'),
    widget='entry',
    label=_('Name:'),
    var_name='name',
)
SkillLevel = WizSetting(
    values_map=(
        (n_('Luck only'), GI.SL_LUCK),
        (n_('Mostly luck'), GI.SL_MOSTLY_LUCK),
        (n_('Balanced'), GI.SL_BALANCED),
        (n_('Mostly skill'), GI.SL_MOSTLY_SKILL),
Ejemplo n.º 39
0
    def __init__(self, parent, title, app, gameid, bookmark=None, **kw):
        kw = self.initKw(kw)
        MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
        top_frame, bottom_frame = self.createFrames(kw)

        self.createBitmaps(top_frame, kw)
        #
        self.app = app
        self.gameid = gameid
        self.bookmark = bookmark
        self.random = None
        if self.TreeDataHolder_Class.data is None:
            self.TreeDataHolder_Class.data = self.TreeData_Class(app)
        #
        sw = self.top.winfo_screenwidth()
        sh = self.top.winfo_screenheight()

        h = int(sh * .8)
        w = int(sw * .8)
        w1 = int(min(275, sw / 2.5))
        geometry = ("%dx%d+%d+%d" % (w, h, (sw - w) / 2, (sh - h) / 2))
        self.top.wm_minsize(400, 200)

        # print sw, w1, w2
        # w2 = max(200, min(w2, 10 + 12 * (app.subsampled_images.CARDW + 10)))
        # print sw, w1, w2
        # padx, pady = kw.padx, kw.pady
        # padx, pady = kw.padx/2, kw.pady/2
        padx, pady = 4, 4
        # PanedWindow
        paned_window = ttk.PanedWindow(top_frame, orient='horizontal')
        paned_window.pack(expand=True, fill='both', padx=8, pady=8)
        left_frame = ttk.Frame(paned_window)
        right_frame = ttk.Frame(paned_window)
        paned_window.add(left_frame)
        paned_window.add(right_frame)

        notebook = ttk.Notebook(left_frame)
        notebook.pack(expand=True, fill='both')
        tree_frame = ttk.Frame(notebook)
        notebook.add(tree_frame, text=_('Tree View'))
        search_frame = ttk.Frame(notebook)
        notebook.add(search_frame, text=_('Search'))

        # Tree
        font = app.getFont("default")
        self.tree = self.Tree_Class(self,
                                    tree_frame,
                                    key=gameid,
                                    default=kw.default,
                                    font=font,
                                    width=w1)
        self.tree.frame.pack(padx=padx, pady=pady, expand=True, fill='both')

        # Search
        searchText = tkinter.StringVar()
        self.list_searchlabel = tkinter.Label(search_frame,
                                              text="Search:",
                                              justify='left',
                                              anchor='w')
        self.list_searchlabel.pack(side="top", fill='both', ipadx=1)
        self.list_searchtext = tkinter.Entry(search_frame,
                                             textvariable=searchText)
        self.list_searchtext.pack(side="top",
                                  fill='both',
                                  padx=padx,
                                  pady=pady,
                                  ipadx=1)
        searchText.trace('w', self.performSearch)

        self.list_scrollbar = tkinter.Scrollbar(search_frame)
        self.list_scrollbar.pack(side="right", fill='both')

        self.createBitmaps(search_frame, kw)
        self.list = tkinter.Listbox(search_frame, exportselection=False)
        self.list.pack(padx=padx,
                       pady=pady,
                       expand=True,
                       side='left',
                       fill='both',
                       ipadx=1)
        self.updateSearchList("")
        bind(self.list, '<<ListboxSelect>>', self.selectSearchResult)
        bind(self.list, '<FocusOut>',
             lambda e: self.list.selection_clear(0, 'end'))

        self.list.config(yscrollcommand=self.list_scrollbar.set)
        self.list_scrollbar.config(command=self.list.yview)

        # LabelFrame
        info_frame = ttk.LabelFrame(right_frame, text=_('About game'))
        info_frame.grid(row=0,
                        column=0,
                        padx=padx,
                        pady=pady,
                        ipadx=4,
                        ipady=4,
                        sticky='nws')
        stats_frame = ttk.LabelFrame(right_frame, text=_('Statistics'))
        stats_frame.grid(row=0,
                         column=1,
                         padx=padx,
                         pady=pady,
                         ipadx=4,
                         ipady=4,
                         sticky='nws')
        # Info
        self.info_labels = {}
        for n, t, f, row in (
            ('name', _('Name:'), info_frame, 0),
            ('altnames', _('Alternate names:'), info_frame, 1),
            ('category', _('Category:'), info_frame, 2),
            ('type', _('Type:'), info_frame, 3),
            ('skill_level', _('Skill level:'), info_frame, 4),
            ('decks', _('Decks:'), info_frame, 5),
            ('redeals', _('Redeals:'), info_frame, 6),
                #
            ('played', _('Played:'), stats_frame, 0),
            ('won', _('Won:'), stats_frame, 1),
            ('lost', _('Lost:'), stats_frame, 2),
            ('time', _('Playing time:'), stats_frame, 3),
            ('moves', _('Moves:'), stats_frame, 4),
            ('percent', _('% won:'), stats_frame, 5),
        ):
            title_label = ttk.Label(f, text=t, justify='left', anchor='w')
            title_label.grid(row=row, column=0, sticky='nw', padx=4)
            text_label = ttk.Label(f, justify='left', anchor='w')
            text_label.grid(row=row, column=1, sticky='nw', padx=4)
            self.info_labels[n] = (title_label, text_label)
        # info_frame.columnconfigure(1, weight=1)
        info_frame.rowconfigure(6, weight=1)
        stats_frame.rowconfigure(6, weight=1)
        # Canvas
        self.preview = MfxScrolledCanvas(right_frame)
        self.preview.setTile(app, app.tabletile_index, force=True)
        self.preview.grid(row=1,
                          column=0,
                          columnspan=3,
                          padx=padx,
                          pady=pady,
                          sticky='nsew')
        right_frame.columnconfigure(1, weight=1)
        right_frame.rowconfigure(1, weight=1)
        #
        focus = self.createButtons(bottom_frame, kw)
        # set the scale factor
        self.preview.canvas.preview = 2
        # create a preview of the current game
        self.preview_key = -1
        self.preview_game = None
        self.preview_app = None
        self.updatePreview(gameid, animations=0)
        # focus = self.tree.frame
        self.mainloop(focus, kw.timeout, geometry=geometry)
Ejemplo n.º 40
0
    def updatePreview(self, gameid, animations=10):
        if gameid == self.preview_key:
            return
        self.deletePreview()
        canvas = self.preview.canvas
        #
        gi = self.app.gdb.get(gameid)
        if not gi:
            self.preview_key = -1
            return
        #
        if self.preview_app is None:
            self.preview_app = Struct(
                # variables
                audio=self.app.audio,
                canvas=canvas,
                cardset=self.app.cardset.copy(),
                gamerandom=self.app.gamerandom,
                gdb=self.app.gdb,
                gimages=self.app.gimages,
                images=None,
                menubar=None,
                miscrandom=self.app.miscrandom,
                opt=self.app.opt.copy(),
                startup_opt=self.app.startup_opt,
                stats=self.app.stats.new(),
                top=None,
                top_cursor=self.app.top_cursor,
                toolbar=None,
                # methods
                constructGame=self.app.constructGame,
                getFont=self.app.getFont,
            )
            self.preview_app.opt.shadow = 0
            self.preview_app.opt.shade = 0
        #

        c = self.app.cardsets_cache.get(gi.category)
        if not c:
            cardset = self.app.cardset_manager.getByName(
                self.app.opt.cardset[gi.category][0])
            self.app.loadCardset(cardset,
                                 id=gi.category,
                                 tocache=True,
                                 noprogress=True)
            c = self.app.cardsets_cache.get(gi.category)
        if c:
            self.preview_app.images = c[2]
        else:
            self.preview_app.images = self.app.subsampled_images

        self.preview_app.audio = None  # turn off audio for initial dealing
        if animations >= 0:
            self.preview_app.opt.animations = animations
        #
        if self.preview_game:
            self.preview_game.endGame()
            self.preview_game.destruct()
        # self.top.wm_title("Select Game - " +
        #   self.app.getGameTitleName(gameid))
        title = self.app.getGameTitleName(gameid)
        self.top.wm_title(_("Select Game - %(game)s") % {'game': title})
        #
        self.preview_game = gi.gameclass(gi)
        self.preview_game.createPreview(self.preview_app)
        #
        random = None
        if gameid == self.gameid:
            random = self.app.game.random.copy()
        if gameid == self.gameid and self.bookmark:
            self.preview_game.restoreGameFromBookmark(self.bookmark)
        else:
            self.preview_game.newGame(random=random, autoplay=1)
        gw, gh = self.preview_game.width, self.preview_game.height
        canvas.config(scrollregion=(0, 0, gw, gh))
        canvas.xview_moveto(0)
        canvas.yview_moveto(0)
        #
        self.preview_app.audio = self.app.audio
        if self.app.opt.animations:
            self.preview_app.opt.animations = 10
        else:
            self.preview_app.opt.animations = 0
        # save seed
        self.random = self.preview_game.random.copy()
        self.random.origin = self.random.ORIGIN_PREVIEW
        self.preview_key = gameid
        #
        self.updateInfo(gameid)
        #
        rules_button = self.buttons[0]
        if self.app.getGameRulesFilename(gameid):
            rules_button.config(state="normal")
        else:
            rules_button.config(state="disabled")
Ejemplo n.º 41
0
    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 = {}
        self.anchor_tags = {}

        # create buttons
        vbox = gtk.VBox()
        parent.table.attach(
            vbox,
            0, 1,                   0, 1,
            gtk.EXPAND | gtk.FILL,  gtk.EXPAND | gtk.FILL | gtk.SHRINK,
            0,                      0)

        buttons_box = gtk.HBox()
        vbox.pack_start(buttons_box, fill=True, expand=False)
        for name, label, callback in (
            ('homeButton',    _('Index'),   self.goHome),
            ('backButton',    _('Back'),    self.goBack),
            ('forwardButton', _('Forward'), self.goForward),
            ('closeButton',   _('Close'),   self.destroy)
                ):
            button = gtk.Button(label)
            button.show()
            button.connect('clicked', callback)
            buttons_box.pack_start(button, fill=True, expand=False)
            button.set_property('can-focus', False)
            setattr(self, name, button)

        # create text widget
        self.textview = gtk.TextView()
        self.textview.show()
        self.textview.set_left_margin(10)
        self.textview.set_right_margin(10)
        self.textview.set_cursor_visible(False)
        self.textview.set_editable(False)
        self.textview.set_wrap_mode(gtk.WRAP_WORD)
        self.textbuffer = self.textview.get_buffer()

        sw = gtk.ScrolledWindow()
        sw.set_property('hscrollbar-policy', gtk.POLICY_AUTOMATIC)
        sw.set_property('vscrollbar-policy', gtk.POLICY_AUTOMATIC)
        sw.set_property('border-width', 0)
        sw.add(self.textview)
        sw.show()
        vbox.pack_start(sw, fill=True, expand=True)
        self.vadjustment = sw.get_vadjustment()
        self.hadjustment = sw.get_hadjustment()

        # statusbar
        self.statusbar = gtk.Statusbar()
        self.statusbar.show()
        vbox.pack_start(self.statusbar, fill=True, expand=False)

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

        # bindings
        parent.connect('key-press-event', self.key_press_event)
        parent.connect('destroy', self.destroy)
        self.textview.connect('motion-notify-event', self.motion_notify_event)
        self.textview.connect('leave-notify-event', self.leave_event)
        self.textview.connect('enter-notify-event', self.motion_notify_event)

        self._changed_cursor = False

        self.createFontMap()

        # cursor
        self.defcursor = gdk.XTERM
        self.handcursor = gdk.HAND2
        # self.textview.realize()
        # window = self.textview.get_window(gtk.TEXT_WINDOW_TEXT)
        # window.set_cursor(gdk.Cursor(self.defcursor))

        parent.set_default_size(600, 440)
        parent.show_all()
        gobject.idle_add(gtk.main)
Ejemplo n.º 42
0
 def getLogHeader(self):
     return _("Game"), _("Game number"), _("Started at"), _("Status")
Ejemplo n.º 43
0
 def getStatHeader(self):
     return (_("Game"), _("Played"), _("Won"), _("Lost"), _('Playing time'),
             _('Moves'), _("% won"))