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         parent = self.GetParser().GetWindow()
 167         if parent:
 168             obj = apply(self.ctx.classObj,
 169                         (parent,),
 170                         self.ctx.kwargs)
 171             obj.Show(true)
 172
 173             # add it to the HtmlWindow
 174             self.GetParser().GetContainer().InsertCell(wxHtmlWidgetCell(obj, self.ctx.floatWidth))
 175             self.ctx = None
 176
 177         return true
 178
 179
 180
 181
 182     def HandleParamTag(self, tag):
 183         if tag.IsEnding():
 184             return false
 185
 186         if not tag.HasParam('NAME'):
 187             return false
 188
 189         name = tag.GetParam('NAME')
 190         value = ""
 191         if tag.HasParam('VALUE'):
 192             value = tag.GetParam('VALUE')
 193
 194         # check for a param named 'id'
 195         if name == 'id':
 196             theID = -1
 197             try:
 198                 theID = string.atoi(value)
 199             except ValueError:
 200                 theID = getattr(self.ctx.classMod, value)
 201             value = theID
 202
 203
 204         # check for something that should be evaluated
 205         elif value[0] in '[{(' or value[:2] == 'wx':
 206             saveVal = value
 207             try:
 208                 value = eval(value, self.ctx.classMod.__dict__)
 209             except:
 210                 value = saveValue
 211
 212         # convert to wxColour
 213         elif value[0] == '#':
 214             try:
 215                 red   = string.atoi('0x'+value[1:3], 16)
 216                 green = string.atoi('0x'+value[3:5], 16)
 217                 blue  = string.atoi('0x'+value[5:], 16)
 218                 value = wxColor(red, green, blue)
 219             except:
 220                 pass
 221
 222         self.ctx.kwargs[name] = value
 223         return false
 224
 225
 226 #----------------------------------------------------------------------
 227 # just a place to hold some values
 228 class _Context:
 229     def __init__(self):
 230         self.kwargs = {}
 231         self.width = -1
 232         self.height = -1
 233         self.classMod = None
 234         self.classObj = None
 235         self.floatWidth = 0
 236
 237
 238 #----------------------------------------------------------------------
 239 # Function to assist with importing packages
 240 def _my_import(name):
 241     mod = __import__(name)
 242     components = string.split(name, '.')
 243     for comp in components[1:]:
 244         mod = getattr(mod, comp)
 245     return mod
 246
 247
 248 #----------------------------------------------------------------------
 249 # Function to parse a param string (of the form 'item=value item2="value etc"'
 250 # and creates a dictionary
 251 def _param2dict(param):
 252     i = 0; j = 0; s = len(param); d = {}
 253     while 1:
 254         while i<s and param[i] == " " : i = i+1
 255         if i>=s: break
 256         j = i
 257         while j<s and param[j] != "=": j=j+1
 258         if j+1>=s:
 259             break
 260         word = param[i:j]
 261         i=j+1
 262         if (param[i] == '"'):
 263             j=i+1
 264             while j<s and param[j] != '"' : j=j+1
 265             if j == s: break
 266             val = param[i+1:j]
 267         elif (param[i] != " "):
 268             j=i+1
 269             while j<s and param[j] != " " : j=j+1
 270             val = param[i:j]
 271         else:
 272             val = ""
 273         i=j+1
 274         d[word] = val
 275     return d
 276
 277 #----------------------------------------------------------------------
 278
 279
 280
 281 wxHtmlWinParser_AddTagHandler(wxpTagHandler)