def createGame(self, rows=8, reserves=8, playcards=7):
        # create layout
        l, s = Layout(self), self.s

        # set window
        max_rows = max(rows, reserves)
        w, h = l.XM + max_rows*l.XS, l.YM + 2*l.YS + (12+playcards)*l.YOFFSET
        self.setSize(w, h)

        # create stacks
        x, y = l.XM + (max_rows-rows)*l.XS//2, l.YM
        for i in range(rows):
            stack = self.RowStack_Class(x, y, self, base_rank=ANY_RANK)
            stack.getBottomImage = stack._getReserveBottomImage
            s.rows.append(stack)
            x += l.XS
        x, y = l.XM + (max_rows-reserves)*l.XS//2, l.YM+l.YS+12*l.YOFFSET
        for i in range(reserves):
            stack = OpenStack(x, y, self, max_accept=0)
            s.reserves.append(stack)
            stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
            x += l.XS

        s.talon = InitialDealTalonStack(l.XM, l.YM, self)

        # default
        l.defaultAll()

    def createGame(self):
        lay, s = Layout(self), self.s
        self.setSize(lay.XM+8*lay.XS, lay.YM+2*lay.YS+12*lay.YOFFSET)

        x, y = lay.XM, lay.YM
        for i in range(4):
            s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
            s.foundations.append(SS_FoundationStack(x+4*lay.XS, y, self,
                                 suit=i,
                                 base_rank=KING, dir=-1))
            x += lay.XS
        x, y = lay.XM, lay.YM+lay.YS
        s.talon = WasteTalonStack(x, y, self, max_rounds=UNLIMITED_REDEALS,
                                  num_deal=3)
        lay.createText(s.talon, 'ne')
        y += lay.YS
        s.waste = WasteStack(x, y, self)
        lay.createText(s.waste, 'ne')
        x, y = lay.XM+2*lay.XS, lay.YM+lay.YS
        for i in range(4):
            s.rows.append(AC_RowStack(x, y, self, base_rank=6))
            x += lay.XS
        x += lay.XS
        stack = OpenStack(x, y, self)
        s.reserves.append(stack)
        stack.CARD_YOFFSET = lay.YOFFSET

        lay.defaultStackGroups()

 def _position(self, card):
     OpenStack._position(self, card)
     #
     if TOOLKIT == 'tk':
         rows = [s for s in self.game.s.rows[:self.id] if s.cards]
         if rows:
             self.group.tkraise(rows[-1].group)
             return
         rows = [s for s in self.game.s.rows[self.id+1:] if s.cards]
         if rows:
             self.group.lower(rows[0].group)
             return
     elif TOOLKIT == 'kivy':
         rows = [s for s in self.game.s.rows[:self.id] if s.cards]
         if rows:
             # self.group.tkraise(rows[-1].group)
             return
         rows = [s for s in self.game.s.rows[self.id+1:] if s.cards]
         if rows:
             # self.group.lower(rows[0].group)
             return
     elif TOOLKIT == 'gtk':
         # FIXME (this is very slow)
         for s in self.game.s.rows[self.id+1:]:
             s.group.tkraise()

    def createGame(self):
        # create layout
        l, s = Layout(self), self.s

        # set window
        self.setSize(l.XM + 8*l.XS, l.YM + 2*l.YS+16*l.YOFFSET)

        # create stacks
        x, y, = l.XM, l.YM
        for i in range(8):
            if self.Foundation_Class is RK_FoundationStack:
                suit = ANY_SUIT
            else:
                suit = int(i//2)
            s.foundations.append(self.Foundation_Class(x, y, self,
                                 suit=suit, max_move=0))
            x += l.XS
        x, y = l.XM, l.YM+l.YS
        stack = OpenStack(x, y, self, max_accept=0)
        stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
        s.reserves.append(stack)
        x += l.XS
        s.talon = WasteTalonStack(x, y, self, max_rounds=1)
        l.createText(s.talon, "s")
        x += l.XS
        s.waste = WasteStack(x, y, self, max_cards=1)
        x += l.XS
        for i in range(5):
            stack = Numerica_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS)
            # stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
            s.rows.append(stack)
            x = x + l.XS

        # define stack-groups
        l.defaultStackGroups()

 def __init__(self, x, y, game, yoffset=-1, **cap):
     kwdefault(
         cap, max_move=UNLIMITED_MOVES,
         max_accept=UNLIMITED_ACCEPTS, dir=-1)
     OpenStack.__init__(self, x, y, game, **cap)
     if yoffset < 0:
         yoffset = game.app.images.CARD_YOFFSET
     self.CARD_YOFFSET = yoffset

 def moveMove(self, ncards, to_stack, frames=-1, shadow=-1):
     OpenStack.moveMove(self, ncards, to_stack, frames, shadow)
     if self.game.base_rank is None and to_stack in self.game.s.foundations:
         old_state = self.game.enterState(self.game.S_FILL)
         self.game.saveStateMove(2 | 16)            # for undo
         self.game.base_rank = to_stack.cards[-1].rank
         self.game.saveStateMove(1 | 16)            # for redo
         self.game.leaveState(old_state)

 def __init__(self, x, y, game):
     OpenStack.__init__(self, x, y, game)
     self.CARD_YOFFSET = self.game.app.images.CARD_YOFFSET
     # use a sine wave for the x offsets
     self.CARD_XOFFSET = []
     j = 1
     for i in range(20):
         self.CARD_XOFFSET.append(int(math.sin(j) * 20))
         j = j + .9

 def __init__(self, x, y, game, xoffset, yoffset):
     OpenStack.__init__(self, x, y, game)
     self.CARD_YOFFSET = int(self.game.app.images.CARD_YOFFSET * yoffset)
     # use a sine wave for the x offsets
     self.CARD_XOFFSET = []
     j = 1
     for i in range(30):
         self.CARD_XOFFSET.append(int(math.cos(j) * xoffset))
         j = j + .9

 def __init__(self, x, y, game, yoffset):
     OpenStack.__init__(self, x, y, game)
     self.CARD_YOFFSET = int(self.game.app.images.CARD_YOFFSET * yoffset)
     # use a sine wave for the x offsets
     # compensate for card width
     offset = self.game.app.images.CARDW / 1.7
     self.CARD_XOFFSET = []
     j = 1
     for i in range(20):
         self.CARD_XOFFSET.append(int(math.sin(j) * offset))
         j = j + .9

    def _position(self, card):
        # AbstractFoundationStack._position(self, card)
        OpenStack._position(self, card)

        fnds = self.game.s.foundations

        cols = (3, 2, 1, 0)
        for i in cols:
            for j in range(9):
                n = i*9+j
                if fnds[n].cards:
                    fnds[n].group.tkraise()
        return

    def createGame(self, rows=1, reserves=8, playcards=3):
        # create layout
        l, s = Layout(self), self.s

        # set window
        w, h = l.XM+8*l.XS, l.YM+3.5*l.YS+playcards*l.YOFFSET
        h += l.TEXT_HEIGHT
        self.setSize(w, h)

        # create stacks
        x, y, = l.XM, l.YM
        for i in range(4):
            s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
                                                    max_move=0))
            x += l.XS
        for i in range(4):
            s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
                                 max_move=0, base_rank=KING, dir=-1))
            x += l.XS
        x, y, = l.XM+(8-reserves)*l.XS//2, y+l.YS
        for i in range(reserves):
            stack = OpenStack(x, y, self, max_accept=0)
            stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
            s.reserves.append(stack)
            x += l.XS
        x, y = l.XM+(8-1-rows)*l.XS//2, self.height-l.YS
        s.talon = Alhambra_Talon(x, y, self, max_rounds=3)
        if rows == 1:
            l.createText(s.talon, 'sw')
        else:
            l.createText(s.talon, 'n')
        anchor = 'nn'
        if rows > 1:
            anchor = 'nnn'
        l.createRoundText(s.talon, anchor)

        x += l.XS
        for i in range(rows):
            stack = self.RowStack_Class(x, y, self, mod=13, max_accept=1)
            stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
            s.rows.append(stack)
            x += l.XS
            if rows == 1:
                l.createText(stack, 'se')
            else:
                l.createText(stack, 'n')

        # define stack-groups (non default)
        l.defaultStackGroups()

 def canFlipCard(self):
     if not OpenStack.canFlipCard(self):
         return False
     for r in self.game.s.reserves:
         if len(r.cards) > 2:
             return False
     return True

 def __init__(self, x, y, game, sine=0):
     OpenStack.__init__(self, x, y, game)
     self.CARD_YOFFSET = self.game.app.images.CARD_YOFFSET
     CW = self.game.app.images.CARDW
     if sine:
         # use a sine wave for the x offsets
         self.CARD_XOFFSET = []
         n = 9
         dx = 0.4 * CW * (2*math.pi/n)
         last_x = 0
         for i in range(n):
             x = int(round(dx * math.sin(i + 1)))
             # print x, x - last_x
             self.CARD_XOFFSET.append(x - last_x)
             last_x = x
     else:
         self.CARD_XOFFSET = (-0.45*CW, 0.35*CW, 0.55*CW, -0.45*CW)

 def acceptsCards(self, from_stack, cards):
     if not OpenStack.acceptsCards(self, from_stack, cards):
         return False
     # check the rank
     if self.cards[-1].rank != cards[0].rank:
         return False
     # now look if the stacks are neighbours
     return self.game.isNeighbour(from_stack, self)

 def clickHandler(self, event):
     result = OpenStack.doubleclickHandler(self, event)
     if result == 1 and not self.game.score_counted:
         self.game.sequence += 1
         self.game.computeHandScore()
         self.game.updateText()
     elif self.game.score_counted:
         self.game.score_counted = False
     return result

    def createGame(self):
        # create layout
        l, s = Layout(self), self.s

        # set window
        # (set size so that at least 13 cards are fully playable)
        w = max(3*l.XS, l.XS+13*l.XOFFSET)
        self.setSize(l.XM+2*w+2*l.XS, l.YM + 5*l.YS + l.TEXT_HEIGHT)

        # create stacks
        x, y = l.XM, l.YM+4*l.YS
        s.talon = InitialDealTalonStack(x, y, self)
        x, y = l.XM+w-l.XS, self.height-l.YS
        for i in range(4):
            stack = OpenStack(x, y, self, max_accept=0)
            s.reserves.append(stack)
            l.createText(stack, 'n')
            x += l.XS

        x = l.XM + w
        for x in (l.XM + w, l.XM + w + l.XS):
            y = l.YM
            for i in range(4):
                s.foundations.append(RK_FoundationStack(x, y, self,
                                     max_move=0))
                y += l.YS

        for x in (l.XM, l.XM + w + 2*l.XS):
            y = l.YM
            for i in range(4):
                stack = RK_RowStack(
                    x, y, self, max_move=1, max_accept=1, base_rank=ANY_RANK)
                stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
                s.rows.append(stack)
                y += l.YS
        l.setRegion(s.rows[:4], (-999, -999, w-l.CW//2, l.YM+4*l.YS-l.CH//2))

        # define stack-groups
        l.defaultStackGroups()
        # set regions
        l.defaultRegions()

 def canFlipCard(self):
     if not OpenStack.canFlipCard(self):
         return False
     for s in self.game.s.rows:
         if not s.cards:
             break
     else:
         return False
     i = list(self.game.s.reserves).index(self)
     if i == 0:
         return True
     if self.game.s.reserves[i-1].cards:
         return False
     return True

 def acceptsCards(self, from_stack, cards):
     if not OpenStack.acceptsCards(self, from_stack, cards):
         return False
     if not self.cards:
         return True
     if cards[0].suit != self.cards[0].suit:
         return False
     if len(self.cards) == 1:
         card_dir = cards[0].rank - self.cards[-1].rank
         return card_dir == 1 or card_dir == -1
     else:
         stack_dir = (self.cards[1].rank - self.cards[0].rank) % \
             self.cap.mod
         return (self.cards[-1].rank + stack_dir) % \
             self.cap.mod == cards[0].rank

 def __init__(self, x, y, game):
     OpenStack.__init__(self, x, y, game, max_move=0, max_accept=1)
     self.CARD_YOFFSET = 1

 def clickHandler(self, event):
     return OpenStack.clickHandler(self, event)