[Winopenrpg-developer] openrpg1/orpg __init__.py,NONE,1.1 main.py,NONE,1.1 minidom.py,NONE,1.1 orpg_version.py,NONE,1.1 orpg_windows.py,NONE,1.1 orpg_wx.py,NONE,1.1 orpg_xml.py,NONE,1.1 player_list.py,NONE,1.1 plugindb.py,NONE,1.1 pluginhandler.py,NONE,1.1 plugins.py,NONE,1.1 pulldom.py,NONE,1.1 systempath.py,NONE,1.1 xmltramp.py,NONE,1.1

[Digital X. <dig...@us...>]

Update of /cvsroot/winopenrpg/openrpg1/orpg
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30930/orpg

Added Files:
	__init__.py main.py minidom.py orpg_version.py orpg_windows.py 
	orpg_wx.py orpg_xml.py player_list.py plugindb.py 
	pluginhandler.py plugins.py pulldom.py systempath.py 
	xmltramp.py 
Log Message:
Initial commit of OpenRPG++ python

--- NEW FILE: systempath.py ---
import sys
if sys.platform != 'win32':
    sys.path.append( "/usr/local/lib/python2.2/site-packages/" )
    sys.path.append( "/usr/lib/python2.2/site-packages/" )

--- NEW FILE: plugindb.py ---
import xmltramp
import orpg.dirpath

class PluginDB:
    def __init__(self, filename="plugindb.xml"):
        self.filename = orpg.dirpath.dir_struct["user"] + filename
        orpg.tools.config_files.validate_config_file(filename,"default_plugindb.xml")
        self.xml_dom = self.LoadDoc()

    def GetString(self, plugname, strname, defaultval, verbose=0):
        strname = self.safe(strname)
        for plugin in self.xml_dom:
            if plugname == plugin._name:
                for child in plugin._dir:
                    if child._name == strname:
                        #str() on this to make sure it's ASCII, not unicode, since orpg can't handle unicode.
                        if verbose:
                            print "successfully found the value"
                        if len(child):
                            return str( self.normal(child[0]) )
                        else:
                            return ""
        else:
            if verbose:
                print "plugindb: no value has been stored for " + strname + " in " + plugname + " so the default has been returned"
            return defaultval

    def SetString(self, plugname, strname, val):
        val = self.safe(val)
        strname = self.safe(strname)
        for plugin in self.xml_dom:##this isn't absolutely necessary, but it saves the trouble of sending a parsed object instead of a simple string.
            if plugname == plugin._name:
                plugin[strname] = val
                plugin[strname]._attrs["type"] = "string"
                self.SaveDoc()
                return "found plugin"
        else:
            self.xml_dom[plugname] = xmltramp.parse("<" + strname + " type=\"string\">" + val + "</" + strname + ">")
            self.SaveDoc()
            return "added plugin"

    def FetchList(self, parent):
        retlist = []
        if not len(parent):
            return []
        for litem in parent[0]._dir:
            if len(litem):
                if litem._attrs["type"] == "int":
                    retlist += [int(litem[0])]
                elif litem._attrs["type"] == "long":
                    retlist += [long(litem[0])]
                elif litem._attrs["type"] == "float":
                    retlist += [float(litem[0])]
                elif litem._attrs["type"] == "list":
                    retlist += [self.FetchList(litem)]
                elif litem._attrs["type"] == "dict":
                    retlist += [self.FetchDict(litem)]
                else:
                    retlist += [str( self.normal(litem[0]) )]
            else:
                retlist += [""]
        return retlist

    def GetList(self, plugname, listname, defaultval, verbose=0):
        listname = self.safe(listname)
        for plugin in self.xml_dom:
            if plugname == plugin._name:
                for child in plugin._dir:
                    if child._name == listname and child._attrs["type"] == "list":
                        retlist = self.FetchList(child)
                        if verbose:
                            print "successfully found the value"
                        return retlist
        else:
            if verbose:
                print "plugindb: no value has been stored for " + listname + " in " + plugname + " so the default has been returned"
            return defaultval

    def BuildList(self, val):
        listerine = "<list>"
        for item in val:
            if type(item) == type(""):#it's a string
                listerine += "<lobject type=\"str\">" + self.safe(item) + "</lobject>"
            elif type(item) == type(0):#it's an int
                listerine += "<lobject type=\"int\">" + str(item) + "</lobject>"
            elif type(item) == type(0.0):#it's a float
                listerine += "<lobject type=\"float\">" + str(item) + "</lobject>"
            elif type(item) == type(255*255*255*255):#it's a long
                listerine += "<lobject type=\"long\">" + str(item) + "</lobject>"
            elif type(item) == type([]):#it's a list
                listerine += "<lobject type=\"list\">" + self.BuildList(item) + "</lobject>"
            elif type(item) == type({}):#it's a dictionary
                listerine += "<lobject type=\"dict\">" + self.BuildDict(item) + "</lobject>"
            else:
                return "type unknown"
        listerine += "</list>"
        return listerine

    def SetList(self, plugname, listname, val):
        listname = self.safe(listname)
        list = xmltramp.parse(self.BuildList(val))
        for plugin in self.xml_dom:
            if plugname == plugin._name:
                plugin[listname] = list
                plugin[listname]._attrs["type"] = "list"
                self.SaveDoc()
                return "found plugin"
        else:
            self.xml_dom[plugname] = xmltramp.parse("<" + listname + "></" + listname + ">")
            self.xml_dom[plugname][listname] = list
            self.xml_dom[plugname][listname]._attrs["type"] = "list"
            self.SaveDoc()
            return "added plugin"

    def BuildDict(self, val):
        dictator = "<dict>"
        for item in val.keys():
            if type(val[item]) == type(""):
                dictator += "<dobject name=\"" + self.safe(item) + "\" type=\"str\">" + self.safe(val[item]) + "</dobject>"
            elif type(val[item]) == type(0):#it's an int
                dictator += "<dobject name=\"" + self.safe(item) + "\" type=\"int\">" + str(val[item]) + "</dobject>"
            elif type(val[item]) == type(0.1):#it's a float
                dictator += "<dobject name=\"" + self.safe(item) + "\" type=\"float\">" + str(val[item]) + "</dobject>"
            elif type(val[item]) == type(255*255*255*255):#it's a long
                dictator += "<dobject name=\"" + self.safe(item) + "\" type=\"long\">" + str(val[item]) + "</dobject>"
            elif type(val[item]) == type({}):#it's a dictionary
                dictator += "<dobject name=\"" + self.safe(item) + "\" type=\"dict\">" + self.BuildDict(val[item]) + "</dobject>"
            elif type(val[item]) == type([]):#it's a list
                dictator += "<dobject name=\"" + self.safe(item) + "\" type=\"list\">" + self.BuildList(val[item]) + "</dobject>"
            else:
                return str(val[item]) + ": type unknown"
        dictator += "</dict>"
        return dictator

    def SetDict(self, plugname, dictname, val, file="plugindb.xml"):
        dictname = self.safe(dictname)
        dict = xmltramp.parse(self.BuildDict(val))
        for plugin in self.xml_dom:
            if plugname == plugin._name:
                plugin[dictname] = dict
                plugin[dictname]._attrs["type"] = "dict"
                self.SaveDoc()
                return "found plugin"
        else:
            self.xml_dom[plugname] = xmltramp.parse("<" + dictname + "></" + dictname + ">")
            self.xml_dom[plugname][dictname] = dict
            self.xml_dom[plugname][dictname]._attrs["type"] = "dict"
            self.SaveDoc()
            return "added plugin"

    def FetchDict(self, parent):
        retdict = {}
        if not len(parent):
            return {}
        for ditem in parent[0]._dir:
            if len(ditem):
                ditem._attrs["name"] = self.normal(ditem._attrs["name"])
                if ditem._attrs["type"] == "int":
                    retdict[ditem._attrs["name"]] = int(ditem[0])
                elif ditem._attrs["type"] == "long":
                    retdict[ditem._attrs["name"]] = long(ditem[0])
                elif ditem._attrs["type"] == "float":
                    retdict[ditem._attrs["name"]] = float(ditem[0])
                elif ditem._attrs["type"] == "list":
                    retdict[ditem._attrs["name"]] = self.FetchList(ditem)
                elif ditem._attrs["type"] == "dict":
                    retdict[ditem._attrs["name"]] = self.FetchDict(ditem)
                else:
                    retdict[ditem._attrs["name"]] = str( self.normal(ditem[0]) )
            else:
                retdict[ditem._attrs["name"]] = ""
        return retdict

    def GetDict(self, plugname, dictname, defaultval, verbose=0):
        dictname = self.safe(dictname)
        for plugin in self.xml_dom:
            if plugname == plugin._name:
                for child in plugin._dir:
                    if child._name == dictname and child._attrs["type"] == "dict":
                        return self.FetchDict(child)
        else:
            if verbose:
                print "plugindb: no value has been stored for " + dictname + " in " + plugname + " so the default has been returned"
            return defaultval

    def safe(self, string):
        return string.replace("<", "$$lt$$").replace(">", "$$gt$$").replace("&","$$amp$$").replace('"',"$$quote$$")

    def normal(self, string):
        return string.replace("$$lt$$", "<").replace("$$gt$$", ">").replace("$$amp$$","&").replace("$$quote$$",'"')

    def SaveDoc(self):
        f = open(self.filename, "w")
        f.write(self.xml_dom.__repr__(1, 1))
        f.close()

    def LoadDoc(self):
        xml_file = open(self.filename)
        plugindb = xml_file.read()
        xml_file.close()
        return xmltramp.parse(plugindb)

--- NEW FILE: player_list.py ---
#!/usr/bin/env python
# Copyright (C) 2000-2001 The OpenRPG Project
#
#   ope...@li...
#
# 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., 675 Mass Ave, Cambridge, MA 02139, USA.
# --
#
# File: player_list.py
# Author: Chris Davis
# Maintainer:
# Version:
#   $Id: player_list.py,v 1.1 2006/01/26 17:33:15 digitalxero Exp $
#
# Description: This is the main entry point of the oprg application
#

__version__ = "$Id: player_list.py,v 1.1 2006/01/26 17:33:15 digitalxero Exp $"

from orpg.orpg_windows import *
import orpg.dirpath


# global definitions
global ROLE_GM; ROLE_GM = "GM"
global ROLE_PLAYER; ROLE_PLAYER = "PLAYER"
global ROLE_LURKER; ROLE_LURKER = "LURKER"


#########################
#player frame window
#########################
PLAYER_BOOT = wxNewId()
PLAYER_WHISPER = wxNewId()
PLAYER_IGNORE = wxNewId()
PLAYER_ROLE_MENU = wxNewId()
PLAYER_ROLE_LURKER = wxNewId()
PLAYER_ROLE_PLAYER = wxNewId()
PLAYER_ROLE_GM = wxNewId()
PLAYER_MODERATE_MENU = wxNewId()
PLAYER_MODERATE_ROOM_ON = wxNewId()
PLAYER_MODERATE_ROOM_OFF = wxNewId()
PLAYER_MODERATE_GIVE_VOICE = wxNewId()
PLAYER_MODERATE_TAKE_VOICE = wxNewId()
PLAYER_SHOW_VERSION = wxNewId()


WG_LIST = {}

#---------------------------------------------------------
# [START] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
PLAYER_WG_MENU = wxNewId()
PLAYER_WG_CREATE = wxNewId()
PLAYER_WG_CLEAR_ALL = wxNewId()
WG_MENU_LIST = {}
#---------------------------------------------------------
# [END] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------

#---------------------------------------------------------
# [START] Snowdog Password/Room Name altering code 12/02
#---------------------------------------------------------

PLAYER_COMMAND_MENU = wxNewId()
PLAYER_COMMAND_PASSWORD_ALTER = wxNewId()
PLAYER_COMMAND_ROOM_RENAME = wxNewId()

#---------------------------------------------------------
# [END] Snowdog Password/Room Name altering code 12/02
#---------------------------------------------------------


class player_list(wxListCtrl):
    def __init__( self, parent, openrpg ):
##        wxListCtrl.__init__( self, parent, -1, wxDefaultPosition, wxDefaultSize, wxLC_REPORT|wxSUNKEN_BORDER|wxEXPAND )
        wxListCtrl.__init__( self, parent, -1, wxDefaultPosition, wxDefaultSize, wxLC_REPORT|wxSUNKEN_BORDER|wxEXPAND|wxLC_HRULES )

        self.myopenrpg = openrpg
        self.session = self.myopenrpg.get_component("session")
        self.settings = self.myopenrpg.get_component('settings')
        self.chat = self.myopenrpg.get_component('chat')
        self.password_manager = self.myopenrpg.get_component("password_manager")
        # Create in image list -- for whatever reason...guess it will be nice when we can tell which is a bot
        self.whisperCount = 0
        self._imageList = wxImageList( 16, 16, false )
        img = wxImage(orpg.dirpath.dir_struct["icon"]+"player.gif", wxBITMAP_TYPE_GIF).ConvertToBitmap()
        self._imageList.Add( img )
        img = wxImage(orpg.dirpath.dir_struct["icon"]+"player-whisper.gif", wxBITMAP_TYPE_GIF).ConvertToBitmap()
        self._imageList.Add( img )
        self.SetImageList( self._imageList, wxIMAGE_LIST_SMALL )

        # Create our column headers
        self.InsertColumn( 0, "ID" )
        self.InsertColumn( 1, "Player" )
        self.InsertColumn( 2, "Status" )
#---------------------------------------------------------
# [START] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
        ##Main Menu
        self.wgMenu = wxMenu()

        #Add the Base Menu items, so they are always at the bottom
        self.wgMenu.Append(PLAYER_WG_CREATE, "Create")
        self.wgMenu.Append(PLAYER_WG_CLEAR_ALL, "Delete All Groups")


#---------------------------------------------------------
# [END] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------

        # Create the role menu
        self.roleMenu = wxMenu()
        self.roleMenu.SetTitle( "Assign Role" )
        self.roleMenu.Append( PLAYER_ROLE_LURKER, "Lurker" )
        self.roleMenu.Append( PLAYER_ROLE_PLAYER, "Player" )
        self.roleMenu.Append( PLAYER_ROLE_GM, "GM" )

        # Create the moderation menu
        self.moderateMenu = wxMenu()
        self.moderateMenu.SetTitle( "Moderate" )
        self.moderateMenu.Append( PLAYER_MODERATE_ROOM_ON, "Room Moderation ON" )
        self.moderateMenu.Append( PLAYER_MODERATE_ROOM_OFF, "Room Moderation OFF" )
        self.moderateMenu.AppendSeparator()
        self.moderateMenu.Append( PLAYER_MODERATE_GIVE_VOICE, "Give Voice" )
        self.moderateMenu.Append( PLAYER_MODERATE_TAKE_VOICE, "Take Voice" )

#---------------------------------------------------------
# [START] Snowdog Password/Room Name altering code 12/02
#---------------------------------------------------------


        # Create the room control menu
        self.commandMenu = wxMenu()
        self.commandMenu.SetTitle( "Room Controls" )
        self.commandMenu.Append( PLAYER_COMMAND_PASSWORD_ALTER, "Password" )
        self.commandMenu.Append( PLAYER_COMMAND_ROOM_RENAME, "Room Name" )
        self.commandMenu.AppendSeparator()

#---------------------------------------------------------
# [END] Snowdog Password/Room Name altering code 12/02
#---------------------------------------------------------

        # Create the pop up menu
        self.menu = wxMenu()
        self.menu.SetTitle( "Player Menu" )
        self.menu.Append( PLAYER_BOOT, "Boot" )
        self.menu.AppendSeparator()
        self.menu.Append( PLAYER_IGNORE, "Toggle &Ignore" )
        self.menu.AppendSeparator()
        self.menu.Append( PLAYER_WHISPER, "Whisper" )
#---------------------------------------------------------
# [START] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
        self.menu.AppendMenu(PLAYER_WG_MENU, "Whisper Groups", self.wgMenu)
#---------------------------------------------------------
# [END] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
        self.menu.AppendSeparator()
        self.menu.AppendMenu( PLAYER_MODERATE_MENU, "Moderate", self.moderateMenu )
        self.menu.AppendMenu( PLAYER_COMMAND_MENU, "Room Control", self.commandMenu )
        self.menu.AppendSeparator()
        self.menu.AppendMenu( PLAYER_ROLE_MENU, "Assign Role", self.roleMenu )
        self.menu.AppendSeparator()
        self.menu.Append( PLAYER_SHOW_VERSION, "Version" )

        # Event processing for our menu
        EVT_MENU( self, PLAYER_BOOT, self.on_menu_item )
        EVT_MENU( self, PLAYER_IGNORE, self.on_menu_item )
        EVT_MENU( self, PLAYER_WHISPER, self.on_menu_item )
        EVT_MENU( self, PLAYER_MODERATE_ROOM_ON, self.on_menu_moderate )
        EVT_MENU( self, PLAYER_MODERATE_ROOM_OFF, self.on_menu_moderate )
        EVT_MENU( self, PLAYER_MODERATE_GIVE_VOICE, self.on_menu_moderate )
        EVT_MENU( self, PLAYER_MODERATE_TAKE_VOICE, self.on_menu_moderate )
        EVT_MENU( self, PLAYER_ROLE_LURKER, self.on_menu_role_change )
        EVT_MENU( self, PLAYER_ROLE_PLAYER, self.on_menu_role_change )
        EVT_MENU( self, PLAYER_ROLE_GM, self.on_menu_role_change )
        EVT_MENU( self, PLAYER_SHOW_VERSION, self.on_menu_item )
#---------------------------------------------------------
# [START] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
        EVT_MENU( self, PLAYER_WG_CREATE, self.on_menu_whispergroup )
        EVT_MENU( self, PLAYER_WG_CLEAR_ALL, self.on_menu_whispergroup )
#---------------------------------------------------------
# [END] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
#---------------------------------------------------------
# [START] Snowdog Password/Room Name altering code 12/02
#---------------------------------------------------------
        EVT_MENU( self, PLAYER_COMMAND_PASSWORD_ALTER, self.on_menu_password )
        EVT_MENU( self, PLAYER_COMMAND_ROOM_RENAME, self.on_menu_room_rename )
#---------------------------------------------------------
# [END] Snowdog Password/Room Name altering code 12/02
#---------------------------------------------------------
        EVT_LEFT_DCLICK(self,self.on_d_lclick)
        EVT_RIGHT_DOWN( self, self.on_menu )
        self.sized = 1

#---------------------------------------------------------
# [START] Snowdog Password/Room Name altering code 12/02
#
#       Revised 8/03 to add support for password manager
#---------------------------------------------------------


    def on_menu_password( self, evt ):
        id = evt.GetId()
        self.session = self.myopenrpg.get_component("session")
        self.password_manager = self.myopenrpg.get_component("password_manager")
        self.chat = self.myopenrpg.get_component("chat")
        boot_pwd = self.password_manager.GetPassword("admin",int(session.group_id))
        if boot_pwd != None:
            alter_pwd_dialog = wxTextEntryDialog(self,"Enter new room password: (blank for no password)","Alter Room Password")
            if alter_pwd_dialog.ShowModal() == wxID_OK:
                new_pass = alter_pwd_dialog.GetValue()
                self.chat.InfoPost( "Requesting password change on server..." )
                self.session.set_room_pass(new_pass, boot_pwd)


    def on_menu_room_rename( self, evt ):
        id = evt.GetId()
        self.session = self.myopenrpg.get_component("session")
        self.password_manager = self.myopenrpg.get_component("password_manager")
        self.chat = self.myopenrpg.get_component("chat")
        boot_pwd = self.password_manager.GetPassword("admin",int(session.group_id))
        if boot_pwd != None:
            alter_name_dialog = wxTextEntryDialog(self,"Enter new room name: ","Change Room Name")
            if alter_name_dialog.ShowModal() == wxID_OK:
                new_name = alter_name_dialog.GetValue()
                self.chat.InfoPost( "Requesting room name change on server..." )

                loc = new_name.find("&")
                oldloc=0
                while loc > -1:
                    loc = new_name.find("&",oldloc)
                    if loc > -1:
                        b = new_name[:loc]
                        e = new_name[loc+1:]
                        new_name = b + "&amp;" + e
                        oldloc = loc +1

                loc = new_name.find("'")
                oldloc=0
                while loc > -1:
                    loc = new_name.find("'",oldloc)
                    if loc > -1:
                        b = new_name[:loc]
                        e = new_name[loc+1:]
                        new_name = b + "&#39;" + e
                        oldloc = loc +1

                loc = new_name.find('"')
                oldloc=0
                while loc > -1:
                    loc = new_name.find('"',oldloc)
                    if loc > -1:
                        b = new_name[:loc]
                        e = new_name[loc+1:]
                        new_name = b + "&quote" + e
                        oldloc = loc +1

                self.session.set_room_name(new_name, boot_pwd)

#---------------------------------------------------------
# [END] Snowdog Password/Room Name altering code 12/02
#---------------------------------------------------------

#---------------------------------------------------------
# [START] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------

    def clean_sub_menus(self):
        for mid in WG_MENU_LIST:
            try:
                self.wgMenu.Remove(WG_MENU_LIST[mid]["menuid"])
                WG_MENU_LIST[mid]["menu"].Destroy()
            except:
                self.wgMenu.UpdateUI()
        if self.wgMenu.GetMenuItemCount() == 2:
            WG_MENU_LIST.clear()
        return

    def on_menu_whispergroup( self, evt ):
        self.session = self.myopenrpg.get_component("session")
        self.settings = self.myopenrpg.get_component('settings')
        self.chat = self.myopenrpg.get_component('chat')
        "Add/Remove players from Whisper Groups"

        id = evt.GetId()
        item = self.GetItem( self.selected_item )

        #See if it is the main menu
        if id == PLAYER_WG_CREATE:
            create_new_group_dialog = wxTextEntryDialog(self,"Enter Group Name","Create New Whisper Group")
            if create_new_group_dialog.ShowModal() == wxID_OK:
                group_name = create_new_group_dialog.GetValue()
                WG_LIST[group_name] = {}
            return
        elif id == PLAYER_WG_CLEAR_ALL:
            WG_LIST.clear()
            return

        #Check Sub Menus
        for mid in WG_MENU_LIST:
            if id == WG_MENU_LIST[mid]["add"]:
                WG_LIST[mid][int(item.GetText())] = int(item.GetText())
                return
            elif id == WG_MENU_LIST[mid]["remove"]:
                del WG_LIST[mid][int(item.GetText())]
                return
            elif id == WG_MENU_LIST[mid]["clear"]:
                WG_LIST[mid].clear()
                return
            elif id == WG_MENU_LIST[mid]["whisper"]:
                self.chat.set_chat_text("/gw " + mid + "=")
                return

        return

#---------------------------------------------------------
# [END] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------



    def on_menu_moderate( self, evt ):
        "Change the moderated status of a room or player."

        id = evt.GetId()
        self.chat = self.myopenrpg.get_component( "chat" )
        playerID = self.GetItemData( self.selected_item )

        moderationString = None
        moderateRoomBase = "/moderate %s"
        moderatePlayerBase = "/moderate %d=%s"
        infoRoomBase = "Attempting to %s moderation in the current room..."
        infoPlayerBase = "Attempting to %s voice to %s (%d)..."

        if id == PLAYER_MODERATE_ROOM_ON:
            moderationString = (moderateRoomBase % "on")
            infoString = (infoRoomBase % "ENABLE")

        if id == PLAYER_MODERATE_ROOM_OFF:
            moderationString = (moderateRoomBase % "off")
            infoString = (infoRoomBase % "DISABLE")

        elif id == PLAYER_MODERATE_GIVE_VOICE:
            moderationString = (moderatePlayerBase % (playerID, "on"))
            infoString = (infoPlayerBase % ("GIVE", chat.session.get_player_by_player_id( str(playerID) )[0], playerID))

        elif id == PLAYER_MODERATE_TAKE_VOICE:
            moderationString = (moderatePlayerBase % (playerID, "off"))
            infoString = (infoPlayerBase % ("TAKE", chat.session.get_player_by_player_id( str(playerID) )[0], playerID))

        # Now, send it to the server
        if moderationString:
            self.chat.chat_cmds.docmd( moderationString )

            # Now, provide local feedback as to what we requested
            self.chat.InfoPost( infoString )



    def on_menu_role_change( self, evt ):
        self.session = self.myopenrpg.get_component("session")
        "Change the role of the selected id."

        id = evt.GetId()
        self.chat = self.myopenrpg.get_component( "chat" )
        playerID = self.GetItemData( self.selected_item )

        roleString = None
        roleBase = "/role %d=%s"
        infoBase = "Attempting to assign the role of %s to (%d) %s..."

        # Do type specific processing
        if id == PLAYER_ROLE_LURKER:
            roleName = ROLE_LURKER
            roleString = (roleBase % ( playerID, ROLE_LURKER ))

        elif id == PLAYER_ROLE_PLAYER:
            roleName = ROLE_PLAYER
            roleString = (roleBase % ( playerID, ROLE_PLAYER ))

        elif id == PLAYER_ROLE_GM:
            roleName = ROLE_GM
            roleString = (roleBase % ( playerID, ROLE_GM ))

        # Now, send it to the server
        if roleString:
            self.chat.chat_cmds.docmd( roleString )

            # Now, provide local feedback as to what we requested
            displayName = self.session.get_player_by_player_id( str(playerID) )[0]
            infoString = (infoBase % ( roleName, playerID, displayName ))
            self.chat.InfoPost( infoString )

    def on_d_lclick(self,evt):
        pos = wxPoint(evt.GetX(),evt.GetY())
        (item, flag) = self.HitTest(pos)
        id = self.GetItemText(item)
        self.chat = self.myopenrpg.get_component("chat")
        self.chat.set_chat_text("/w " + id + "=")

    def on_menu_item(self,evt):
        id = evt.GetId()
        self.session = self.myopenrpg.get_component("session")
        self.password_manager = self.myopenrpg.get_component("password_manager")

        if id == PLAYER_BOOT:
            id = str(self.GetItemData(self.selected_item))
            boot_pwd = self.password_manager.GetPassword("admin",int(session.group_id))
            if boot_pwd != None:
                self.session.boot_player(id,boot_pwd)

        elif id == PLAYER_WHISPER:
            id = self.GetItemText(self.selected_item)
            self.chat = self.myopenrpg.get_component("chat")
            self.chat.set_chat_text("/w " + id + "=")

        elif id == PLAYER_IGNORE:
            id = str(self.GetItemData(self.selected_item))
            self.chat = self.myopenrpg.get_component("chat")
            (result,id,name) = session.toggle_ignore(id)
            if result == 0:
                  self.chat.Post(chat.colorize(chat.syscolor, "Player " + name + " with ID:" + id +" no longer ignored"))
            else:
                  self.chat.Post(chat.colorize(chat.syscolor, "Player " + name + " with ID:" + id +" now being ignored"))

        elif id == PLAYER_SHOW_VERSION:
            id = str(self.GetItemData(self.selected_item))
            version_string = self.session.players[id][4]
            if version_string:
                wxMessageBox("Running client version " + version_string,"Version")
            else:
                wxMessageBox("No client version available for this player","Version")



    def on_menu(self,evt):
        pos = wxPoint(evt.GetX(),evt.GetY())
        (item, flag) = self.HitTest(pos)
        if item > -1:
            self.selected_item = item

            #  This if-else block makes the menu item to boot players active or inactive, as appropriate
            if 0:     #self.myopenrpg.get_component("session").group_id == "0":
                self.menu.Enable(PLAYER_BOOT,0)
                self.menu.SetLabel(PLAYER_BOOT,"Can't boot from Lobby")
            else:
                self.menu.Enable(PLAYER_BOOT,1)
                self.menu.SetLabel(PLAYER_BOOT,"Boot")
#---------------------------------------------------------
# [START] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
            self.menu.Enable(PLAYER_WG_MENU, true)
            item = self.GetItem( self.selected_item )

            if len(WG_MENU_LIST) > len(WG_LIST):
                self.clean_sub_menus()

            if len(WG_LIST) == 0:
                self.wgMenu.Enable(PLAYER_WG_CLEAR_ALL, false)
            else:
                self.wgMenu.Enable(PLAYER_WG_CLEAR_ALL, true)


            for gid in WG_LIST:
                if not WG_MENU_LIST.has_key(gid):
                    WG_MENU_LIST[gid] = {}
                    WG_MENU_LIST[gid]["menuid"] = wxNewId()
                    WG_MENU_LIST[gid]["whisper"] = wxNewId()
                    WG_MENU_LIST[gid]["add"] = wxNewId()
                    WG_MENU_LIST[gid]["remove"] = wxNewId()
                    WG_MENU_LIST[gid]["clear"] = wxNewId()
                    WG_MENU_LIST[gid]["menu"] = wxMenu()

                    WG_MENU_LIST[gid]["menu"].SetTitle(gid)
                    WG_MENU_LIST[gid]["menu"].Append(WG_MENU_LIST[gid]["whisper"], "Whisper")
                    WG_MENU_LIST[gid]["menu"].Append(WG_MENU_LIST[gid]["add"], "Add")
                    WG_MENU_LIST[gid]["menu"].Append(WG_MENU_LIST[gid]["remove"], "Remove")
                    WG_MENU_LIST[gid]["menu"].Append(WG_MENU_LIST[gid]["clear"], "Clear")
                    self.wgMenu.PrependMenu(WG_MENU_LIST[gid]["menuid"], gid, WG_MENU_LIST[gid]["menu"])

                if WG_LIST[gid].has_key(int(item.GetText())):
                    WG_MENU_LIST[gid]["menu"].Enable(WG_MENU_LIST[gid]["remove"], true)
                    WG_MENU_LIST[gid]["menu"].Enable(WG_MENU_LIST[gid]["add"], false)
                else:
                    WG_MENU_LIST[gid]["menu"].Enable(WG_MENU_LIST[gid]["remove"], false)
                    WG_MENU_LIST[gid]["menu"].Enable(WG_MENU_LIST[gid]["add"], true)

                if len(WG_LIST[gid]) == 0:
                    WG_MENU_LIST[gid]["menu"].Enable(WG_MENU_LIST[gid]["whisper"], false)
                    WG_MENU_LIST[gid]["menu"].Enable(WG_MENU_LIST[gid]["clear"], false)
                else:
                    WG_MENU_LIST[gid]["menu"].Enable(WG_MENU_LIST[gid]["whisper"], true)
                    WG_MENU_LIST[gid]["menu"].Enable(WG_MENU_LIST[gid]["clear"], true)

                #Event Stuff
                EVT_MENU( self, WG_MENU_LIST[gid]["whisper"], self.on_menu_whispergroup )
                EVT_MENU( self, WG_MENU_LIST[gid]["add"], self.on_menu_whispergroup )
                EVT_MENU( self, WG_MENU_LIST[gid]["remove"], self.on_menu_whispergroup )
                EVT_MENU( self, WG_MENU_LIST[gid]["clear"], self.on_menu_whispergroup )
#---------------------------------------------------------
# [END] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
            self.PopupMenu(self.menu,pos)



    def add_player(self,player):
        i = self.InsertImageStringItem(0,player[2],0)
        self.SetStringItem(i,1,self.strip_html(player))
        self.SetItemData(i,int(player[2]))
        self.SetStringItem (i, 2,player[3])
        self.colorize_player_list()
        self.Refresh()

        # play sound
        setobj = self.myopenrpg.get_component('settings')
        sound_file = setobj.get_setting("AddSound")
        sound_player = orpg.tools.orpg_sound.orpg_sound(setobj.get_setting("UnixSoundPlayer"));
        sound_player.play(sound_file)


    def del_player(self,player):
        i = self.FindItemData(-1,int(player[2]))
        self.DeleteItem(i)

#---------------------------------------------------------
# [START] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
        for gid in WG_LIST:
            if WG_LIST[gid].has_key(int(player[2])):
                del WG_LIST[gid][int(player[2])]
#---------------------------------------------------------
# [END] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------

        # play sound
        setobj = self.myopenrpg.get_component('settings')
        sound_file = setobj.get_setting("DelSound")
        sound_player = orpg.tools.orpg_sound.orpg_sound(setobj.get_setting("UnixSoundPlayer"));
        sound_player.play(sound_file)

        ic = self.GetItemCount()
        self.whisperCount = 0
        index = 0
        while index < ic:
            item = self.GetItem( index )
            if item.GetImage():
                self.whisperCount += 1
            index += 1
        self.colorize_player_list()
        self.Refresh()

    #  This method updates the player info
    #
    #  self:  reference to this PlayerList
    #  player:  reference to a player structure(list)
    #
    #  Returns:  None
    #
    def update_player(self,player):
        i = self.FindItemData(-1,int(player[2]))  #  finds the right list box index
        self.SetStringItem(i,1,self.strip_html(player))
        self.SetStringItem(i,2,player[3])
        item = self.GetItem(i)
        self.colorize_player_list()
        self.Refresh()

    def colorize_player_list(self):
        session = self.myopenrpg.get_component("session")
        settings = self.myopenrpg.get_component('settings')
        mode = settings.get_setting("ColorizeRoles")
        if mode.lower() == "off":
            return
        players = session.players

        for m in players.keys():
            item_list_location = self.FindItemData(-1,int(m))
            if item_list_location == -1: continue
            player_info = session.get_player_by_player_id(m)
            item = self.GetItem(item_list_location)
            role = player_info[7].lower()
            color = wxGREEN
            if role == "lurker":
                color = wxColour(red=160,green=160,blue=160)
            elif role == "player":
                color = wxBLACK
            elif role == "gm":
                color = wxRED
            if self.session.group_id != "0":
                item.SetTextColour(color)
            self.SetItem(item)

    def reset(self):
        self.whisperCount = 0
#---------------------------------------------------------
# [START] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
        WG_LIST.clear()
#---------------------------------------------------------
# [END] Digitalxero Multi Whisper Group 1/1/05
#---------------------------------------------------------
        self.DeleteAllItems()



    def strip_html(self,player):
        ret_string = ""
        x = 0
        in_tag = 0

        for x in range(len(player[0])) :
            if player[0][x] == "<" or player[0][x] == ">" or in_tag == 1 :
                if player[0][x] == "<" :
                    in_tag = 1
                elif player[0][x] == ">" :
                    in_tag = 0
                else :
                    pass
            else :
                ret_string = ret_string + player[0][x]
        return ret_string



    def size_cols(self):
##        # moved skip here to see if it breaks
##        w,h = self.GetClientSizeTuple()
##        w /= 8
##        self.SetColumnWidth( 0, w*2 )
##        self.SetColumnWidth( 1, w*2 )
##        self.SetColumnWidth( 2, w*3 )
        pass


--- NEW FILE: main.py ---
#!/usr/bin/env python
# Copyright (C) 2000-2001 The OpenRPG Project
#
#        ope...@li...
#
# 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., 675 Mass Ave, Cambridge, MA 02139, USA.
# --
[...1114 lines suppressed...]
        self.called = False
        wxInitAllImageHandlers()
        self.splash = SplashScreen(None, bitmapfile=orpg.dirpath.dir_struct["icon"]+'splash13.jpg',
                                   duration=3000, callback=self.AfterSplash)
        wxYield()
        return true

    def AfterSplash(self,evt):
        if not self.called:
            self.called = True
            self.splash.HideWindow(1)
            self.splash.screen.Destroy()
            self.frame = orpgFrame(NULL, -1, "OpenRPG v"+VERSION)
            self.frame.Raise()
            self.frame.Refresh()
            self.frame.Show(true)
            self.SetTopWindow(self.frame)
            #self.frame.show_dlgs()
            self.frame.post_show_init()
            return true

--- NEW FILE: orpg_windows.py ---
# Copyright (C) 2000-2001 The OpenRPG Project
#
#        ope...@li...
#
# 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., 675 Mass Ave, Cambridge, MA 02139, USA.
# --
#
# File: orpg_windows.py
# Author: Chris Davis
# Maintainer:
# Version:
#   $Id: orpg_windows.py,v 1.1 2006/01/26 17:33:15 digitalxero Exp $
#
# Description: orpg custom windows
#

__version__ = "$Id: orpg_windows.py,v 1.1 2006/01/26 17:33:15 digitalxero Exp $"

import os
import systempath
import re
import string
import urllib
from orpg.orpg_wx import *
import orpg.tools.rgbhex
import orpg.orpg_xml
import orpg.tools.rgbhex
import orpg.dirpath


class img_helper:
    def __init__(self):
        pass

    def load_url(self,path):
        img_type = self.get_type(path)
        try:
            data = urllib.urlretrieve(path)
            if data:
                img = wxBitmap(data[0], img_type)
            else:
                raise IOError, "Image refused to load!"
        except IOError, e:
            img = None
        return img


    def load_file(self,path):
        img_type = self.get_type(path)
        return wxBitmap(path, img_type)

    def get_type(self,file_name):
        pos = string.rfind(file_name,'.')
        ext = string.lower(file_name[pos+1:])
        img_type = 0
        if ext == "gif":
            img_type = wxBITMAP_TYPE_GIF
        elif (ext == "jpg") | (ext == "jpeg"):
            img_type = wxBITMAP_TYPE_JPEG
        elif ext == "bmp":
            img_type = wxBITMAP_TYPE_BMP
        elif ext == "png":
            img_type = wxBITMAP_TYPE_PNG
        else:
            imf_type = None
        return img_type



################################
## Panels
################################

class wxBoxedSizer(wxPanel):
    def __init__(self, parent, txt):
        wxPanel.__init__(self, parent, -1)
        self.sizer = None
        self.outline = wxStaticBox(self,-1,txt)
        self.ctrl = None
        EVT_SIZE(self, self.on_size)

    def set_sizer(self,sizer):
        self.sizer = sizer
        self.SetSizer(self.sizer)

    def set_ctrl(self,ctrl):
        self.ctrl = ctrl

    def on_size(self,event):
        s = self.GetClientSizeTuple()
        if self.sizer:
            self.sizer.SetDimension(20,20,s[0]-40,s[1]-40)
        if self.ctrl:
            self.ctrl.SetDimensions(20,20,s[0]-40,s[1]-40)
        self.outline.SetDimensions(5,5,s[0]-10,s[1]-10)

    def SetMySize(self,size):
        self.SetMinSize(size)


#####################
## A text editor for openrpg related text
#####################

class html_text_edit(wxPanel):
    """ a text ctrl with html helpers """
    def __init__(self, parent, id, text, callback,home_dir):
        wxPanel.__init__(self, parent,-1)
        self.r_h = orpg.tools.rgbhex.RGBHex()
        self.text = orpgTextCtrl(self, id, text, wxDefaultPosition,
                             wxDefaultSize,
                             wxTE_MULTILINE )
        EVT_SIZE(self, self.OnSize)
        EVT_TEXT(self, id, callback)
        self.callback = callback
        self.BOLD = wxNewId()
        self.ITALIC = wxNewId()
        self.UNDER = wxNewId()
        self.COLOR = wxNewId()
        self.DIE100 = wxNewId()
        self.DIE20 = wxNewId()
        self.DIE10 = wxNewId()
        self.DIE8 = wxNewId()
        self.DIE6 = wxNewId()
        self.DIE4 = wxNewId()
        self.DIE2 = wxNewId()
        self.DIE = wxNewId()

        self.sizer = wxBoxSizer(wxHORIZONTAL)
        gif = wxImage(orpg.dirpath.dir_struct["icon"]+"bold.gif", wxBITMAP_TYPE_GIF)
        self.sizer.Add(wxBitmapButton(self, self.BOLD, gif.ConvertToBitmap()), 0, wxEXPAND)
        gif = wxImage(orpg.dirpath.dir_struct["icon"]+"italic.gif", wxBITMAP_TYPE_GIF)
        self.sizer.Add(wxBitmapButton(self, self.ITALIC, gif.ConvertToBitmap()), 0, wxEXPAND)
        gif = wxImage(orpg.dirpath.dir_struct["icon"]+"underlined.gif", wxBITMAP_TYPE_GIF)
        self.sizer.Add(wxBitmapButton(self, self.UNDER, gif.ConvertToBitmap()), 0, wxEXPAND)
        self.color_button = wxButton(self, self.COLOR, "C",wxPoint(0,0),wxSize(22,0))
        self.color_button.SetBackgroundColour(wxBLACK)
        self.color_button.SetForegroundColour(wxWHITE)
        self.sizer.Add(self.color_button, 0, wxEXPAND)

        EVT_BUTTON(self, self.BOLD, self.on_text_format)
        EVT_BUTTON(self, self.ITALIC, self.on_text_format)
        EVT_BUTTON(self, self.UNDER, self.on_text_format)
        EVT_BUTTON(self, self.COLOR, self.on_text_format)

    def on_text_format(self,event):
        id = event.GetId()
        if wxPlatform == '__WXMSW__':
            txt = self.text.GetLabel()
        else:
            txt = self.text.GetValue()
        (beg,end) = self.text.GetSelection()
        if beg != end:
            sel_txt = txt[beg:end]
        else:
            return
        print txt
        if id == self.BOLD:
            sel_txt = "<b>" + sel_txt + "</b>"
        elif id == self.ITALIC:
            sel_txt = "<i>" + sel_txt + "</i>"
        elif id == self.UNDER:
            sel_txt = "<u>" + sel_txt + "</u>"
        elif id == self.COLOR:
            hexcolor = self.r_h.do_hex_color_dlg(self)
            if hexcolor:
                sel_txt = "<font color='"+hexcolor+"'>"+sel_txt+"</font>"
                self.color_button.SetBackgroundColour(hexcolor)

        txt = txt[:beg] + sel_txt + txt[end:]
       # print txt
        if wxPlatform == '__WXMSW__':
            txt = self.text.SetLabel(txt)
        else:
            txt = self.text.SetValue(txt)
        self.text.SetInsertionPoint(beg)
        self.text.SetFocus()
        self.callback(wxEvent(self.text.GetId()))

    def set_text(self,txt):
        self.text.SetValue(txt)

    def get_text(self):
        return self.text.GetValue()

    def OnSize(self,event):
        (w,h) = self.GetClientSizeTuple()
        self.text.SetDimensions(0,0,w,h-25)
        self.sizer.SetDimension(0,h-25,w,25)


################################
## controls
################################

TEXT_CUT = wxNewId()
TEXT_PASTE = wxNewId()
TEXT_COPY = wxNewId()
TEXT_SELECT_ALL = wxNewId()
TEXT_UNDO = wxNewId()
TEXT_REDO = wxNewId()
# Heroman
TEXT_DISPLAY_HTML = wxNewId()
TEXT_HTML_BOLD = wxNewId()
TEXT_HTML_ITAL = wxNewId()
TEXT_HTML_UNDER = wxNewId()
TEXT_HTML_COLOR = wxNewId()
TEXT_HTML_OTHER=wxNewId()
TEXT_HTML_BORDER = wxNewId()
TEXT_HTML_RULE = wxNewId()
TEXT_HTML_URL = wxNewId()
TEXT_HTML_IMG = wxNewId()

class orpgTextCtrl(wxTextCtrl):
    def __init__(self, parent, id, value="",pos=wxDefaultPosition, size=wxDefaultSize, style=0, validator=None, name=""):
        if validator:
            wxTextCtrl.__init__(self, parent, id, value,pos, size, style, validator, name)
        else:
            wxTextCtrl.__init__(self, parent, id, value,pos, size, style)
        self.r_h = orpg.tools.rgbhex.RGBHex()
        self.edit_menu = wxMenu()
        self.edit_menu.Append(TEXT_CUT,"Cu&t")
        self.edit_menu.Append(TEXT_COPY,"&Copy")
        self.edit_menu.Append(TEXT_PASTE,"&Paste")
        self.edit_menu.AppendSeparator()
        self.edit_menu.Append(TEXT_SELECT_ALL,"Select &All")
        self.edit_menu.AppendSeparator()
        self.edit_menu.Append(TEXT_DISPLAY_HTML,"HTML Preview")
        self.edit_menu.AppendSeparator()
        self.edit_menu.Append(TEXT_HTML_BOLD,"Bold")
        self.edit_menu.Append(TEXT_HTML_ITAL,"Italics")
        self.edit_menu.Append(TEXT_HTML_UNDER,"Underline")
        self.edit_menu.Append(TEXT_HTML_COLOR,"Color")
        self.edit_menu_other=wxMenu()
        self.edit_menu_other.Append(TEXT_HTML_BORDER,"Border")
        self.edit_menu_other.Append(TEXT_HTML_RULE,"Horizantal Rule")
        self.edit_menu_other.Append(TEXT_HTML_IMG,"Image Tag")
        self.edit_menu_other.Append(TEXT_HTML_URL,"URL Tag","Adds empty tag or uses selection as a URL")

        self.edit_menu.AppendMenu(TEXT_HTML_OTHER,"Other",self.edit_menu_other,"Other HTML tags...");

        EVT_RIGHT_DOWN(self, self.on_rclick)
        EVT_MENU(self, TEXT_COPY, self.on_menu)
        EVT_MENU(self, TEXT_CUT, self.on_menu)
        EVT_MENU(self, TEXT_PASTE, self.on_menu)
        EVT_MENU(self, TEXT_SELECT_ALL, self.on_menu)
        EVT_MENU(self, TEXT_DISPLAY_HTML,self.on_menu)
        EVT_MENU(self, TEXT_HTML_BOLD,self.on_menu)
        EVT_MENU(self, TEXT_HTML_ITAL,self.on_menu)
        EVT_MENU(self, TEXT_HTML_UNDER,self.on_menu)
        EVT_MENU(self, TEXT_HTML_COLOR,self.on_menu)
        EVT_MENU(self, TEXT_HTML_BORDER,self.on_menu)
        EVT_MENU(self, TEXT_HTML_RULE,self.on_menu)
        EVT_MENU(self, TEXT_HTML_IMG,self.on_menu)
        EVT_MENU(self, TEXT_HTML_URL,self.on_menu)


    def on_rclick(self,evt):
        pt = evt.GetPosition()
        self.PopupMenu(self.edit_menu,pt)

    def on_menu(self,evt):
        id = evt.GetId()
        if id == TEXT_COPY:
            self.Copy()
        elif id == TEXT_CUT:
            self.Cut()
        elif id == TEXT_PASTE:
            self.Paste()
        elif id == TEXT_SELECT_ALL:
            self.SetFocus()
            self.SetSelection(0,self.GetLastPosition())
        elif id == TEXT_HTML_BOLD:
            sel=self.GetStringSelection();
            self.Cut()
            self.WriteText("<b>"+sel+"</b>")
        elif id == TEXT_HTML_ITAL:
            sel=self.GetStringSelection();
            self.Cut()
            self.WriteText("<i>"+sel+"</i>")
        elif id == TEXT_HTML_IMG:
            sel=self.GetStringSelection();
            self.Cut()
            self.WriteText("<img src=\""+sel+"\">")
        elif id == TEXT_HTML_URL:
            sel=self.GetStringSelection();
            self.Cut()
            if sel == "":
                self.WriteText("<a href=\"INSERT_URL_HERE\">INSERT_TEXT_HERE</a>")
            else:
                self.WriteText("<a href=\""+sel+"\">"+sel+"</a>")
        elif id == TEXT_HTML_UNDER:
            sel=self.GetStringSelection();
            self.Cut()
            self.WriteText("<u>"+sel+"</u>")
        elif id == TEXT_HTML_RULE:
            sel=self.GetStringSelection();
            self.Cut()
            self.WriteText("<hr>")
        elif id == TEXT_HTML_COLOR:
            sel=self.GetStringSelection();
            self.Cut()
            data = wxColourData()
            data.SetChooseFull(true)
            dlg = wxColourDialog(self, data)
            if dlg.ShowModal() == wxID_OK:
                data = dlg.GetColourData()
                (red,green,blue) = data.GetColour().Get()
                hexcolor = self.r_h.hexstring(red, green, blue)
                self.WriteText("<font color=\""+hexcolor+"\">"+sel+"</font>")
            dlg.Destroy()
        elif id == TEXT_HTML_BORDER:
            sel=self.GetStringSelection();
            self.Cut()
            self.WriteText("<table border=1><tr><td>"+sel+"</td></tr></table>")
        elif id == TEXT_DISPLAY_HTML:
            dlg=HTMLDialog(self,"HTML Preview",self.GetValue());
            dlg.Show()
            #dlg.Destroy()
            #about = MyAboutBox(self,obj.about())





################################
### MISC WINDOWS AND FRAMES
################################
class HTMLDialog(wxDialog):
    page = """
<html>
<body bgcolor="%s">
%s
<p><wxp class="wxButton">
    <param name="label" value="Okay">
    <param name="id"    value="wxID_OK">
</wxp></p>
</body>
</html>
"""
    def __init__(self, parent, title, text, bgcolor="#FFFFFF"):
        wxDialog.__init__(self, parent, -1, title,pos=(-1,-1),size=(400,400),style=wxRESIZE_BORDER|wxDEFAULT_DIALOG_STYLE)
        self.html = http_html_window(self,-1)
        #self.html = wxHtmlWindow(self, -1, size=(600, 400))
        self.html.SetPage(self.page % (bgcolor, text))
        ir = self.html.GetInternalRepresentation()
        self.html.SetSize( (ir.GetWidth()+5, ir.GetHeight()+5) )
        self.SetClientSize(self.html.GetSize())
        self.SetSize(size=(600,400))
        self.CentreOnParent(wxBOTH)
    #def OnOK(self,event):


class MyAboutBox(wxDialog):
    page = """
<html>
<body bgcolor="%s"><center>
%s
<p><wxp class="wxButton">
    <param name="label" value="Okay">
    <param name="id"    value="wxID_OK">
</wxp></p>
</center>
</body>
</html>
"""
    def __init__(self, parent, text, bgcolor="#FFFFFF"):
        wxDialog.__init__(self, parent, -1, 'About',)
        html = wxHtmlWindow(self, -1, size=(420, -1))
        html.SetPage(self.page % (bgcolor, text))
        ir = html.GetInternalRepresentation()
        html.SetSize( (ir.GetWidth()+5, ir.GetHeight()+5) )
        self.SetClientSize(html.GetSize())
        self.CentreOnParent(wxBOTH)

###########################
## HTML related clasees
###########################

class http_html_window(wxHtmlWindow):
    """ a wxHTMLwindow that will load links  """
    def __init__(self, parent, id):
        wxHtmlWindow.__init__(self, parent, id, wxDefaultPosition,wxDefaultSize,wxSUNKEN_BORDER | wxHW_SCROLLBAR_AUTO)
        self.path = ""
        self.local = 0
        #self.title = title

    def OnLinkClicked(self, linkinfo):
        address = linkinfo.GetHref()
        if address[:4] == "http":
            self.load_url(address)
            self.local = 0
        elif address[0] == "#" or self.local:
            self.base_OnLinkClicked(linkinfo)
        else:
            self.load_url(self.path+address)

    def load_url(self,path):
        print path
        dlg = wxProgressDialog("HTML Document","Loading...",3,self)
        dlg.Update(1)
        try:
            data = urllib.urlretrieve(path)
            file = open(data[0])
            dlg.Update(2)
            self.SetPage(file.read())
            i = string.rfind(path,"/")
            self.path = path[:i+1]
        except:
            wxMessageBox("Invalid URL","Browser Error",wxOK)
            #self.SetPage("<h3>Invalid URL</h3>")
        dlg.Update(3)
        dlg.Destroy()

    def load_file(self,path):
        self.LoadPage(path)
        self.local = 1


WEB_CLOSE = wxNewId()
WEB_BACK = wxNewId()
WEB_FORWARD = wxNewId()
WEB_PRINT = wxNewId()
WEB_SAVE = wxNewId()
class wxHTMLpanel(wxPanel):
    """ A user friednly panel for the http_html_window """
    def __init__(self, parent, id,):
        wxPanel.__init__(self, parent, id)
        self.html_wnd = http_html_window(self,-1)
        self.parent = parent
        self.sizer = wxBoxSizer(wxHORIZONTAL)
        self.sizer.Add(wxButton(self, WEB_CLOSE, "Close"), 1, wxEXPAND)
        self.sizer.Add(wxButton(self, WEB_BACK, "Back"), 1, wxEXPAND)
        self.sizer.Add(wxButton(self, WEB_FORWARD, "Forward"), 1, wxEXPAND)
        self.sizer.Add(wxButton(self, WEB_SAVE, "Save"), 1, wxEXPAND)
        self.sizer.Add(wxButton(self, WEB_PRINT, "Print"), 1, wxEXPAND)
        EVT_BUTTON(self, WEB_CLOSE, self.on_button)
        EVT_BUTTON(self, WEB_BACK, self.on_button)
        EVT_BUTTON(self, WEB_FORWARD, self.on_button)
        EVT_BUTTON(self, WEB_PRINT, self.on_button)
        EVT_BUTTON(self, WEB_SAVE, self.on_button)
        EVT_SIZE(self, self.on_size)
        EVT_CLOSE( self, self.OnClose )
        self.printer = wxHtmlEasyPrinting()

    def on_button(self,evt):
        id = evt.GetId()
        if id == WEB_CLOSE:
            self.OnClose( evt )
        elif id == WEB_FORWARD:
            if not self.html_wnd.HistoryForward():
                wxMessageBox("No more items in history!")
        elif id==WEB_BACK:
            if not self.html_wnd.HistoryBack():
                wxMessageBox("No more items in history!")
        elif id==WEB_PRINT:
            file = self.html_wnd.GetOpenedPage()
            if file == "":
                self.save_page("print.htm")
                file = "print.htm"
            self.printer.PreviewFile(file)
        elif id==WEB_SAVE:
            f =wxFileDialog(self,"Select a file",orpg.dirpath.dir_struct["user"],"","HTML (*.html)|*.html",wxSAVE)
            if f.ShowModal() == wxID_OK:
                self.save_page(f.GetPath())
            f.Destroy()

    def save_page(self,path):
        data = self.html_wnd.GetParser().GetSource()
        file = open(path,"w")
        file.write(data)
        file.close()

    def load_file(self,path):
        self.html_wnd.load_file(path)

    def load_url(self,path):
        self.html_wnd.load_url(path)

    def on_size(self,event):
        (w,h) = self.GetClientSizeTuple()
        self.html_wnd.SetDimensions(0,0,w,h-25)
        self.sizer.SetDimension(0,h-25,w,25)

    def load_text(self,txt):
        self.html_wnd.SetPage(txt)

    def OnClose( self, evt ):
        self.parent.Close( true )



class wxPFrame(wxFrame):
    """ a framed window that holds a single panel """
    def __init__(self, parent, caption, icon_file=orpg.dirpath.dir_struct["icon"]+'d20.ico',
                 only_hide=0, pos = None, size = None, style=wxDEFAULT_FRAME_STYLE):
        if not pos:
            pos = wxDefaultPosition
        if not size:
            size = wxSize(500,300)
        wxFrame.__init__(self, parent, -1, caption, pos, size, style )
        if wxPlatform == '__WXMSW__':
            icon = wxIcon(icon_file, wxBITMAP_TYPE_ICO)
            self.SetIcon(icon)
        self.panel = None
        self.only_hide = only_hide
        self.parent = parent
        self.destroyed = 0
        EVT_SIZE(self, self.OnSize)
        EVT_CLOSE(self, self.OnCloseWindow)


    def OnCloseWindow(self, event):
        if self.only_hide:
            self.Show( false )
            self.Raise()
        else:
            self.destroyed = 1
            self.Destroy()
        #print "window destroyed!"


    def OnSize(self,event):
        (w,h) = self.GetClientSizeTuple()
        if self.panel:
            self.panel.SetDimensions(0,0,w,h)



class wxHTMLFrame(wxFrame):
    """ a framed http_html_window """
    def __init__(self, parent, caption, pos = None, size = None, style = wxDEFAULT_FRAME_STYLE):
        if not pos:
            pos = wxDefaultPosition
        if not size:
            size = wxSize(500,300)
        wxFrame.__init__(self, parent, -1, caption, pos, size,style)
        self.html_wnd = http_html_window(self,-1)
        self.ok = wxButton(self, wxID_OK, "OK")
        EVT_BUTTON(self, wxID_OK, self.OnCloseMe)
        EVT_SIZE(self, self.OnSize)

    def load_file(self,path):
        self.html_wnd.load_file(path)

    def load_url(self,path):
        self.html_wnd.load_url(path)

    def set_page(self,data):
        self.html_wnd.SetPage(data)

    def load_img(self,path):
        self.html_wnd.load_img(path)

    def OnCloseMe(self, event):
        self.Close(true)

    def OnCloseWindow(self, event):
        self.Destroy()

    def OnSize(self,event):
        (w,h) = self.GetClientSizeTuple()
        self.html_wnd.SetDimensions(0,0,w,h-25)
        self.ok.SetDimensions(0,h-25,w,25)

###########################
## Some misc dialogs
###########################

class wxMultiCheckBoxDlg(wxDialog):
    """ notes """
    def __init__(self,parent,opts,text,caption,selected=[],pos=wxDefaultPosition):
        wxDialog.__init__(self,parent,-1,caption,pos,wxDefaultSize)
        sizers = { 'ctrls' : wxBoxSizer(wxVERTICAL),
                    'buttons' : wxBoxSizer(wxHORIZONTAL) }

        sid = wxNewId()
        self.opts = opts
        self.list = wxCheckListBox(self, sid, wxDefaultPosition, wxDefaultSize,opts)
        for s in selected:
            self.list.Check(s,1)

        sizers['ctrls'].Add(wxStaticText(self, -1, text), 0, 0)
        sizers['ctrls'].Add(wxSize(10,10))
        sizers['ctrls'].Add(self.list, 1, wxEXPAND)

        sizers['buttons'].Add(wxButton(self, wxID_OK, "OK"), 1, wxEXPAND)
        sizers['buttons'].Add(wxSize(10,10))
        sizers['buttons'].Add(wxButton(self, wxID_CANCEL, "Cancel"), 1, wxEXPAND)

        width = 200
        height = 200
        self.SetClientSizeWH(width,height)
        sizers['ctrls'].SetDimension(10,5,width-20,160)
        sizers['buttons'].SetDimension(10,170,width-20,25)
        EVT_BUTTON(self, wxID_OK, self.on_ok)


    def on_ok(self,evt):
        checked = []
        for i in range(len(self.opts)):
            if self.list.IsChecked(i):
                checked.append(i)
        self.checked = checked
        self.EndModal(wxID_OK)

    def get_selections(self):
        return self.checked


class wxMultiChoiceDlg(wxDialog):
    """ test """
    def __init__(self,parent,opts,text,caption,pos=wxDefaultPosition):
        wxDialog.__init__(self,parent,-1,caption,pos,wxDefaultSize)
        sizers = { 'ctrls' : wxBoxSizer(wxVERTICAL),
                    'buttons' : wxBoxSizer(wxHORIZONTAL) }

        self.list = wxListBox(self, -1, wxDefaultPosition, wxDefaultSize,
                       opts, wxLB_EXTENDED)

        sizers['ctrls'].Add(wxStaticText(self, -1, text), 0, 0)
        sizers['ctrls'].Add(wxSize(10,10))
        sizers['ctrls'].Add(self.list, 1, wxEXPAND)

        sizers['buttons'].Add(wxButton(self, wxID_OK, "OK"), 1, wxEXPAND)
        sizers['buttons'].Add(wxSize(10,10))
        sizers['buttons'].Add(wxButton(self, wxID_CANCEL, "Cancel"), 1, wxEXPAND)

        width = 200
        height = 200
        self.SetClientSizeWH(width,height)
        sizers['ctrls'].SetDimension(10,5,width-20,160)
        sizers['buttons'].SetDimension(10,170,width-20,25)
        EVT_BUTTON(self, wxID_OK, self.on_ok)

    def on_ok(self,evt):
        self.EndModal(wxID_OK)

    def get_selections(self):
        pass


class wxMultiTextEntry(wxDialog):
    """ a dialog that takes two lists (labels and values) and creates a
        'label: value' style text edit control for each node in the dic"""
    def __init__(self,parent,tlist,vlist,caption,pos=wxDefaultPosition):
        wxDialog.__init__(self,parent,-1,caption,pos,wxDefaultSize)

        num = len(tlist)
        sizers = { 'ctrls' : wxFlexGridSizer(num,2,5,0),
                    'buttons' : wxBoxSizer(wxHORIZONTAL) }
        #keys = mlist.keys()
        self.tlist = ...
 
[truncated message content]