+ new option: `shrink face down'

* changed talon/waste text anchor: `ss' -> `s', `nn' -> `n' * fixed support python 2.2 and tk 8.3 git-svn-id: file:///home/shlomif/Backup/svn-dumps/PySolFC/svnsync-repos/pysolfc/PySolFC/trunk@43 efabe8c0-fbe8-4139-b769-b5e6d273206e
2025-04-05 00:02:29 -04:00 · 2006-08-10 21:19:27 +00:00 · 2006-08-10 21:19:27 +00:00 · 175410e2d0
commit 175410e2d0
parent 2632de3eab
47 changed files with 225 additions and 189 deletions
--- a/MANIFEST.in
+++ b/MANIFEST.in
@ -6,8 +6,7 @@ include pysol setup.py setup.cfg MANIFEST.in Makefile COPYING README
 #recursive-include pysollib *.py
 include pysollib/*.py pysollib/tk/*.py
 include pysollib/games/*.py pysollib/games/special/*.py
-include pysollib/games/ultra/*.py pysollib/games/contrib/*.py
-include pysollib/games/mahjongg/*.py
+include pysollib/games/ultra/*.py pysollib/games/mahjongg/*.py
 include docs/*
 include po/*
 include scripts/build.bat scripts/create_iss.py scripts/mahjongg_utils.py
--- a/pysollib/actions.py
+++ b/pysollib/actions.py
@ -126,6 +126,7 @@ class PysolMenubarActions:
            shadow = BooleanVar(),
            shade = BooleanVar(),
            shade_filled_stacks = BooleanVar(),
+            shrink_face_down = BooleanVar(),
            toolbar = IntVar(),
            toolbar_style = StringVar(),
            toolbar_relief = StringVar(),
@ -169,6 +170,7 @@ class PysolMenubarActions:
        tkopt.highlight_cards.set(opt.highlight_cards)
        tkopt.highlight_samerank.set(opt.highlight_samerank)
        tkopt.highlight_not_matching.set(opt.highlight_not_matching)
+        tkopt.shrink_face_down.set(opt.shrink_face_down)
        tkopt.shade_filled_stacks.set(opt.shade_filled_stacks)
        tkopt.mahjongg_show_removed.set(opt.mahjongg_show_removed)
        tkopt.shisen_show_hint.set(opt.shisen_show_hint)
@ -869,6 +871,12 @@ class PysolMenubarActions:
        self.app.opt.highlight_not_matching = self.tkopt.highlight_not_matching.get()
        ##self.game.updateMenus()

+    def mOptShrinkFaceDown(self, *args):
+        if self._cancelDrag(break_pause=False): return
+        self.app.opt.shrink_face_down = self.tkopt.shrink_face_down.get()
+        self.game.endGame(bookmark=1)
+        self.game.quitGame(bookmark=1)
+
    def mOptShadeFilledStacks(self, *args):
        if self._cancelDrag(break_pause=False): return
        self.app.opt.shade_filled_stacks = self.tkopt.shade_filled_stacks.get()
--- a/pysollib/app.py
+++ b/pysollib/app.py
@ -104,6 +104,7 @@ class Options:
        self.animations = 2                     # default to Timer based
        self.shadow = 1
        self.shade = 1
+        self.shrink_face_down = True
        self.shade_filled_stacks = True
        self.demo_logo = 1
        self.toolbar = 1
--- a/pysollib/games/acesup.py
+++ b/pysollib/games/acesup.py
@ -93,7 +93,7 @@ class AcesUp(Game):
        if reserve:
            l.createText(s.talon, "ne")
        else:
-            l.createText(s.talon, "ss")
+            l.createText(s.talon, "s")
        x = x + 3*l.XS/2
        for i in range(rows):
            s.rows.append(self.RowStack_Class(x, y, self))
@ -101,7 +101,7 @@ class AcesUp(Game):
        x = x + l.XS/2
        stack = self.Foundation_Class(x, y, self, suit=ANY_SUIT, max_move=0,
                                      dir=0, base_rank=ANY_RANK, max_cards=48)
-        l.createText(stack, "ss")
+        l.createText(stack, "s")
        s.foundations.append(stack)

        if reserve:
@ -221,16 +221,17 @@ class PerpetualMotion(Game):
        # create stacks
        x, y, = l.XM, l.YM
        s.talon = PerpetualMotion_Talon(x, y, self, max_rounds=-1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + 3*l.XS/2
        for i in range(4):
            s.rows.append(PerpetualMotion_RowStack(x, y, self, dir=0, base_rank=NO_RANK))
            x = x + l.XS
        x = l.XM + 6*l.XS
-        stack = PerpetualMotion_Foundation(x, y, self, ANY_SUIT, base_rank=ANY_RANK,
+        stack = PerpetualMotion_Foundation(x, y, self, ANY_SUIT,
+                                           base_rank=ANY_RANK,
                                           max_cards=52, max_move=0,
                                           min_accept=4, max_accept=4)
-        l.createText(stack, "ss")
+        l.createText(stack, "s")
        s.foundations.append(stack)

        # define stack-groups
--- a/pysollib/games/algerian.py
+++ b/pysollib/games/algerian.py
@ -98,7 +98,7 @@ class Carthage(Game):
            x += l.XS+d

        s.talon = self.Talon_Class(l.XM, l.YM, self)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/auldlangsyne.py
+++ b/pysollib/games/auldlangsyne.py
@ -68,7 +68,7 @@ class TamOShanter(Game):
        else:
            x, y, = l.XM, l.YM
        s.talon = self.Talon_Class(x, y, self)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        if texts:
            tx, ty, ta, tf = l.getTextAttr(s.talon, 'nn')
            font = self.app.getFont('canvas_default')
@ -271,7 +271,7 @@ class Interregnum(Game):
            s.talon.texts.rounds = MfxCanvasText(self.canvas, tx, ty,
                                                 anchor=ta, font=font)
        else:
-            l.createText(s.talon, "nn")
+            l.createText(s.talon, "n")

        # define stack-groups
        l.defaultStackGroups()
@ -417,7 +417,7 @@ class Colorado(Game):

        x, y = l.XM+9*l.XS, l.YM+3*l.YS
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x -= l.XS
        s.waste = WasteStack(x, y, self, max_cards=1)

--- a/pysollib/games/beleagueredcastle.py
+++ b/pysollib/games/beleagueredcastle.py
@ -391,15 +391,15 @@ class Zerline(Game):
        y = l.YM
        x = l.XM + w
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x += l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        x += l.XS
        stack = Zerline_ReserveStack(x, y, self, max_cards=reserve_max_cards)
        s.reserves.append(stack)
        stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
-        l.createText(stack, "ss")
+        l.createText(stack, "s")
        x = l.XM + w
        for j in range(decks):
            y = l.YM+l.TEXT_HEIGHT+l.YS
--- a/pysollib/games/braid.py
+++ b/pysollib/games/braid.py
@ -160,13 +160,13 @@ class Braid(Game):
        s.braid = Braid_BraidStack(x, y, self)
        x, y = l.XM + 7 * l.XS, l.YM + l.YS * 3/2
        s.talon = WasteTalonStack(x, y, self, max_rounds=3)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        s.talon.texts.rounds = MfxCanvasText(self.canvas,
                                             x + l.CW / 2, y - l.TEXT_MARGIN,
                                             anchor="s", font=font)
        x = x - l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        y = l.YM
        for i in range(4):
            x = l.XM+8*l.XS
@ -339,10 +339,10 @@ class Backbone(Game):

        x, y = l.XM+rows*l.XS/2, h-l.YS
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")
        x += l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "nn")
+        l.createText(s.waste, "n")

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/bristol.py
+++ b/pysollib/games/bristol.py
@ -210,7 +210,7 @@ class Dover(Bristol):
                x += l.XS
        if text:
            x, y = l.XM+8*l.XS, l.YM
-            tx, ty, ta, tf = l.getTextAttr(None, "s")
+            tx, ty, ta, tf = l.getTextAttr(None, "ss")
            tx, ty = x+tx+l.XM, y+ty
            font = self.app.getFont("canvas_default")
            self.texts.info = MfxCanvasText(self.canvas, tx, ty, anchor=ta, font=font)
--- a/pysollib/games/calculation.py
+++ b/pysollib/games/calculation.py
@ -165,7 +165,7 @@ class Calculation(Game):
        self.setRegion(s.rows, (-999, y, 999999, 999999))
        x = l.XM
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")
        y = y + l.YS
        s.waste = WasteStack(x, y, self, max_cards=1)

@ -254,10 +254,10 @@ class BetsyRoss(Calculation):
                                        anchor="w", font=self.app.getFont("canvas_fixed"))
        x = l.XM
        s.talon = WasteTalonStack(x, y, self, max_rounds=3)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")
        y = y + l.YS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/canfield.py
+++ b/pysollib/games/canfield.py
@ -376,10 +376,10 @@ class EagleWing(Canfield):
        # create stacks
        x, y = l.XM, l.YM
        s.talon = WasteTalonStack(x, y, self, max_rounds=3, num_deal=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        for i in range(4):
            x = l.XM + (i+3)*l.XS
            s.foundations.append(self.Foundation_Class(x, y, self, i, mod=13, max_move=0))
@ -395,7 +395,7 @@ class EagleWing(Canfield):
        x, y = l.XM + 4*l.XS, ry
        s.reserves.append(self.ReserveStack_Class(x, y, self))
        ##s.reserves[0].CARD_YOFFSET = 0
-        l.createText(s.reserves[0], "ss")
+        l.createText(s.reserves[0], "s")

        # define stack-groups
        l.defaultStackGroups()
@ -505,9 +505,9 @@ class LittleGate(Gate):
            s.rows.append(self.RowStack_Class(x, y, self))
            x += l.XS
        s.talon = WasteTalonStack(l.XM, l.YM, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        s.waste = WasteStack(l.XM+l.XS, l.YM, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/curdsandwhey.py
+++ b/pysollib/games/curdsandwhey.py
@ -233,7 +233,7 @@ class Arachnida(CurdsAndWhey):
        # create stacks
        x, y = l.XM, l.YM
        s.talon = DealRowTalonStack(x, y, self)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x += l.XS
        for i in range(10):
            stack = self.RowStack_Class(x, y, self, base_rank=ANY_RANK,
@ -243,7 +243,7 @@ class Arachnida(CurdsAndWhey):
            x += l.XS
        s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT,
                                                     max_accept=0, max_cards=104))
-        l.createText(s.foundations[0], "ss")
+        l.createText(s.foundations[0], "s")

        # define stack-groups
        l.defaultStackGroups()
@ -300,10 +300,10 @@ class GermanPatience(Game):
            x += l.XS
        x, y = l.XM, h-l.YS
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, 'nn')
+        l.createText(s.talon, 'n')
        x += l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, 'nn')
+        l.createText(s.waste, 'n')

        l.defaultStackGroups()

@ -361,7 +361,7 @@ class TrustyTwelve(Game):
        self.setSize(l.XM+(rows+1)*l.XS, l.YM+l.YS+12*l.YOFFSET)
        x, y = l.XM, l.YM
        s.talon = TalonStack(x, y, self)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x += l.XS
        for i in range(rows):
            s.rows.append(RK_RowStack(x, y, self, max_move=1))
@ -398,7 +398,7 @@ class SweetSixteen(TrustyTwelve):
        self.setSize(l.XM+9*l.XS, l.YM+2*l.YS+20*l.YOFFSET)
        x, y = l.XM, l.YM
        s.talon = TalonStack(x, y, self)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        y = l.YM
        for i in range(2):
            x = l.XM+l.XS
--- a/pysollib/games/diplomat.py
+++ b/pysollib/games/diplomat.py
@ -81,10 +81,10 @@ class Diplomat(Game):
            x = x + l.XS
        x, y, = l.XM, self.height - l.YS
        s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "nn")
+        l.createText(s.waste, "n")

        # define stack-groups
        l.defaultStackGroups()
@ -161,17 +161,15 @@ class Congress(Diplomat):
                s.rows.append(stack)
        x, y, = l.XM, l.YM
        s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        if max_rounds > 1:
            tx, ty, ta, tf = l.getTextAttr(s.waste, "ne")
            font = self.app.getFont("canvas_default")
-            s.talon.texts.rounds = MfxCanvasText(self.canvas,
-                                                 tx, ty,
-                                                 anchor=ta,
-                                                 font=font)
+            s.talon.texts.rounds = MfxCanvasText(self.canvas, tx, ty,
+                                                 anchor=ta, font=font)

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/doublets.py
+++ b/pysollib/games/doublets.py
@ -81,15 +81,15 @@ class Doublets(Game):
        s.foundations.append(Doublets_Foundation(x, y, self, ANY_SUIT,
                                                 dir=0, mod=13,
                                                 max_move=0, max_cards=48))
-        l.createText(s.foundations[0], "ss")
+        l.createText(s.foundations[0], "s")
 ##        help = "A, 2, 4, 8, 3, 6, Q, J, 9, 5, 10, 7, A, ..."
 ##        self.texts.help = MfxCanvasText(self.canvas, x + l.CW/2, y + l.YS + l.YM, anchor="n", text=help)
        x, y = l.XM, l.YM + 3*l.YS/2
        s.talon = WasteTalonStack(x, y, self, max_rounds=3)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/eiffeltower.py
+++ b/pysollib/games/eiffeltower.py
@ -83,10 +83,10 @@ class EiffelTower(Game):
        x = l.XM + 6 * l.XS
        y = l.YM + 5 * l.YS / 2
        s.waste = self.Waste_Class(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        x = x + l.XS
        s.talon = self.Talon_Class(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/glenwood.py
+++ b/pysollib/games/glenwood.py
@ -109,10 +109,10 @@ class Glenwood(Game):
        # create stacks
        x, y = l.XM, l.YM
        s.talon = Glenwood_Talon(x, y, self, max_rounds=2, num_deal=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x += l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        x += l.XS+l.XM
        for i in range(4):
            s.foundations.append(self.Foundation_Class(x, y, self, i, dir=1,
--- a/pysollib/games/golf.py
+++ b/pysollib/games/golf.py
@ -144,11 +144,11 @@ class Golf(Game):
            x = x + l.XS
        x, y = l.XM, self.height - l.YS
        s.talon = Golf_Talon(x, y, self, max_rounds=1)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")
        x = x + l.XS
        s.waste = self.Waste_Class(x, y, self)
        s.waste.CARD_XOFFSET = l.XOFFSET
-        l.createText(s.waste, "nn")
+        l.createText(s.waste, "n")
        # the Waste is also our only Foundation in this game
        s.foundations.append(s.waste)

@ -249,10 +249,10 @@ class Elevator(RelaxedGolf):
                x = x + l.XS
        x, y = l.XM, l.YM
        s.talon = Golf_Talon(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = self.Waste_Class(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        # the Waste is also our only Foundation in this game
        s.foundations.append(s.waste)

@ -334,8 +334,9 @@ class BlackHole(Game):
            r.CARD_XOFFSET = l.XOFFSET
            r.CARD_YOFFSET = 0
        x, y = l.XM + 2*w, l.YM + 3*l.YS/2
-        s.foundations.append(BlackHole_Foundation(x, y, self, ANY_SUIT, dir=0, mod=13, max_move=0, max_cards=52))
-        l.createText(s.foundations[0], "ss")
+        s.foundations.append(BlackHole_Foundation(x, y, self, suit=ANY_SUIT,
+                             dir=0, mod=13, max_move=0, max_cards=52))
+        l.createText(s.foundations[0], "s")
        x, y = l.XM + 4*w, self.height - l.YS
        s.talon = InitialDealTalonStack(x, y, self)

--- a/pysollib/games/gypsy.py
+++ b/pysollib/games/gypsy.py
@ -249,7 +249,7 @@ class MissMilligan(Gypsy):
        if s.reserves:
            self.setRegion(s.reserves, (-999, ry, rx - 1, 999999))
        else:
-            l.createText(s.talon, "ss")
+            l.createText(s.talon, "s")
            rx = -999
        x, y = l.XM + (8-rows)*l.XS/2, l.YM + l.YS
        for i in range(rows):
--- a/pysollib/games/harp.py
+++ b/pysollib/games/harp.py
@ -79,10 +79,10 @@ class DoubleKlondike(Game):
            assert s.talon.texts.rounds is None
            tx, ty, ta, tf = l.getTextAttr(s.talon, "nn")
            if layout.get("texts"):
-                ty = ty - 2*l.TEXT_MARGIN
+                ty = ty - l.TEXT_MARGIN
+            font = self.app.getFont("canvas_default")
            s.talon.texts.rounds = MfxCanvasText(self.canvas, tx, ty,
-                                                 anchor=ta,
-                                                 font=self.app.getFont("canvas_default"))
+                                                 anchor=ta, font=font)
        return l

    def startGame(self, flip=0):
--- a/pysollib/games/katzenschwanz.py
+++ b/pysollib/games/katzenschwanz.py
@ -298,7 +298,7 @@ class SalicLaw(DerKatzenschwanz):
            s.rows.append(stack)
            x += l.XS
        s.talon = SalicLaw_Talon(l.XM+9*l.XS, l.YM, self)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/klondike.py
+++ b/pysollib/games/klondike.py
@ -608,7 +608,7 @@ class Jane(Klondike):

        x, y = l.XM, l.YM
        s.talon = self.Talon_Class(x, y, self, max_rounds=max_rounds)
-        l.createText(s.talon, 'ss')
+        l.createText(s.talon, 's')
        x += l.XS
        s.waste = WasteStack(l.XM+l.XS, l.YM, self)

--- a/pysollib/games/montecarlo.py
+++ b/pysollib/games/montecarlo.py
@ -136,10 +136,10 @@ class MonteCarlo(Game):
        x, y = l.XM + 11*l.XS/2, l.YM
        s.foundations.append(self.Foundation_Class(x, y, self, suit=ANY_SUIT,
                             max_move=0, max_cards=self.gameinfo.ncards, base_rank=ANY_RANK))
-        l.createText(s.foundations[0], "ss")
+        l.createText(s.foundations[0], "s")
        y = y + 2*l.YS
        s.talon = self.Talon_Class(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss", text_format="%D")
+        l.createText(s.talon, "s", text_format="%D")

        # define stack-groups
        l.defaultStackGroups()
@ -285,11 +285,11 @@ class SimplePairs(MonteCarlo):
                                                  dir=0, base_rank=NO_RANK))
        x, y = l.XM, l.YM + 3*l.YS/2
        s.talon = TalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + 5*l.XS
        s.foundations.append(self.Foundation_Class(x, y, self, suit=ANY_SUIT,
-                                max_move=0, max_cards=52, base_rank=ANY_RANK))
-        l.createText(s.foundations[0], "ss")
+                             max_move=0, max_cards=52, base_rank=ANY_RANK))
+        l.createText(s.foundations[0], "s")

        # define stack-groups
        l.defaultStackGroups()
@ -408,7 +408,7 @@ class Fourteen(Game):
        x, y = l.XM + 6*l.XS, l.YM
        s.foundations.append(self.Foundation_Class(x, y, self, suit=ANY_SUIT,
                                max_move=0, max_cards=52, base_rank=ANY_RANK))
-        l.createText(s.foundations[0], "ss")
+        l.createText(s.foundations[0], "s")
        x, y = self.width - l.XS, self.height - l.YS
        s.talon = InitialDealTalonStack(x, y, self)

@ -478,7 +478,7 @@ class Nestor(Game):
        x, y = self.width-l.XS, self.height-l.YS
        s.foundations.append(self.Foundation_Class(x, y, self, suit=ANY_SUIT,
                                max_move=0, max_cards=52, base_rank=ANY_RANK))
-        l.createText(s.foundations[0], "nn")
+        l.createText(s.foundations[0], "n")
        x, y = l.XM, self.height - l.YS
        s.talon = InitialDealTalonStack(x, y, self)

@ -552,7 +552,7 @@ class Vertical(Nestor):
        x, y = self.width-l.XS, l.YM
        s.foundations.append(self.Foundation_Class(x, y, self, suit=ANY_SUIT,
                             max_move=0, max_cards=52, base_rank=ANY_RANK))
-        l.createText(s.foundations[0], "ss")
+        l.createText(s.foundations[0], "s")
        x -= l.XS
        s.talon = InitialDealTalonStack(x, y, self)

@ -599,7 +599,7 @@ class TheWish(Game):
        x, y = self.width - l.XS, self.height - l.YS
        s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT,
                             max_move=0, max_cards=32, max_accept=0, base_rank=ANY_RANK))
-        l.createText(s.foundations[0], "nn")
+        l.createText(s.foundations[0], "n")

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/numerica.py
+++ b/pysollib/games/numerica.py
@ -351,7 +351,7 @@ class Frog(Game):
        s.reserves.append(stack)
        x += l.XS
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x += l.XS
        s.waste = WasteStack(x, y, self, max_cards=1)
        x += l.XS
@ -430,7 +430,7 @@ class Gnat(Game):
        # create stacks
        x, y = l.XM, l.YM
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x += l.XS
        s.waste = WasteStack(x, y, self, max_cards=1)
        x += l.XS
@ -448,7 +448,7 @@ class Gnat(Game):
            for j in range(3):
                s.reserves.append(OpenStack(x, y, self, max_accept=0))
                y += l.YS
-            x += l.YS
+            x += l.XS

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/parallels.py
+++ b/pysollib/games/parallels.py
@ -132,7 +132,7 @@ class Parallels(Game):
        self.setSize(l.XM+12*l.XS, l.YM+7*l.YS)
        # create stacks
        s.talon = Parallels_TalonStack(l.XM, l.YM, self)
-        l.createText(s.talon, 'ss')
+        l.createText(s.talon, 's')
        n = 0
        y = l.YM
        for i in range(7):
--- a/pysollib/games/royalcotillion.py
+++ b/pysollib/games/royalcotillion.py
@ -152,10 +152,10 @@ class OddAndEven(RoyalCotillion):
                x = x + l.XS
        x, y = l.XM, self.height - l.YS
        s.talon = WasteTalonStack(x, y, self, max_rounds=2)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "nn")
+        l.createText(s.waste, "n")

        # define stack-groups
        l.defaultStackGroups()
@ -226,7 +226,6 @@ class Kingdom(RoyalCotillion):
 # // Grant's Reinforcement
 # ************************************************************************/

-
 class Alhambra_Hint(CautiousDefaultHint):
    def _getDropCardScore(self, score, color, r, t, ncards):
        return 93000, color
--- a/pysollib/games/royaleast.py
+++ b/pysollib/games/royaleast.py
@ -78,10 +78,10 @@ class RoyalEast(Game):
            s.rows.append(stack)
        x, y = l.XM, l.YM + 3*l.YS/2
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/special/memory.py
+++ b/pysollib/games/special/memory.py
@ -137,7 +137,7 @@ class Memory24(Game):
                               max_move=0, max_accept=0, max_cards=1))
        x, y = l.XM, l.YM
        s.talon = InitialDealTalonStack(x, y, self)
-        l.createText(s.talon, anchor="nn", text_format="%D")
+        l.createText(s.talon, anchor="n", text_format="%D")
        s.internals.append(InvisibleStack(self))

        # define stack-groups
--- a/pysollib/games/special/pegged.py
+++ b/pysollib/games/special/pegged.py
@ -142,7 +142,7 @@ class Pegged(Game):
                self.map[stack.pos] = stack
        x, y = self.width - l.XS, l.YM
        s.foundations.append(AbstractFoundationStack(x, y, self, ANY_SUIT, max_move=0, max_accept=0, max_cards=self.gameinfo.ncards))
-        l.createText(s.foundations[0], "ss")
+        l.createText(s.foundations[0], "s")
        y = self.height - l.YS
        s.talon = InitialDealTalonStack(x, y, self)
        s.internals.append(InvisibleStack(self))
--- a/pysollib/games/special/tarock.py
+++ b/pysollib/games/special/tarock.py
@ -282,10 +282,10 @@ class WheelOfFortune(AbstractTarockGame):
        x = self.width - l.XS
        y = self.height - l.YS * 1.5
        s.talon = WasteTalonStack(x, y, self, num_deal=2, max_rounds=1)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")
        x = x - l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "nn")
+        l.createText(s.waste, "n")

        # Define stack groups
        l.defaultStackGroups()
@ -335,10 +335,10 @@ class ImperialTrumps(AbstractTarockGame):
        # Create talon
        x = l.XM
        s.talon = WasteTalonStack(x, y, self, num_deal=1, max_rounds=-1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # Create rows
        x = l.XM
@ -684,10 +684,10 @@ class Grasshopper(AbstractTarockGame):
        x = l.XM
        y = l.YM
        s.talon = WasteTalonStack(x, y, self, num_deal=1, max_rounds=self.MAX_ROUNDS)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # Create foundations
        x = x + l.XM + l.XS
@ -796,14 +796,14 @@ class Ponytail(Tarock_GameMethods, Braid):
        x = l.XM + 7 * l.XS
        y = l.YM + 2*l.YS
        s.talon = WasteTalonStack(x, y, self, max_rounds=3)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        s.talon.texts.rounds = MfxCanvasText(self.canvas,
                                             x + l.CW / 2, y - l.YM,
                                             anchor="s",
                                             font=self.app.getFont("canvas_default"))
        x = x - l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        x = l.XM + 8 * l.XS
        y = l.YM
        for i in range(4):
--- a/pysollib/games/spider.py
+++ b/pysollib/games/spider.py
@ -681,7 +681,7 @@ class Chelicera(Game):
        # create stacks
        x, y = l.XM, l.YM
        s.talon = TalonStack(x, y, self)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x += l.XS
        for i in range(7):
            s.rows.append(Chelicera_RowStack(x, y, self, base_rank=KING))
@ -765,7 +765,7 @@ class SpiderWeb(RelaxedSpider):
        # create stacks
        x, y = l.XM, l.YM
        s.talon = DealRowTalonStack(x, y, self)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x += 2*l.XS
        s.reserves.append(ReserveStack(x, y, self))
        x += 2*l.XS
--- a/pysollib/games/sultan.py
+++ b/pysollib/games/sultan.py
@ -253,10 +253,10 @@ class Contradance(Game):

        x, y = l.XM+3*l.XS, l.YM+3*l.YS
        s.talon = WasteTalonStack(x, y, self, max_rounds=2)
-        l.createText(s.talon, 'nn')
+        l.createText(s.talon, 'n')
        x += l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, 'nn')
+        l.createText(s.waste, 'n')

        l.defaultStackGroups()

@ -292,10 +292,10 @@ class IdleAces(Game):

        x, y = l.XM, l.YM
        s.talon = WasteTalonStack(x, y, self, max_rounds=3)
-        l.createText(s.talon, 'ss')
+        l.createText(s.talon, 's')
        x += l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, 'ss')
+        l.createText(s.waste, 's')
        x0, y0 = l.XM+2*l.XS, l.YM
        k = 0
        for i, j in((2, 0), (0, 1.5), (4, 1.5), (2, 3)):
--- a/pysollib/games/ultra/dashavatara.py
+++ b/pysollib/games/ultra/dashavatara.py
@ -480,7 +480,7 @@ class TenAvatars(AbstractDashavataraGame):

        # Create talon
        s.talon = DealRowTalonStack(l.XM, self.height - l.YS, self)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")

        # Define stack groups
        l.defaultStackGroups()
@ -883,14 +883,14 @@ class Journey(AbstractDashavataraGame):
        # Create talon
        x, y = l.XM + l.XS * 2 + l.XS * decks, h - l.YS - l.YM
        s.talon = WasteTalonStack(x, y, self, max_rounds=3)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        s.talon.texts.rounds = MfxCanvasText(self.canvas,
                                             self.width / 2, h - l.YM * 2.5,
                                             anchor="center",
                                             font=self.app.getFont("canvas_default"))
        x = x + l.XS * 2
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # define stack-groups
        self.sg.talonstacks = [s.talon] + [s.waste]
@ -1010,7 +1010,7 @@ class AppachansWaterfall(AbstractDashavataraGame):

        # Create talon
        s.talon = DealRowTalonStack(l.XM, y, self)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")

        # Define stack groups
        l.defaultStackGroups()
--- a/pysollib/games/ultra/hanafuda.py
+++ b/pysollib/games/ultra/hanafuda.py
@ -594,10 +594,10 @@ class FourWinds(AbstractFlowerGame):
        x = x + 2 * l.XS
        y = y + 2 * l.YS
        s.talon = WasteTalonStack(x, y, self, num_deal=1, max_rounds=2)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # Define stack-groups
        l.defaultStackGroups()
--- a/pysollib/games/ultra/hanafuda1.py
+++ b/pysollib/games/ultra/hanafuda1.py
@ -133,8 +133,9 @@ class LesserQueue(AbstractFlowerGame):

        # set window
        decks = self.gameinfo.decks
-        h = l.YM + l.YS * 5.5
-        self.setSize(l.XM + l.XS * 10.5, l.YM + h)
+        yoffset = l.YOFFSET*self.BRAID_OFFSET
+        h = l.YM+max(l.YS*5.5, l.YS+self.BRAID_CARDS*yoffset+2*l.TEXT_MARGIN)
+        self.setSize(l.XM + l.XS * 10.5, h)

        # extra settings
        self.base_card = None
@ -164,16 +165,16 @@ class LesserQueue(AbstractFlowerGame):
        s.braid = Queue_BraidStack(x, y, self, yoffset=self.BRAID_OFFSET)

        # Create talon, waste
-        x, y = l.XM, l.YM + l.YS * 4.3
+        x, y = l.XM, h-l.YS
        s.talon = WasteTalonStack(x, y, self, max_rounds=3)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "n")
        s.talon.texts.rounds = MfxCanvasText(self.canvas,
-                                             self.width / 2, h - l.YM * 2.5,
+                                             self.width/2, h-2*l.TEXT_MARGIN,
                                             anchor="center",
                                             font=self.app.getFont("canvas_default"))
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "n")

        # Create foundations
        x = l.XM
@ -187,7 +188,7 @@ class LesserQueue(AbstractFlowerGame):
                y = y + l.YS
            x = x + l.XS
        self.texts.info = MfxCanvasText(self.canvas,
-                                        self.width / 2, h - l.YM / 2,
+                                        self.width/2, h-l.TEXT_MARGIN,
                                        anchor="center",
                                        font=self.app.getFont("canvas_default"))

--- a/pysollib/games/ultra/hexadeck.py
+++ b/pysollib/games/ultra/hexadeck.py
@ -331,10 +331,10 @@ class BitsNBytes(Game):
        x = l.XM
        y = l.YM
        s.talon = WasteTalonStack(x, y, self, num_deal=2, max_rounds=2)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        y += l.YS + l.TEXT_HEIGHT
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # Define stack groups
        l.defaultStackGroups()
@ -1099,14 +1099,14 @@ class MerlinsMeander(AbstractHexADeckGame):
        # Create talon, waste
        x, y = l.XM + l.XS * 7, l.YM + l.YS * 1.5
        s.talon = WasteTalonStack(x, y, self, max_rounds=3)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        s.talon.texts.rounds = MfxCanvasText(self.canvas,
                                             x + l.CW / 2, y - l.YM,
                                             anchor="s",
                                             font=self.app.getFont("canvas_default"))
        x = x - l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # Create foundations
        x, y = l.XM + l.XS * 8, l.YM
--- a/pysollib/games/ultra/mughal.py
+++ b/pysollib/games/ultra/mughal.py
@ -392,7 +392,7 @@ class EightLegions(AbstractMughalGame):

        # Create talon
        s.talon = DealRowTalonStack(l.XM, self.height - l.YS, self)
-        l.createText(s.talon, "nn")
+        l.createText(s.talon, "n")

        # Define stack groups
        l.defaultStackGroups()
@ -727,14 +727,14 @@ class AkbarsTriumph(AbstractMughalGame):
        # Create talon
        x, y = l.XM + l.XS * 2 + l.XS * decks, h - l.YS - l.YM
        s.talon = WasteTalonStack(x, y, self, max_rounds = 3)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        s.talon.texts.rounds = MfxCanvasText(self.canvas,
                                             self.width / 2, h - l.YM * 2.5,
                                             anchor = "center",
                                             font=self.app.getFont("canvas_default"))
        x = x + l.XS * 2
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")

        # define stack-groups
        self.sg.talonstacks = [s.talon] + [s.waste]
--- a/pysollib/games/windmill.py
+++ b/pysollib/games/windmill.py
@ -98,10 +98,10 @@ class Windmill(Game):
        x = l.XM
        y = l.YM
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        x0, y0 = x + l.XS, y
        for d in self.ROWS_LAYOUT:
            x, y = x0 + d[0] * l.XS, y0 + d[1] * l.YS
@ -221,10 +221,10 @@ class NapoleonsTomb(Windmill):
        x = l.XM
        y = l.YM
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, "ss")
+        l.createText(s.talon, "s")
        x = x + l.XS
        s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, "ss")
+        l.createText(s.waste, "s")
        x0, y0 = x + l.XS, y
        for d in ((0,1), (1,0), (1,2), (2,1)):
            x, y = x0 + d[0] * l.XS, y0 + d[1] * l.YS
--- a/pysollib/layout.py
+++ b/pysollib/layout.py
@ -133,6 +133,7 @@ class Layout:
                self.XOFFSET =  self.XOFFSET / self.game.preview
            if kw.has_key("YOFFSET"):
                self.YOFFSET =  self.YOFFSET / self.game.preview
+            self.TEXT_HEIGHT = 10

    def __createStack(self, x, y, suit=None):
        stack = _LayoutStack(x, y, suit)
@ -144,6 +145,10 @@ class Layout:
        self.stackmap[mapkey] = stack
        return stack

+    def _setText(self, stack, anchor="center"):
+        tx, ty, ta, tf = self.getTextAttr(stack, anchor)
+        stack.setText(tx, ty, ta, tf)
+
    #
    #
    #
@ -196,16 +201,17 @@ class Layout:
    def getTextAttr(self, stack, anchor):
        x, y = 0, 0
        delta_x, delta_y = 4, 4
+        delta_yy = 10
        if stack is not None:
            x, y = stack.x, stack.y
        if anchor == "n":
            return (x+self.CW/2, y-delta_y, "s", "%d")
        if anchor == "nn":
-            return (x+self.CW/2, y-self.TEXT_MARGIN, "s", "%d")
+            return (x+self.CW/2, y-delta_yy, "s", "%d")
        if anchor == "s":
            return (x+self.CW/2, y+self.CH+delta_y, "n", "%d")
        if anchor == "ss":
-            return (x+self.CW/2, y+self.CH+self.TEXT_MARGIN, "n", "%d")
+            return (x+self.CW/2, y+self.CH+delta_yy, "n", "%d")
        if anchor == "nw":
            return (x-delta_x, y, "ne", "%d")
        if anchor == "sw":
@ -226,9 +232,9 @@ class Layout:
            return
        assert stack.texts.ncards is None
        tx, ty, ta, tf = self.getTextAttr(stack, anchor)
+        font = self.game.app.getFont("canvas_default")
        stack.texts.ncards = MfxCanvasText(self.canvas, tx+dx, ty+dy,
-                                           anchor=ta,
-                                           font=self.game.app.getFont("canvas_default"))
+                                           anchor=ta, font=font)
        stack.texts.ncards.text_format = text_format or tf

    def setRegion(self, stacks, rects):
@ -376,7 +382,7 @@ class Layout:
        self.s.talon = s = S(x, y)
        if texts:
            # place text right of stack
-            s.setText(x + XS, y + CH, anchor="sw", format="%3d")
+            self._setText(s, anchor="se")

        # set window
        self.size = (w, h)
@ -425,13 +431,13 @@ class Layout:
        self.s.talon = s = S(x, y)
        if texts:
            # place text right of stack
-            s.setText(x + XS, y + CH, anchor="sw", format="%3d")
+            self._setText(s, anchor="se")
        if waste:
            x = x - XS
            self.s.waste = s = S(x, y)
            if texts:
                # place text left of stack
-                s.setText(x - self.TEXT_MARGIN, y + CH, anchor="se", format="%3d")
+                self._setText(s, anchor="sw")
        # create reserves
        x, y = XM, h-YS
        for i in range(reserves):
@ -483,12 +489,12 @@ class Layout:
            self.s.waste = s = S(x, y)
            if texts:
                # place text above stack
-                s.setText(x + CW / 2, y - self.TEXT_MARGIN, anchor="s")
+                self._setText(s, 'n')
        x = w - XS
        self.s.talon = s = S(x, y)
        if texts:
            # place text above stack
-            s.setText(x + CW / 2, y - self.TEXT_MARGIN, anchor="s")
+            self._setText(s, 'n')

        # set window
        self.size = (w, YM + h + YS)
@ -524,17 +530,17 @@ class Layout:
        if texts:
            if waste or not center or maxrows - frows <= 1:
                # place text below stack
-                s.setText(x + CW / 2, y + YS, anchor="n")
+                self._setText(s, 's')
                text_height = self.TEXT_HEIGHT
            else:
                # place text right of stack
-                s.setText(x + XS, y, anchor="nw", format="%3d")
+                self._setText(s, 'ne')
        if waste:
            x = x + XS
            self.s.waste = s = S(x, y)
            if texts:
                # place text below stack
-                s.setText(x + CW / 2, y + YS, anchor="n")
+                self._setText(s, 's')
                text_height = self.TEXT_HEIGHT

        for row in range(foundrows):
@ -600,7 +606,7 @@ class Layout:
        self.s.talon = s = S(x, y)
        if texts:
            # place text right of stack
-            s.setText(x + XS, y + CH, anchor="sw", format="%3d")
+            self._setText(s, 'se')

        # set window
        self.size = (XM + (rows+decks)*XS,  h)
@ -635,17 +641,17 @@ class Layout:
        if texts:
            if waste or not center or maxrows - frows <= 1:
                # place text below stack
-                s.setText(x + CW / 2, y + YS, anchor="n")
+                self._setText(s, 's')
                yextra = 20
            else:
                # place text right of stack
-                s.setText(x + XS, y, anchor="nw", format="%3d")
+                self._setText(s, 'ne')
        if waste:
            x = x + XS
            self.s.waste = s = S(x, y)
            if texts:
                # place text below stack
-                s.setText(x + CW / 2, y + YS, anchor="n")
+                self._setText(s, 's')
        x = XM + (maxrows - frows) * XS
        if center and frows + 2 * (1 + waste + 1) <= maxrows:
            # center the foundations
@ -700,17 +706,17 @@ class Layout:
        if texts:
            if waste or not center or toprows - rows <= 1:
                # place text below stack
-                s.setText(x + CW / 2, y + YS, anchor="n")
+                self._setText(s, 's')
                yextra = 20
            else:
                # place text right of stack
-                s.setText(x + XS, y, anchor="nw", format="%3d")
+                self._setText(s, 'ne')
        if waste:
            x = x + XS
            self.s.waste = s = S(x, y)
            if texts:
                # place text below stack
-                s.setText(x + CW / 2, y + YS, anchor="n")
+                self._setText(s, 's')

        # left & right
        x, y = XM, YM
@ -789,7 +795,7 @@ class Layout:
        self.s.talon = s = S(x, y)
        if texts:
            # place text right of stack
-            s.setText(x + XS, y + CH, anchor="sw", format="%3d")
+            self._setText(s, 'se')

        # set window
        self.size = (XM + toprows * XS, YM + YS + h)
@ -851,7 +857,7 @@ class Layout:
        self.s.talon = s = S(x, y)
        if texts:
            # place text right of stack
-            s.setText(x + XS, y + CH, anchor="sw", format="%3d")
+            self._setText(s, 'se')

        # set window
        self.size = (w, YM + YS + h)
@ -884,7 +890,7 @@ class Layout:
        self.s.talon = s = S(x, y)
        if texts:
            # place text below stack
-            s.setText(x + CW / 2, y + YS, anchor="center", format="%d")
+            self._setText(s, 's')

        # create rows
        x, y = XS + XM * 3, YM
@ -898,7 +904,7 @@ class Layout:
        self.setRegion(self.s.rows, (XS + XM, -999, 999999, 999999))

        # create reserves
-        x, y = XM, YM * 3 + YS
+        x, y = XM, YM + YS + self.TEXT_HEIGHT
        for i in range(decks):
            for i in range(reserves / decks):
                self.s.reserves.append(S(x, y))
@ -985,9 +991,9 @@ class Layout:
        # Talon
        x, y = XM, YM
        self.s.talon = s = S(x, y)
-        s.setText(x + XS, y + CH, anchor = "sw", format = "%3d")
+        self._setText(s, 'se')
        self.s.waste = s = S(x, y + YS)
-        s.setText(x + XS, y + YS + CH, anchor = "sw", format = "%3d")
+        self._setText(s, 'se')

        # Create foundations
        x = w - fspace - XS * frows / 2
--- a/pysollib/move.py
+++ b/pysollib/move.py
@ -149,6 +149,7 @@ class AFlipAllMove(AtomicMove):
                card.showBack()
            else:
                card.showFace()
+        stack.refreshView()

    def undo(self, game):
        stack = game.allstacks[self.stack_id]
@ -157,6 +158,7 @@ class AFlipAllMove(AtomicMove):
                card.showBack()
            else:
                card.showFace()
+        stack.refreshView()

    def cmpForRedo(self, other):
        return cmp(self.stack_id, other.stack_id)
@ -463,6 +465,7 @@ class ACloseStackMove(AtomicMove):

 # /***********************************************************************
 # // ASingleCardMove - move single card from *anyone* position
+# // (for ArbitraryStack)
 # ************************************************************************/

 class ASingleCardMove(AtomicMove):
@ -487,6 +490,7 @@ class ASingleCardMove(AtomicMove):
            game.animatedMoveTo(from_stack, to_stack, [card], x, y,
                                frames=self.frames, shadow=self.shadow)
        to_stack.addCard(card)
+        stack.refreshView()

    def undo(self, game):
        from_stack = game.allstacks[self.from_stack_id]
@ -498,6 +502,7 @@ class ASingleCardMove(AtomicMove):
 ##             game.animatedMoveTo(from_stack, to_stack, [card], x, y,
 ##                                 frames=self.frames, shadow=self.shadow)
        from_stack.insertCard(card, from_pos)
+        stack.refreshView()

    def cmpForRedo(self, other):
        return cmp((self.from_stack_id, self.to_stack_id, self.from_pos),
--- a/pysollib/pysolrandom.py
+++ b/pysollib/pysolrandom.py
@ -148,7 +148,7 @@ class MFXRandom:

    # Get a random integer in the range [a, b] including both end points.
    def randint(self, a, b):
-        return a + int(self.random() * (b+1-a))
+        return a + long(self.random() * (b+1-a))

    def randrange(self, a, b):
        return self.randint(a, b-1)
@ -234,9 +234,13 @@ class LCRandom31(MFXRandom):
        self.seed = (self.seed*214013L + 2531011L) & self.MAX_SEED
        return a + (int(self.seed >> 16) % (b+1-a))

+
 # select
-##PysolRandom = LCRandom64
-PysolRandom = SysRandom
+if sys.version_info >= (2,3):
+    PysolRandom = SysRandom
+else:
+    PysolRandom = LCRandom64
+

 # /***********************************************************************
 # // PySol support code
--- a/pysollib/stack.py
+++ b/pysollib/stack.py
@ -274,6 +274,7 @@ class Stack:
        view.CARD_XOFFSET = 0
        view.CARD_YOFFSET = 0
        view.group = MfxCanvasGroup(view.canvas)
+        view.shrink_face_down = 1
        ##view.group.move(view.x, view.y)
        # image items
        view.images = Struct(
@ -382,6 +383,11 @@ class Stack:
                # don't display a shadow if the YOFFSET of the stack
                # and the images don't match
                self.max_shadow_cards = 1
+        if (self.game.app.opt.shrink_face_down and
+            type(ox) is int and type(oy) is int):
+            if ((ox == 0 and oy >= self.game.app.images.CARD_YOFFSET/2) or
+                (oy == 0 and ox >= self.game.app.images.CARD_XOFFSET/2)):
+                self.shrink_face_down = 2
        # bottom image
        if self.is_visible:
            self.prepareBottom()
@ -702,10 +708,16 @@ class Stack:
        for c in model.cards:
            if c is card:
                break
-            x = x + view.CARD_XOFFSET[ix]
-            y = y + view.CARD_YOFFSET[iy]
+            d = self.shrink_face_down
+            if c.face_up:
+                x += self.CARD_XOFFSET[ix]
+                y += self.CARD_YOFFSET[iy]
+            else:
+                x += int(self.CARD_XOFFSET[ix]/d)
+                y += int(self.CARD_YOFFSET[iy]/d)
            ix = (ix + 1) % lx
            iy = (iy + 1) % ly
+
        return (x, y)

    def getOffsetFor(self, card):
@ -742,8 +754,13 @@ class Stack:
            c.item.tkraise(item)
            item = c.item
            if not view.can_hide_cards:
-                x = x + view.CARD_XOFFSET[ix]
-                y = y + view.CARD_YOFFSET[iy]
+                d = self.shrink_face_down
+                if c.face_up:
+                    x += self.CARD_XOFFSET[ix]
+                    y += self.CARD_YOFFSET[iy]
+                else:
+                    x += int(self.CARD_XOFFSET[ix]/d)
+                    y += int(self.CARD_YOFFSET[iy]/d)
                ix = (ix + 1) % lx
                iy = (iy + 1) % ly
                c.moveTo(x, y)
@ -2240,6 +2257,9 @@ class InvisibleStack(Stack):

 # /***********************************************************************
 # // ArbitraryStack (stack with arbitrary access)
+# //
+# // NB: don't support hint and demo for non-top cards
+# // NB: this stack only for CARD_XOFFSET == 0
 # ************************************************************************/

 class ArbitraryStack(OpenStack):
--- a/pysollib/tk/menubar.py
+++ b/pysollib/tk/menubar.py
@ -90,12 +90,12 @@ def createToolbarMenu(menubar, menu):
                            variable=menubar.tkopt.toolbar_relief,
                            value=Tkinter.RAISED,
                            command=menubar.mOptToolbarRelief)
-
-    submenu = MfxMenu(menu, label=n_('Compound'), tearoff=tearoff)
-    for comp, label in COMPOUNDS:
-        submenu.add_radiobutton(label=label,
-                                variable=menubar.tkopt.toolbar_compound,
-                                value=comp, command=menubar.mOptToolbarCompound)
+    if Tkinter.TkVersion >= 8.4:
+        submenu = MfxMenu(menu, label=n_('Compound'), tearoff=tearoff)
+        for comp, label in COMPOUNDS:
+            submenu.add_radiobutton(
+                label=label, variable=menubar.tkopt.toolbar_compound,
+                value=comp, command=menubar.mOptToolbarCompound)
    menu.add_separator()
    menu.add_radiobutton(label=n_("Hide"),
                         variable=menubar.tkopt.toolbar, value=0,
@ -371,6 +371,7 @@ class PysolMenubar(PysolMenubarActions):
        submenu.add_checkbutton(label=n_("Card shado&w"), variable=self.tkopt.shadow, command=self.mOptShadow)
        submenu.add_checkbutton(label=n_("Shade &legal moves"), variable=self.tkopt.shade, command=self.mOptShade)
        submenu.add_checkbutton(label=n_("&Negative cards bottom"), variable=self.tkopt.negative_bottom, command=self.mOptNegativeBottom)
+        submenu.add_checkbutton(label=n_("Shrink face-down cards"), variable=self.tkopt.shrink_face_down, command=self.mOptShrinkFaceDown)
        submenu.add_checkbutton(label=n_("Shade &filled stacks"), variable=self.tkopt.shade_filled_stacks, command=self.mOptShadeFilledStacks)
        submenu = MfxMenu(menu, label=n_("A&nimations"))
        submenu.add_radiobutton(label=n_("&None"), variable=self.tkopt.animations, value=0, command=self.mOptAnimations)
--- a/pysollib/tk/selectgame.py
+++ b/pysollib/tk/selectgame.py
@ -349,8 +349,8 @@ class SelectGameDialogWithPreview(SelectGameDialog):
            info_frame = Tkinter.LabelFrame(right_frame, text=_('About game'))
            stats_frame = Tkinter.LabelFrame(right_frame, text=_('Statistics'))
        else:
-            info_frame = Tkinter.Frame(right_frame)
-            stats_frame = Tkinter.Frame(right_frame)
+            info_frame = Tkinter.Frame(right_frame, bd=2, relief='groove')
+            stats_frame = Tkinter.Frame(right_frame, bd=2, relief='groove')
        info_frame.grid(row=0, column=0, padx=padx, pady=pady,
                        ipadx=padx, ipady=pady, sticky='nws')
        stats_frame.grid(row=0, column=1, padx=padx, pady=pady,
@ -485,14 +485,6 @@ class SelectGameDialogWithPreview(SelectGameDialog):
        ##self.top.wm_title("Select Game - " + self.app.getGameTitleName(gameid))
        title = self.app.getGameTitleName(gameid)
        self.top.wm_title(_("Playable Preview - ") + title)
-##         if False:
-##             cw, ch = canvas.winfo_width(), canvas.winfo_height()
-##             if cw >= 100 and ch >= 100:
-##                 MfxCanvasText(canvas, cw / 2, ch - 4,
-##                               preview=0, anchor="s", text=_("Playable Area"),
-##                               font=self.app.getFont("canvas_large"))
-##                 if self.app.opt.table_text_color:
-##                     canvas.setTextColor(self.app.opt.table_text_color_value)
        #
        self.preview_game = gi.gameclass(gi)
        self.preview_game.createPreview(self.preview_app)
--- a/pysollib/tk/soundoptionsdialog.py
+++ b/pysollib/tk/soundoptionsdialog.py
@ -144,7 +144,7 @@ class SoundOptionsDialog(MfxDialog):
            frame = Tkinter.LabelFrame(top_frame, text=_('Enable samles'),
                                       padx=5, pady=5)
        else:
-            frame = Tkinter.Frame(top_frame)
+            frame = Tkinter.Frame(top_frame, bd=2, relief='groove')
        frame.pack(expand=1, fill='both', padx=5, pady=5)
        frame.columnconfigure(0, weight=1)
        frame.columnconfigure(1, weight=1)
--- a/pysollib/tk/tkhtml.py
+++ b/pysollib/tk/tkhtml.py
@ -223,10 +223,6 @@ class tkHTMLParser(htmllib.HTMLParser):
    def handle_image(self, src, alt, ismap, align, width, height):
        self.formatter.writer.viewer.showImage(src, alt, ismap, align, width, height)

-    def do_br(self, attrs):
-        #self.formatter.add_line_break()
-        self.formatter.add_literal_data('\n')
-

 # /***********************************************************************
 # //
--- a/pysollib/tk/toolbar.py
+++ b/pysollib/tk/toolbar.py
@ -214,7 +214,7 @@ class PysolToolbar(PysolToolbarActions):
                sep = self._createSeparator()
                sep.bind("<1>", self.clickHandler)
                sep.bind("<3>", self.rightclickHandler)
-            elif l == 'Pause' and Tkinter.TkVersion >= 8.4:
+            elif l == 'Pause':
                self._createButton(l, f, check=True, tooltip=t)
            else:
                self._createButton(l, f, tooltip=t)
@ -344,22 +344,24 @@ class PysolToolbar(PysolToolbarActions):
        position = len(self._widgets)
        bd = self.button_relief == 'flat' and 1 or 2
        kw = {
-            'position': position,
-            'toolbar': self,
-            'toolbar_name': name,
-            'command': command,
-            'takefocus': 0,
-            'text': gettext(label),
-            'bd': bd,
-            'relief': self.button_relief,
-            'overrelief': 'raised',
-            'padx': self.button_pad,
-            'pady': self.button_pad
+            'position'     : position,
+            'toolbar'      : self,
+            'toolbar_name' : name,
+            'command'      : command,
+            'takefocus'    : 0,
+            'text'         : gettext(label),
+            'bd'           : bd,
+            'relief'       : self.button_relief,
+            'padx'         : self.button_pad,
+            'pady'         : self.button_pad
            }
+        if Tkinter.TkVersion >= 8.4:
+            kw['overrelief'] = 'raised'
        if image:
            kw['image'] = image
        if check:
-            kw['offrelief'] = self.button_relief
+            if Tkinter.TkVersion >= 8.4:
+                kw['offrelief'] = self.button_relief
            kw['indicatoron'] = False
            kw['selectcolor'] = ''
            button = ToolbarCheckbutton(self.frame, **kw)
@ -506,27 +508,30 @@ class PysolToolbar(PysolToolbarActions):
            if isinstance(w, ToolbarButton):
                w.config(relief=self.button_relief, bd=bd)
            elif isinstance(w, ToolbarCheckbutton):
-                w.config(relief=self.button_relief,
-                         offrelief=self.button_relief, bd=bd)
+                w.config(relief=self.button_relief, bd=bd)
+                if Tkinter.TkVersion >= 8.4:
+                    w.config(offrelief=self.button_relief)
            elif w.__class__ is ToolbarSeparator: # not ToolbarFlatSeparator
                w.config(relief=self.separator_relief)
        return True

    def setCompound(self, compound, force=False):
+        if Tkinter.TkVersion < 8.4:
+            return False
        if not force and self.compound == compound:
            return False
        for w in self._widgets:
            if not isinstance(w, (ToolbarButton, ToolbarCheckbutton)):
                continue
            if compound == 'text':
-                w.config(compound=Tkinter.NONE, image='')
+                w.config(compound='none', image='')
            else:
                image = getattr(self, w.toolbar_name+'_image')
                w.config(compound=compound, image=image)
        self.compound = compound
        return True

-    def _setOrient(self, orient=Tkinter.HORIZONTAL, force=False):
+    def _setOrient(self, orient='horizontal', force=False):
        if not force and self.orient == orient:
            return False
        for w in self._widgets:
--- a/setup.py
+++ b/setup.py
@ -57,7 +57,6 @@ kw = {
    'packages'     : ['pysollib',
                      'pysollib.tk',
                      'pysollib.games',
-                      'pysollib.games.contrib',
                      'pysollib.games.special',
                      'pysollib.games.ultra',
                      'pysollib.games.mahjongg'],