fpdb/pyfpdb/TableWindow.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Base class for interacting with poker client windows.

There are currently subclasses for X and Windows.

The class queries the poker client window for data of interest, such as
size and location. It also controls the signals to alert the HUD when the
client has been resized, destroyed, etc.
"""
#    Copyright 2008 - 2010, Ray E. Barker

#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

########################################################################

#    Standard Library modules
import re

#    pyGTK modules
import gtk
import gobject

#    FreePokerTools modules
from HandHistoryConverter import getTableTitleRe
from HandHistoryConverter import getTableNoRe

#    Global used for figuring out the current game being played from the title.
#    The dict key is a tuple of (limit type, category) for the game. 
#    The list is the names for those games used by the supported poker sites
#    This is currently only used for mixed games, so it only needs to support those
#    games on PokerStars and Full Tilt.
nlpl_game_names = { #fpdb name      Stars Name   FTP Name (if different)
              ("nl", "holdem"    ) : ("No Limit Hold\'em"  ,                     ),
              ("pl", "holdem"    ) : ("Pot Limit Hold\'em" ,                     ),
              ("pl", "omahahi"   ) : ("Pot Limit Omaha"    ,"Pot Limit Omaha Hi" ),
             }
limit_game_names = { #fpdb name      Stars Name   FTP Name
              ("fl", "holdem"    ) : ("Limit Hold\'em"  ,          ),
              ("fl", "omahahilo" ) : ("Limit Omaha H/L" ,          ),
              ("fl", "studhilo"  ) : ("Limit Stud H/L"  ,          ),
              ("fl", "razz"      ) : ("Limit Razz"      ,          ),
              ("fl", "studhi"    ) : ("Limit Stud"      , "Stud Hi"),
              ("fl", "27_3draw"  ) : ("Limit Triple Draw 2-7 Lowball",          )
             }

#    A window title might have our table name + one of these words/
#    phrases. If it has this word in the title, it is not a table.
bad_words = ('History for table:', 'HUD:', 'Chat:', 'FPDBHUD', 'Instant Replay')

#    Here are the custom signals we define for allowing the 'client watcher'
#    thread to communicate with the gui thread. Any time a poker client is
#    is moved, resized, or closed on of these signals is emitted to the
#    HUD main window.
gobject.signal_new("client_moved", gtk.Window,
                   gobject.SIGNAL_RUN_LAST,
                   gobject.TYPE_NONE,
                   (gobject.TYPE_PYOBJECT,))

gobject.signal_new("client_resized", gtk.Window,
                   gobject.SIGNAL_RUN_LAST,
                   gobject.TYPE_NONE,
                   (gobject.TYPE_PYOBJECT,))

gobject.signal_new("client_destroyed", gtk.Window,
                   gobject.SIGNAL_RUN_LAST,
                   gobject.TYPE_NONE,
                   (gobject.TYPE_PYOBJECT,))

gobject.signal_new("game_changed", gtk.Window,
                   gobject.SIGNAL_RUN_LAST,
                   gobject.TYPE_NONE,
                   (gobject.TYPE_PYOBJECT,))

gobject.signal_new("table_changed", gtk.Window,
                   gobject.SIGNAL_RUN_LAST,
                   gobject.TYPE_NONE,
                   (gobject.TYPE_PYOBJECT,))

#    Each TableWindow object must have the following attributes correctly populated:
#    tw.name = the table name from the title bar, which must to match the table name
#              from the corresponding hand record in the db.
#    tw.number = This is the system id number for the client table window in the
#                format that the system presents it.  This is Xid in Xwindows and
#                hwnd in Microsoft Windows.
#    tw.title = The full title from the window title bar.
#    tw.width, tw.height = The width and height of the window in pixels.  This is
#            the internal width and height, not including the title bar and
#            window borders.
#    tw.x, tw.y = The x, y (horizontal, vertical) location of the window relative
#            to the top left of the display screen.  This also does not include the
#            title bar and window borders.  To put it another way, this is the
#            screen location of (0, 0) in the working window.
#    tournament = Tournament number for a tournament or None for a cash game.
#    tw.table = tournament: Table number for the tournament.
#               cash: full Table name as given by the poker site
#    tw.gdkhandle = gdk handle for the poker client window - used to nail the hud to the window 
#    tw.window = is this still used?
#    tw.parent = window object of the parent of the client window, only used in Linux 
#    tw.game = the poker game being played at the table, only used in mixed games 
#    tw.search_string = regular expression used to find the table, supplied by XToFpdb.py
#    tw.key = a string formulated to be a unique id for this table window, used in the hud main window

class Table_Window(object):
    def __init__(self, config, site, table_name = None, tournament = None, table_number = None):

        self.config = config
        self.site = site
        self.hud = None   # fill in later
        if tournament is not None and table_number is not None:
            self.tournament = int(tournament)
            self.table = int(table_number)
            self.name = "%s - %s" % (self.tournament, self.table)
            self.type = "tour"
            table_kwargs = dict(tournament = self.tournament, table_number = self.table)
            self.tableno_re = getTableNoRe(self.config, self.site, tournament = self.tournament)
            self.key = "%s Table %s" % (tournament, str(self.table))
        elif table_name is not None:
            self.name = table_name
            self.type = "cash"
            self.tournament = None
            table_kwargs = dict(table_name = table_name)
            self.key = table_name  # used as key for the hud_dict in HUD_main

        else:
            return None

        self.search_string = getTableTitleRe(self.config, self.site, self.type, **table_kwargs)
        self.find_table_parameters()

#        self.gdkhandle = gtk.gdk.window_foreign_new(self.number)
        geo = self.get_geometry()
        if geo is None:  return None
        self.width  = geo['width']
        self.height = geo['height']
        self.x      = geo['x']
        self.y      = geo['y']
        self.oldx   = self.x # attn ray: remove these two lines and update Hud.py::update_table_position()
        self.oldy   = self.y

        self.game = self.get_game()

    def __str__(self):
#    __str__ method for testing
        likely_attrs = ("number", "title", "site", "width", "height", "x", "y",
                        "tournament", "table", "gdkhandle", "window", "parent",
                        "key", "hud", "game", "search_string", "tableno_re")
        temp = 'TableWindow object\n'
        for a in likely_attrs:
            if getattr(self, a, 0):
                temp += "    %s = %s\n" % (a, getattr(self, a))
        return temp

####################################################################
#    "get" methods. These query the table and return the info to get.
#    They don't change the data in the table and are generally used
#    by the "check" methods. Most of the get methods are in the 
#    subclass because they are specific to X, Windows, etc.
    def get_game(self):
#        title = self.get_window_title()
#        if title is None:
#            return False
        title = self.title

#    check for nl and pl games first, to avoid bad matches
        for game, names in nlpl_game_names.iteritems():
            for name in names:
                if name in title:
                    return game
        for game, names in limit_game_names.iteritems():
            for name in names:
                if name in title:
                    return game
        return False

    def get_table_no(self):
        new_title = self.get_window_title()
        if new_title is None:
            return False

        try:
            mo = re.search(self.tableno_re, new_title)
        except AttributeError: #'Table' object has no attribute 'tableno_re'
            return False
              
        if mo is not None:
            #print "get_table_no: mo=",mo.groups()
            return int(mo.group(1))
        return False

####################################################################
#    check_table() is meant to be called by the hud periodically to
#    determine if the client has been moved or resized. check_table()
#    also checks and signals if the client has been closed. 
    def check_table(self, hud):
        result = self.check_size()
        if result != False:
            hud.parent.main_window.emit(result, hud)
            if result == "client_destroyed":
                return True

        result = self.check_loc()
        if result != False:
            hud.parent.main_window.emit(result, hud)
            if result == "client_destroyed":
                return True
        return True

####################################################################
#    "check" methods. They use the corresponding get method, update the
#    table object and return the name of the signal to be emitted or 
#    False if unchanged. These do not signal for destroyed
#    clients to prevent a race condition.

#    These might be called by a Window.timeout, so they must not
#    return False, or the timeout will be cancelled.
    def check_game(self, hud):
        new_game = self.get_game()
        if new_game is not None and self.game != new_game:
            self.game = new_game
            hud.main_window.emit("game_changed", hud)
            return "game_changed"
        return True

    def check_size(self):
        new_geo = self.get_geometry()
        if new_geo is None:   # window destroyed
            return "client_destroyed"

        elif  self.width  != new_geo['width'] or self.height != new_geo['height']:    # window resized
            self.oldwidth = self.width
            self.width  = new_geo['width']
            self.oldheight = self.height
            self.height = new_geo['height']
            return "client_resized"
        return False  # no change

    def check_loc(self):
        new_geo = self.get_geometry()        
        if new_geo is None:   # window destroyed
            return "client_destroyed"

        if self.x != new_geo['x'] or self.y != new_geo['y']: # window moved
#            print self.x, self.y, new_geo['x'], new_geo['y']
            self.x      = new_geo['x']
            self.y      = new_geo['y']
            return "client_moved"
        return False  # no change

    def check_table_no(self, hud):
        result = self.get_table_no()
        if result != False and result != self.table:
            self.table = result
            if hud is not None:
                hud.parent.main_window.emit("table_changed", hud)
        return True

    def check_bad_words(self, title):
        for word in bad_words:
            if word in title: return True
        return False