utils/wxPython/lib/wxpTag.py

   1 #----------------------------------------------------------------------
   2 # Name:        wxPython.lib.wxpTag
   3 # Purpose:     A wxHtmlTagHandler that knows how to build and place
   4 #              wxPython widgets onto web pages.
   5 #
   6 # Author:      Robin Dunn
   7 #
   8 # Created:     13-Sept-1999
   9 # RCS-ID:      $Id$
  10 # Copyright:   (c) 1999 by Total Control Software
  11 # Licence:     wxWindows license
  12 #----------------------------------------------------------------------
  13
  14 '''
  15 wxPython.lib.wxpTag
  16
  17 This module contains a wxHtmlTagHandler that knows how to build
  18 and place wxPython widgets onto wxHtmlWindow web pages.
  19
  20 You don\'t need to use anything in this module directly, just
  21 importing it will create the tag handler and add it to any
  22 wxHtmlWinParsers created from that time forth.
  23
  24 Tags of the following form are recognised:
  25
  26     <WXP class="classname" [module="modulename"] [width="num"] [height="num"]>
  27         <PARAM name="parameterName" value="parameterValue>
  28         ...
  29     </WXP>
  30
  31 where modulename is the name of a module (possibly in package
  32 notation) to import and classname is the name of a class in that
  33 module to create an instance of.  If the module tag-attribute is not
  34 given or is an empty string, then wxPython.wx is used.  The width and
  35 height attributes are expected to be integers and will be passed to
  36 the __init__ method of the class as a wxSize object named size.
  37 However, if the width attribute ends with the percent (%) symbol then
  38 the value will be used as a percentage of the available width and the
  39 wxHtmlWindow will manage the size.
  40
  41 The name-value pairs in all the nested PARAM tags are packaged up as
  42 strings into a python dictionary and passed to the __init__ method of
  43 the class as keyword arguments.  This means that they are all
  44 accessible from the __init__ method as regular parameters, or you use
  45 the special Python **kw syntax in your __init__ method to get the
  46 dictionary directly.
  47
  48 Some parameter values are special and if they are present then they will
  49 be converted from strings to alternate datatypes.  They are:
  50
  51     id           If the value of id can be converted to an integer, it will
  52                  be.  Otherwise it is assumed to be the name of an integer
  53                  variable in the module.
  54
  55     colours      Any value of the form "#123ABC" will automatically be
  56                  converted to a wxColour object.
  57
  58     Py Types     Any value begining with "(", "[" or "{" are expected to
  59                  be a Python tuple, list, or dictionary and eval()
  60                  will be used to convert them to that type.  If the
  61                  eval() fails then the original string value will be
  62                  preserved.
  63
  64     wx Types     Any value begining with "wx" is expected to be an attempt
  65                  to create a wxPython object, such as a wxSize, etc.
  66                  The eval() will be used to try and construct the
  67                  object and if it fails then the original string value
  68                  will be used instead.
  69
  70 An example:
  71
  72     <wxp module="" class="wxButton">
  73         <param name="label" value="Click here">
  74         <param name="id" value="wxID_OK">
  75     </wxp>
  76
  77 Both the begining and ending WXP tags are required.
  78
  79 In the future support will be added for another tag that can be
  80 embedded between the two begining and ending WXP tags and will
  81 facilitate calling methods of the widget to help initialize it.
  82 Additionally, support may be added to fetch the module from a web
  83 server as is done with java applets.
  84
  85 '''
  86 #----------------------------------------------------------------------
  87
  88 from wxPython.wx   import *
  89 from wxPython.html import *
  90 import wxPython.wx
  91
  92 import string
  93 import types
  94
  95 #----------------------------------------------------------------------
  96
  97 WXPTAG   = 'WXP'
  98 PARAMTAG = 'PARAM'
  99
 100 #----------------------------------------------------------------------
 101
 102 class wxpTagHandler(wxHtmlWinTagHandler):
 103     def __init__(self):
 104         wxHtmlWinTagHandler.__init__(self)
 105         self.ctx = None
 106
 107     def GetSupportedTags(self):
 108         return WXPTAG+','+PARAMTAG
 109
 110
 111     def HandleTag(self, tag):
 112         name = tag.GetName()
 113         if name == WXPTAG:
 114             return self.HandleWxpTag(tag)
 115         elif name == PARAMTAG:
 116             return self.HandleParamTag(tag)
 117         else:
 118             raise ValueError, 'unknown tag: ' + name
 119
 120
 121     def HandleWxpTag(self, tag):
 122         if tag.IsEnding():
 123             return false
 124
 125         # create a new context object
 126         self.ctx = _Context()
 127
 128         # find and import the module
 129         modName = ''
 130         if tag.HasParam('MODULE'):
 131             modName = tag.GetParam('MODULE')
 132         if modName:
 133             self.ctx.classMod = _my_import(modName)
 134         else:
 135             self.ctx.classMod = wxPython.wx
 136
 137         # find and verify the class
 138         if not tag.HasParam('CLASS'):
 139             raise AttributeError, "WXP tag requires a CLASS attribute"
 140
 141         className = tag.GetParam('CLASS')
 142         self.ctx.classObj = getattr(self.ctx.classMod, className)
 143         if type(self.ctx.classObj) != types.ClassType:
 144             raise TypeError, "WXP tag attribute CLASS must name a class"
 145
 146
 147
 148         # now look for width and height
 149         width = -1
 150         height = -1
 151         if tag.HasParam('WIDTH'):
 152             width = tag.GetParam('WIDTH')
 153             if width[-1] == '%':
 154                 self.ctx.floatWidth = string.atoi(width[:-1], 0)
 155                 width = self.ctx.floatWidth
 156             else:
 157                 width = string.atoi(width)
 158         if tag.HasParam('HEIGHT'):
 159             height = string.atoi(tag.GetParam('HEIGHT'))
 160         self.ctx.kwargs['size'] = wxSize(width, height)
 161
 162
 163         self.ParseInner(tag)
 164
 165         # create the object
 166         obj = apply(self.ctx.classObj,
 167                     (self.GetParser().GetWindow(),),
 168                     self.ctx.kwargs)
 169         obj.Show(true)
 170
 171         # add it to the HtmlWindow
 172         self.GetParser().GetContainer().InsertCell(wxHtmlWidgetCell(obj, self.ctx.floatWidth))
 173         self.ctx = None
 174         return true
 175
 176
 177
 178
 179     def HandleParamTag(self, tag):
 180         if tag.IsEnding():
 181             return false
 182
 183         if not tag.HasParam('NAME'):
 184             return false
 185
 186         name = tag.GetParam('NAME')
 187         value = ""
 188         if tag.HasParam('VALUE'):
 189             value = tag.GetParam('VALUE')
 190
 191         # check for a param named 'id'
 192         if name == 'id':
 193             theID = -1
 194             try:
 195                 theID = string.atoi(value)
 196             except ValueError:
 197                 theID = getattr(self.ctx.classMod, value)
 198             value = theID
 199
 200
 201         # check for something that should be evaluated
 202         elif value[0] in '[{(' or value[:2] == 'wx':
 203             saveVal = value
 204             try:
 205                 value = eval(value, self.ctx.classMod.__dict__)
 206             except:
 207                 value = saveValue
 208
 209         # convert to wxColour
 210         elif value[0] == '#':
 211             #try:
 212                 red   = string.atoi('0x'+value[1:3], 16)
 213                 green = string.atoi('0x'+value[3:5], 16)
 214                 blue  = string.atoi('0x'+value[5:], 16)
 215                 value = wxColor(red, green, blue)
 216             #except:
 217             #    pass
 218
 219         self.ctx.kwargs[name] = value
 220         return false
 221
 222
 223 #----------------------------------------------------------------------
 224 # just a place to hold some values
 225 class _Context:
 226     def __init__(self):
 227         self.kwargs = {}
 228         self.width = -1
 229         self.height = -1
 230         self.classMod = None
 231         self.classObj = None
 232         self.floatWidth = 0
 233
 234
 235 #----------------------------------------------------------------------
 236 # Function to assist with importing packages
 237 def _my_import(name):
 238     mod = __import__(name)
 239     components = string.split(name, '.')
 240     for comp in components[1:]:
 241         mod = getattr(mod, comp)
 242     return mod
 243
 244
 245 #----------------------------------------------------------------------
 246 # Function to parse a param string (of the form 'item=value item2="value etc"'
 247 # and creates a dictionary
 248 def _param2dict(param):
 249     i = 0; j = 0; s = len(param); d = {}
 250     while 1:
 251         while i<s and param[i] == " " : i = i+1
 252         if i>=s: break
 253         j = i
 254         while j<s and param[j] != "=": j=j+1
 255         if j+1>=s:
 256             break
 257         word = param[i:j]
 258         i=j+1
 259         if (param[i] == '"'):
 260             j=i+1
 261             while j<s and param[j] != '"' : j=j+1
 262             if j == s: break
 263             val = param[i+1:j]
 264         elif (param[i] != " "):
 265             j=i+1
 266             while j<s and param[j] != " " : j=j+1
 267             val = param[i:j]
 268         else:
 269             val = ""
 270         i=j+1
 271         d[word] = val
 272     return d
 273
 274 #----------------------------------------------------------------------
 275
 276
 277
 278 wxHtmlWinParser_AddTagHandler(wxpTagHandler)