Esempio n. 1
0
 def __init__(self):
     Struct.__init__(
         self,
         # line[0]
         version=1,
         ext=".gif",
         type=CSI.TYPE_FRENCH,
         ncards=-1,
         styles=[],
         year=0,
         # line[1]
         ident="",
         name="",
         # line[2]
         CARDW=0,
         CARDH=0,
         CARDD=0,
         # line[3]
         CARD_XOFFSET=0,
         CARD_YOFFSET=0,
         SHADOW_XOFFSET=0,
         SHADOW_YOFFSET=0,
         # line[4]
         backindex=0,
         # line[5]
         backnames=(),
         # other
         CARD_DX=0,  # relative pos of real card image within Card
         CARD_DY=0,
     )
Esempio n. 2
0
 def __init__(self):
     Struct.__init__(
         self,
         # line[0]
         version=1,
         ext=".gif",
         type=CSI.TYPE_FRENCH,
         ncards=-1,
         styles=[],
         year=0,
         # line[1]
         ident="",
         name="",
         # line[2]
         CARDW=0,
         CARDH=0,
         CARDD=0,
         # line[3]
         CARD_XOFFSET=0,
         CARD_YOFFSET=0,
         SHADOW_XOFFSET=0,
         SHADOW_YOFFSET=0,
         # line[4]
         backindex=0,
         # line[5]
         backnames=(),
         # other
         CARD_DX=0,        # relative pos of real card image within Card
         CARD_DY=0,
     )
Esempio n. 3
0
 def update(self, gameid, value, game_number, game_start_time):
     # update min & max
     if not self.min or value < self.min:
         self.min = value
     if not self.max or value > self.max:
         self.max = value
     # calculate position & update top
     position = None
     n = 0
     for i in self.top:
         if value < i.value:
             position = n + 1
             v = Struct(gameid=gameid,
                        value=value,
                        game_number=game_number,
                        game_start_time=game_start_time)
             self.top.insert(n, v)
             del self.top[TOP_SIZE:]
             break
         n += 1
     if not position and len(self.top) < TOP_SIZE:
         v = Struct(gameid=gameid,
                    value=value,
                    game_number=game_number,
                    game_start_time=game_start_time)
         self.top.append(v)
         position = len(self.top)
     # update average
     self.total += value
     self.num += 1
     self.average = float(self.total) / self.num
     return position
Esempio n. 4
0
def playeroptionsdialog_main(args):
    from pysollib.ui.tktile.tkutil import wm_withdraw
    opt = Struct(player="Test", update_player_stats=1)
    app = Struct(opt=opt)
    tk = tkinter.Tk()
    wm_withdraw(tk)
    tk.update()
    d = PlayerOptionsDialog(tk, "Player options", app)
    print(d.status, d.button, ":", d.player, d.update_stats)
    return 0
Esempio n. 5
0
 def __init__(self, **kw):
     kw = KwStruct(kw,
         name = "",
         filename = "",
         basename = "",      # basename of filename
         absname = "",       # absolute filename
         # implicit
         index = -1,
         error = 0,          # error while loading this resource
     )
     Struct.__init__(self, **kw.getKw())
Esempio n. 6
0
 def __init__(self, **kw):
     kw = KwStruct(
         kw,
         name="",
         filename="",
         basename="",  # basename of filename
         absname="",  # absolute filename
         # implicit
         index=-1,
         error=0,  # error while loading this resource
     )
     Struct.__init__(self, **kw.getKw())
Esempio n. 7
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()
Esempio n. 8
0
 def __init__(self, app, top, progress=None):
     self.app = app
     self.top = top
     self.game = None
     # enabled/disabled - this is set by updateMenuState()
     self.menustate = Struct(
         save=0,
         save_as=0,
         hold_and_quit=0,
         undo=0,
         redo=0,
         restart=0,
         deal=0,
         hint=0,
         autofaceup=0,
         autodrop=0,
         shuffle=0,
         autodeal=0,
         quickplay=0,
         demo=0,
         highlight_piles=0,
         find_card=0,
         rules=0,
         pause=0,
         custom_game=0,
     )
     PysolMenubarTk.__init__(self, app, top, progress)
Esempio n. 9
0
    def __init__(self, game, card_x_space=None, card_y_space=None, **kw):
        self.game = game
        self.canvas = self.game.canvas
        self.size = None
        self.s = Struct(
            talon=None,
            waste=None,
            foundations=[],
            rows=[],
            reserves=[],
        )
        self.stackmap = {}
        self.regions = []
        # set visual constants
        images = self.game.app.images

        layout_x_margin = images.CARDW // 9
        layout_y_margin = layout_x_margin
        layout_card_x_space = images.CARDW // 9
        layout_card_y_space = images.CARDH // 8

        self.CW = images.CARDW
        self.CH = images.CARDH
        self.XOFFSET = images.CARD_XOFFSET
        self.YOFFSET = images.CARD_YOFFSET
        self.XM = layout_x_margin  # XMARGIN
        self.YM = layout_y_margin  # YMARGIN

        if card_x_space is None:
            self.XS = self.CW + layout_card_x_space  # XSPACE
        else:
            self.XS = self.CW + card_x_space
        if card_y_space is None:
            self.YS = self.CH + layout_card_y_space  # YSPACE
        else:
            self.YS = self.CH + card_y_space

        # self.CARD_X_SPACE = layout_card_x_space
        # self.CARD_Y_SPACE = layout_card_y_space
        # self.RIGHT_MARGIN = layout_x_margin-layout_card_x_space
        # self.BOTTOM_MARGIN = layout_y_margin-layout_card_y_space

        font = game.app.getFont("canvas_default")
        # self.TEXT_MARGIN = 10
        self.TEXT_MARGIN = font[1]
        # self.TEXT_HEIGHT = 30
        self.TEXT_HEIGHT = 18 + font[1]

        self.__dict__.update(kw)
        if self.game.preview > 1:
            if "XOFFSET" in kw:
                self.XOFFSET //= self.game.preview
            if "YOFFSET" in kw:
                self.YOFFSET //= self.game.preview
            self.TEXT_HEIGHT = 10
Esempio n. 10
0
 def __init__(self, **kw):
     # start with all fields from CardsetConfig
     config = CardsetConfig()
     kw = KwStruct(config.__dict__, **kw)
     # si is the SelectionInfo struct that will be queried by
     # the "select cardset" dialogs. It can be freely modified.
     si = Struct(type=0, size=0, styles=[], nationalities=[], dates=[])
     kw = KwStruct(
         kw,
         # essentials
         ranks=(),
         suits=(),
         trumps=(),
         nbottoms=7,
         nletters=4,
         nshadows=1 + 13,
         # selection criteria
         si=si,
         # implicit
         backname=None,
         dir="",
     )
     Resource.__init__(self, **kw.getKw())
Esempio n. 11
0
 def __init__(self):
     self.gdb = GAME_DB
     self.opt = Options()
     self.startup_opt = self.opt.copy()
     self.stats = Statistics()
     self.splashscreen = 1
     # visual components
     self.top = None  # the root toplevel window
     self.top_bg = None  # default background
     self.top_cursor = None  # default cursor
     self.menubar = None
     self.toolbar = None
     self.canvas = None  # MfxCanvas
     self.scrolled_canvas = None  # MfxScrolledCanvas
     self.statusbar = None
     #
     self.game = None
     self.dataloader = None
     self.audio = None
     self.images = None
     self.subsampled_images = None
     self.gimages = Struct(  # global images
         demo=[],  # demo logos
         pause=[],  # pause logos
         logos=[],
         redeal=[],
     )
     # self.progress_bg = None
     self.progress_images = []
     self.cardset_manager = CardsetManager()
     self.cardset = None  # current cardset
     self.cardsets_cache = {}
     self.tabletile_manager = TileManager()
     self.tabletile_index = 0  # current table tile
     self.sample_manager = SampleManager()
     self.music_manager = MusicManager()
     self.music_playlist = []
     self.intro = Struct(
         progress=None,  # progress bar
     )
     # directory names
     config = os.path.normpath(getprefdir(PACKAGE))
     self.dn = Struct(
         config=config,
         plugins=os.path.join(config, "plugins"),
         savegames=os.path.join(config, "savegames"),
         maint=os.path.join(config, "maint"),  # debug
     )
     for k, v in self.dn.__dict__.items():
         #             if os.name == "nt":
         #                 v = os.path.normcase(v)
         v = os.path.normpath(v)
         self.dn.__dict__[k] = v
     # file names
     self.fn = Struct(
         opt=os.path.join(self.dn.config, "options.dat"),
         opt_cfg=os.path.join(self.dn.config, "options.cfg"),
         stats=os.path.join(self.dn.config, "statistics.dat"),
         holdgame=os.path.join(self.dn.config, "holdgame.dat"),
         comments=os.path.join(self.dn.config, "comments.dat"),
     )
     for k, v in self.dn.__dict__.items():
         if os.name == "nt":
             v = os.path.normcase(v)
         v = os.path.normpath(v)
         self.fn.__dict__[k] = v
     # random generators
     self.gamerandom = PysolRandom()
     self.miscrandom = PysolRandom()
     # player
     player = getusername()
     if not player:
         player = "unknown"
     player = player[:30]
     self.opt.player = player
     # misc
     self.nextgame = Struct(
         id=0,  # start this game
         random=None,  # use this random generator
         loadedgame=None,  # data for loaded game
         startdemo=0,  # start demo ?
         cardset=None,  # use this cardset
         holdgame=0,  # hold this game on exit ?
         bookmark=None,  # goto this bookmark (load new cardset)
     )
     self.commandline = Struct(
         loadgame=None,  # load a game ?
         game=None,
         gameid=None,
         deal=None,
     )
     self.demo_counter = 0
Esempio n. 12
0
    def __init__(self, game, card_x_space=None, card_y_space=None, **kw):
        self.game = game
        self.canvas = self.game.canvas
        self.size = None
        self.s = Struct(
            talon=None,
            waste=None,
            foundations=[],
            rows=[],
            reserves=[],
        )
        self.stackmap = {}
        self.regions = []
        # set visual constants
        images = self.game.app.images
        cardset_size = images.cs.si.size
        if cardset_size in (CSI.SIZE_TINY, CSI.SIZE_SMALL):
            layout_x_margin = 6
            layout_y_margin = 6
            layout_card_x_space = 6
            layout_card_y_space = 10
        elif cardset_size in (CSI.SIZE_MEDIUM, ):
            layout_x_margin = 8
            layout_y_margin = 8
            layout_card_x_space = 8
            layout_card_y_space = 12
        else:  # CSI.SIZE_LARGE, CSI.SIZE_XLARGE
            layout_x_margin = 10
            layout_y_margin = 10
            layout_card_x_space = 10
            layout_card_y_space = 14

        self.CW = images.CARDW
        self.CH = images.CARDH
        self.XOFFSET = images.CARD_XOFFSET
        self.YOFFSET = images.CARD_YOFFSET
        self.XM = layout_x_margin  # XMARGIN
        self.YM = layout_y_margin  # YMARGIN

        if card_x_space is None:
            self.XS = self.CW + layout_card_x_space  # XSPACE
        else:
            self.XS = self.CW + card_x_space
        if card_y_space is None:
            self.YS = self.CH + layout_card_y_space  # YSPACE
        else:
            self.YS = self.CH + card_y_space

        ##self.CARD_X_SPACE = layout_card_x_space
        ##self.CARD_Y_SPACE = layout_card_y_space
        ##self.RIGHT_MARGIN = layout_x_margin-layout_card_x_space
        ##self.BOTTOM_MARGIN = layout_y_margin-layout_card_y_space

        font = game.app.getFont("canvas_default")
        ##self.TEXT_MARGIN = 10
        self.TEXT_MARGIN = font[1]
        ##self.TEXT_HEIGHT = 30
        self.TEXT_HEIGHT = 18 + font[1]

        self.__dict__.update(kw)
        if self.game.preview > 1:
            if "XOFFSET" in kw:
                self.XOFFSET = self.XOFFSET / self.game.preview
            if "YOFFSET" in kw:
                self.YOFFSET = self.YOFFSET / self.game.preview
            self.TEXT_HEIGHT = 10
Esempio n. 13
0
    def updatePreview(self, gameid, animations=10):
        if gameid == self.preview_key:
            return
        self.deletePreview()
        canvas = self.preview
        #
        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.set_title(_("Select Game - %(game)s") % {'game': title})
        #
        self.preview_game = gi.gameclass(gi)
        self.preview_game.createPreview(self.preview_app)
        # tx, ty = 0, 0
        # gw, gh = self.preview_game.width, self.preview_game.height
        # ~ canvas.config(scrollregion=(-tx, -ty, -tx, -ty))
        # ~ canvas.xview_moveto(0)
        # ~ canvas.yview_moveto(0)
        #
        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)
        # ~ canvas.config(scrollregion=(-tx, -ty, gw, gh))
        #
        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[1]
        if self.app.getGameRulesFilename(gameid):
            rules_button.set_sensitive(True)
        else:
            rules_button.set_sensitive(False)
Esempio n. 14
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 = "default"
        # self.defcursor = parent["cursor"]
        # self.defcursor = 'xterm'
        self.handcursor = "hand2"

        self.title = "Browser"
        self.window = None
        self.running = False

        # prüfen ob noch aktiv.

        if parent.workStack.peek(self.title) is not None:
            parent.popWork(self.title)

        pc = self.make_pop_command(parent, self.title)
        cc = self.make_close_command(parent, self.title)

        # neuen Dialog aufbauen.

        window = LTopLevel(app.top, self.title, size_hint=(1.8, 1.0))
        window.titleline.bind(on_press=cc)
        self.parent.pushWork(self.title, window)
        self.window = window
        self.running = True

        content = BoxLayout(orientation='vertical')
        # buttonline =
        #   BoxLayout(orientation='horizontal', size_hint=(1.0, 0.1))

        # create buttons
        self.homeButton = HTMLButton(text="Index", on_release=self.goHome)
        self.backButton = HTMLButton(text="Back", on_release=self.goBack)
        self.forwardButton = HTMLButton(
            text="Forward", on_release=self.goForward)
        self.closeButton = HTMLButton(text="Close", on_release=self.goHome)

        '''
        buttonline.add_widget(self.homeButton)
        buttonline.add_widget(self.backButton)
        buttonline.add_widget(self.forwardButton)
        buttonline.add_widget(self.closeButton)
        content.add_widget(buttonline)
        '''

        '''
        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

        self.text = HTMLText(
            pop_command=pc, text="hallo", size_hint=(1.0, 1.0))
        self.text.label.bind(on_ref_press=self.refpress)
        content.add_widget(self.text)
        '''
        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
        '''

        self.window.content.add_widget(content)

        # 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)
Esempio n. 15
0
    def __init__(
            self,
            id,
            gameclass,
            name,
            game_type,
            decks,
            redeals,
            skill_level=None,
            # keyword arguments:
            si={},
            category=0,
            short_name=None,
            altnames=(),
            suits=list(range(4)),
            ranks=list(range(13)),
            trumps=(),
            rules_filename=None,
    ):
        #
        def to_unicode(s):
            if isinstance(s, six.text_type):
                return s
            try:
                s = six.text_type(s, 'utf-8')
            except UnicodeDecodeError as err:
                print_err(err)
                s = six.text_type(s, 'utf-8', 'ignore')
            return s

        ncards = decks * (len(suits) * len(ranks) + len(trumps))
        game_flags = game_type & ~1023
        game_type = game_type & 1023
        name = to_unicode(name)
        en_name = name  # for app.getGameRulesFilename
        if pysollib.settings.TRANSLATE_GAME_NAMES:
            name = _(name)
        if not short_name:
            short_name = name
        else:
            short_name = to_unicode(short_name)
            if pysollib.settings.TRANSLATE_GAME_NAMES:
                short_name = _(short_name)
        if isinstance(altnames, six.string_types):
            altnames = (altnames, )
        altnames = [to_unicode(n) for n in altnames]
        if pysollib.settings.TRANSLATE_GAME_NAMES:
            altnames = [_(n) for n in altnames]
        #
        if not (1 <= category <= 9):
            if game_type == GI.GT_HANAFUDA:
                category = GI.GC_HANAFUDA
            elif game_type == GI.GT_TAROCK:
                category = GI.GC_TAROCK
            elif game_type == GI.GT_MAHJONGG:
                category = GI.GC_MAHJONGG
            elif game_type == GI.GT_HEXADECK:
                category = GI.GC_HEXADECK
            elif game_type == GI.GT_MUGHAL_GANJIFA:
                category = GI.GC_MUGHAL_GANJIFA
            elif game_type == GI.GT_NAVAGRAHA_GANJIFA:
                category = GI.GC_NAVAGRAHA_GANJIFA
            elif game_type == GI.GT_DASHAVATARA_GANJIFA:
                category = GI.GC_DASHAVATARA_GANJIFA
            else:
                category = GI.GC_FRENCH
        #
        if not (1 <= id <= 999999):
            raise GameInfoException(name + ": invalid game ID " + str(id))
        if category == GI.GC_MAHJONGG:
            if decks % 4:
                raise GameInfoException(name + ": invalid number of decks " +
                                        str(id))
        else:
            if not (1 <= decks <= 4):
                raise GameInfoException(name + ": invalid number of decks " +
                                        str(id))
        if not name:
            raise GameInfoException(name + ": invalid game name")
        if GI.PROTECTED_GAMES.get(id):
            raise GameInfoException(name + ": protected game ID " + str(id))
        #
        for f, l in ((GI.GT_CHILDREN, GI._CHILDREN_GAMES),
                     (GI.GT_OPEN, GI._OPEN_GAMES), (GI.GT_POPULAR,
                                                    GI._POPULAR_GAMES)):
            if (game_flags & f) and (id not in l):
                l.append(id)
            elif not (game_flags & f) and (id in l):
                game_flags = game_flags | f
        # si is the SelectionInfo struct that will be queried by
        # the "select game" dialogs. It can be freely modified.
        gi_si = Struct(game_type=game_type,
                       game_flags=game_flags,
                       decks=decks,
                       redeals=redeals,
                       ncards=ncards)
        gi_si.update(si)
        #
        Struct.__init__(self,
                        id=id,
                        gameclass=gameclass,
                        name=name,
                        short_name=short_name,
                        altnames=tuple(altnames),
                        en_name=en_name,
                        decks=decks,
                        redeals=redeals,
                        ncards=ncards,
                        category=category,
                        skill_level=skill_level,
                        suits=tuple(suits),
                        ranks=tuple(ranks),
                        trumps=tuple(trumps),
                        si=gi_si,
                        rules_filename=rules_filename)
Esempio n. 16
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)
Esempio n. 17
0
    def createGame(self):
        tiles, max_tl, max_tx, max_ty = self.getTiles()

        # start layout
        l, s = Layout(self), self.s
        show_removed = self.app.opt.mahjongg_show_removed

        # dx, dy = 2, -2
        # dx, dy = 3, -3
        cs = self.app.cardset
        if cs.version >= 6:
            dx = l.XOFFSET
            dy = -l.YOFFSET
            d_x = cs.SHADOW_XOFFSET
            d_y = cs.SHADOW_YOFFSET
            if self.preview:
                # Fixme
                dx, dy, d_x, d_y = dx // 2, dy // 2, d_x // 2, d_y // 2
            self._delta_x, self._delta_y = dx, -dy
        else:
            dx = 3
            dy = -3
            d_x = 0
            d_y = 0
            self._delta_x, self._delta_y = 0, 0
        # print dx, dy, d_x, d_y, cs.version

        font = self.app.getFont("canvas_default")

        # width of self.texts.info
        # ti_width = Font(self.canvas, font).measure(_('Remaining'))
        ti_width = 80

        # set window size
        dxx, dyy = abs(dx) * (max_tl + 1), abs(dy) * (max_tl + 1)
        # foundations dxx dyy
        if self.NCARDS > 144:
            fdxx = abs(dx) * 8
            fdyy = abs(dy) * 8
        else:
            fdxx = abs(dx) * 4
            fdyy = abs(dy) * 4
        cardw, cardh = l.CW - d_x, l.CH - d_y
        if show_removed:
            left_margin = l.XM + 4 * cardw + fdxx + d_x + l.XM
        else:
            left_margin = l.XM
        tableau_width = (max_tx + 2) * cardw // 2 + dxx + d_x
        right_margin = l.XM + ti_width + l.XM
        w = left_margin + tableau_width + right_margin
        h = l.YM + dyy + (max_ty + 2) * cardh // 2 + d_y + l.YM
        if show_removed:
            h = max(h, l.YM + fdyy + cardh * 9 + d_y + l.YM)
        self.setSize(w, h)

        # set game extras
        self.check_dist = l.CW * l.CW + l.CH * l.CH  # see _getClosestStack()

        # sort tiles (for 3D)
        tiles.sort(key=lambda x: (x[0], x[2] - x[1]))

        # create a row stack for each tile and compute the tilemap
        tilemap = {}
        x0 = left_margin
        y0 = l.YM + dyy
        for level, tx, ty in tiles:
            # print level, tx, ty
            x = x0 + (tx * cardw) // 2 + level * dx
            y = y0 + (ty * cardh) // 2 + level * dy
            stack = self.RowStack_Class(x, y, self)
            # stack.G = (level, tx, ty)
            stack.CARD_XOFFSET = dx
            stack.CARD_YOFFSET = dy
            s.rows.append(stack)
            # tilemap - each tile covers 4 positions
            tilemap[(level, tx, ty)] = stack
            tilemap[(level, tx + 1, ty)] = stack
            tilemap[(level, tx, ty + 1)] = stack
            tilemap[(level, tx + 1, ty + 1)] = stack

        # compute blockmap
        for stack in s.rows:
            level, tx, ty = tiles[stack.id]
            above, below, left, right = {}, {}, {}, {}
            # above blockers
            for tl in range(level + 1, level + 2):
                above[tilemap.get((tl, tx, ty))] = 1
                above[tilemap.get((tl, tx + 1, ty))] = 1
                above[tilemap.get((tl, tx, ty + 1))] = 1
                above[tilemap.get((tl, tx + 1, ty + 1))] = 1
            #
            for tl in range(level):
                below[tilemap.get((tl, tx, ty))] = 1
                below[tilemap.get((tl, tx + 1, ty))] = 1
                below[tilemap.get((tl, tx, ty + 1))] = 1
                below[tilemap.get((tl, tx + 1, ty + 1))] = 1
            # left blockers
            left[tilemap.get((level, tx - 1, ty))] = 1
            left[tilemap.get((level, tx - 1, ty + 1))] = 1
            # right blockers
            right[tilemap.get((level, tx + 2, ty))] = 1
            right[tilemap.get((level, tx + 2, ty + 1))] = 1
            # up blockers
            # up[tilemap.get((level, tx, ty-1))] = 1
            # up[tilemap.get((level, tx+1, ty-1))] = 1
            # bottom blockers
            # bottom[tilemap.get((level, tx, ty+2))] = 1
            # bottom[tilemap.get((level, tx+1, ty+2))] = 1
            # sanity check - assert that there are no overlapping tiles
            assert tilemap.get((level, tx, ty)) is stack
            assert tilemap.get((level, tx + 1, ty)) is stack
            assert tilemap.get((level, tx, ty + 1)) is stack
            assert tilemap.get((level, tx + 1, ty + 1)) is stack
            #
            above = tuple([_f for _f in above.keys() if _f])
            below = tuple([_f for _f in below.keys() if _f])
            left = tuple([_f for _f in left.keys() if _f])
            right = tuple([_f for _f in right.keys() if _f])
            # up = tuple(filter(None, up.keys()))
            # bottom = tuple(filter(None, bottom.keys()))

            # assemble
            stack.blockmap = Struct(
                above=above,
                below=below,
                left=left,
                right=right,
                # up=up,
                # bottom=bottom,
                all_left=None,
                all_right=None,
            )

        def get_all_left(s):
            if s.blockmap.all_left is None:
                s.blockmap.all_left = {}
            for t in s.blockmap.left:
                if t.blockmap.all_left is None:
                    get_all_left(t)
                s.blockmap.all_left.update(t.blockmap.all_left)
                s.blockmap.all_left[t] = 1

        def get_all_right(s):
            if s.blockmap.all_right is None:
                s.blockmap.all_right = {}
            for t in s.blockmap.right:
                if t.blockmap.all_right is None:
                    get_all_right(t)
                s.blockmap.all_right.update(t.blockmap.all_right)
                s.blockmap.all_right[t] = 1

        for r in s.rows:
            get_all_left(r)
            get_all_right(r)
        for r in s.rows:
            r.blockmap.all_left = tuple(r.blockmap.all_left.keys())
            r.blockmap.all_right = tuple(r.blockmap.all_right.keys())

        # create other stacks
        for i in range(4):
            for j in range(9):
                if show_removed:
                    x = l.XM + i * cardw
                    y = l.YM + fdyy + j * cardh
                else:
                    if TOOLKIT == 'tk':
                        x = -l.XS - self.canvas.xmargin
                        y = l.YM + dyy
                    elif TOOLKIT == 'gtk':
                        # FIXME
                        x = self.width - l.XS
                        y = self.height - l.YS
                stack = Mahjongg_Foundation(x, y, self)
                if show_removed:
                    stack.CARD_XOFFSET = dx
                    stack.CARD_YOFFSET = dy
                s.foundations.append(stack)

        self.texts.info = MfxCanvasText(self.canvas,
                                        self.width - l.XM - ti_width,
                                        l.YM + dyy,
                                        anchor="nw",
                                        font=font)
        # the Talon is invisble
        s.talon = InitialDealTalonStack(-l.XS - self.canvas.xmargin,
                                        self.height - dyy, self)

        # Define stack groups
        l.defaultStackGroups()
Esempio n. 18
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()
Esempio n. 19
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(),
             comments=self.app.comments.new(),
             gamerandom=self.app.gamerandom,
             gdb=self.app.gdb,
             gimages=self.app.gimages,
             images=self.app.subsampled_images,
             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
     #
     self.preview_app.audio = None  # turn off audio for intial 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(_("Playable Preview - ") + 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[1]
     if self.app.getGameRulesFilename(gameid):
         rules_button.config(state="normal")
     else:
         rules_button.config(state="disabled")
Esempio n. 20
0
 def mPlayerStats(self, *args, **kw):
     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
             p0, p1, p2 = TITLE + _(" Demo"), TITLE + _(" Demo "), ""
         else:
             player = self.app.opt.player
             p0, p1, p2 = player, "", _(" for ") + player
         n = self.game.gameinfo.name
         #
         if mode == 100:
             d = Status_StatsDialog(self.top, game=self.game)
         elif mode == 101:
             header = p1 + _("Statistics for ") + n
             d = SingleGame_StatsDialog(self.top,
                                        header,
                                        self.app,
                                        player,
                                        gameid=self.game.id)
             gameid = d.selected_game
         elif mode == 102:
             header = p1 + _("Statistics") + p2
             d = AllGames_StatsDialog(self.top, header, self.app, player)
             gameid = d.selected_game
         elif mode == 103:
             header = p1 + _("Full log") + p2
             d = FullLog_StatsDialog(self.top, header, self.app, player)
         elif mode == 104:
             header = p1 + _("Session log") + p2
             d = SessionLog_StatsDialog(self.top, header, self.app, player)
         elif mode == 105:
             header = p1 + TOP_TITLE + _(" for ") + n
             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%s ?") %
                     p0,
                     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%s\nand game\n%s ?') %
                                     (p0, n),
                                     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