← Back to branch summary

~ubuntu-branches/ubuntu/raring/wxwidgets2.8/raring

« back to all changes in this revision

Viewing changes to wxPython/wx/tools/Editra/plugins/Launch/launch/launchxml.py

  • Committer: Package Import Robot
  • Author(s): Stéphane Graber
  • Date: 2012-01-07 13:59:25 UTC
  • mfrom: (1.1.9) (5.1.10 sid)
  • Revision ID: package-import@ubuntu.com-20120107135925-2601miy9ullcon9j
Tags: 2.8.12.1-6ubuntu1
https://launchpad.net/bugs/632984
* Resync from Debian, changes that were kept:
  - debian/rules: re-enable mediactrl. This allows libwx_gtk2u_media-2.8 to be
    built, as this is required by some applications (LP: #632984)
  - debian/control: Build-dep on libxt-dev for mediactrl.
  - Patches
    + fix-bashism-in-example
* Add conflict on python-wxgtk2.8 (<< 2.8.12.1-6ubuntu1~) to python-wxversion
  to guarantee upgrade ordering when moving from pycentral to dh_python2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
wxPython/wx/tools/Editra/plugins/Launch/launch/launchxml.py
30
30
"""
31
31
 
32
32
__author__ = "Cody Precord <cprecord@editra.org>"
33
 
__svnid__ = "$Id: launchxml.py 62581 2009-11-10 02:52:54Z CJP $"
34
 
__revision__ = "$Revision: 62581 $"
 
33
__svnid__ = "$Id: launchxml.py 67713 2011-05-06 18:43:32Z CJP $"
 
34
__revision__ = "$Revision: 67713 $"
35
35
 
36
36
#-----------------------------------------------------------------------------#
37
37
# Imports
38
 
import xml.sax as sax
39
38
import re
40
 
import os
41
39
import sys
42
 
sys.path.insert(0, os.path.abspath('../../../src/'))
 
40
#sys.path.insert(0, '../../../src/')
43
41
 
44
42
# Editra Imports
45
 
import syntax
46
 
from syntax import synglob
 
43
import ed_xml
47
44
 
48
45
#-----------------------------------------------------------------------------#
49
46
# Globals
50
47
 
51
 
# Tags
52
 
EXML_LAUNCH      = u"launch"
53
 
EXML_HANDLER     = u"handler"
54
 
EXML_COMMANDLIST = u"commandlist"
55
 
EXML_COMMAND     = u"command"
56
 
EXML_ERROR       = u"error"
57
 
EXML_HOTSPOT     = u"hotspot"
58
 
 
59
 
# Attributes
60
 
EXML_DEFAULT = u"default"
61
 
EXML_EXECUTE = u"execute"
62
 
EXML_PATTERN = u"pattern"
63
 
 
64
48
#-----------------------------------------------------------------------------#
65
49
 
66
 
class LaunchXml(syntax.EditraXml):
67
 
    """Launch Xml Handler"""
68
 
    def __init__(self):
69
 
        syntax.EditraXml.__init__(self)
70
 
 
71
 
        # Attributes
72
 
        self._current = None
73
 
        self._handlers = dict()
74
 
 
75
 
        # Setup
76
 
        self.SetName(EXML_LAUNCH)
77
 
 
78
 
    #---- Xml Implementation ----#
79
 
 
80
 
    def startElement(self, name, attrs):
81
 
        if name == EXML_HANDLER:
82
 
            lang = attrs.get(syntax.EXML_NAME, None)
83
 
            assert lang is not None, "lang attribute must be defined"
84
 
            id_ = attrs.get(syntax.EXML_ID, None)
85
 
            assert id_ is not None, "lang id is not specified"
86
 
            assert hasattr(synglob, id_), "Undefined language id: %s" % id_
87
 
            self._current = Handler(lang, getattr(synglob, id_))
88
 
            self._handlers[lang] = self._current
89
 
        elif self._current is not None:
90
 
            self._current.startElement(name, attrs)
91
 
        else:
92
 
            pass
93
 
 
94
 
    def endElement(self, name):
95
 
        if name == EXML_HANDLER:
96
 
            self._current = None
97
 
        elif self._current is not None:
98
 
            self._current.endElement(name)
99
 
        else:
100
 
            pass
101
 
 
102
 
    #---- End Xml Implementation ----#
103
 
 
104
 
    #---- External Api ----#
105
 
    
 
50
class ErrorPattern(ed_xml.EdXml):
 
51
    class meta:
 
52
        tagname = "error"
 
53
    pattern = ed_xml.String(required=True)
 
54
 
 
55
class HotspotPattern(ed_xml.EdXml):
 
56
    class meta:
 
57
        tagname = "hotspot"
 
58
    pattern = ed_xml.String(required=True)
 
59
 
 
60
class Command(ed_xml.EdXml):
 
61
    class meta:
 
62
        tagname = "command"
 
63
    name = ed_xml.String(required=True)
 
64
    execute = ed_xml.String(required=True)
 
65
 
 
66
class CommandList(ed_xml.EdXml):
 
67
    class meta:
 
68
        tagname = "commandlist"
 
69
    default = ed_xml.String(required=True)
 
70
    commands = ed_xml.List(Command)
 
71
 
 
72
class Handler(ed_xml.EdXml):
 
73
    class meta:
 
74
        tagname = "handler"
 
75
    name = ed_xml.String(required=True)
 
76
    id = ed_xml.String(required=True)
 
77
    # Sub elements
 
78
    commandlist = ed_xml.Model(CommandList, required=False)
 
79
    error = ed_xml.Model(ErrorPattern, required=False)
 
80
    hotspot = ed_xml.Model(HotspotPattern, required=False)
 
81
 
 
82
    def GetDefaultCommand(self):
 
83
        """Get the default command"""
 
84
        default = u""
 
85
        if self.commandlist:
 
86
            default = self.commandlist.default
 
87
        return default
 
88
 
 
89
    def GetCommands(self):
 
90
        """Get the list of commands"""
 
91
        clist = dict()
 
92
        if self.commandlist:
 
93
            for cmd in self.commandlist.commands:
 
94
                clist[cmd.name] = cmd.execute
 
95
        return clist
 
96
 
 
97
    def GetErrorPattern(self):
 
98
        """Get the handlers error pattern"""
 
99
        if self.error and self.error.pattern:
 
100
            return re.compile(self.error.pattern)
 
101
        return None
 
102
 
 
103
    def GetHotspotPattern(self):
 
104
        """Get the handlers hotspot pattern"""
 
105
        if self.hotspot and self.hotspot.pattern:
 
106
            return re.compile(self.hotspot.pattern)
 
107
        return None
 
108
 
 
109
class LaunchXml(ed_xml.EdXml):
 
110
    class meta:
 
111
        tagname = "launch"
 
112
    handlers = ed_xml.List(Handler, required=False)
 
113
 
106
114
    def GetHandler(self, name):
107
115
        """Get a handler by name
108
116
        @return: Handler instance or None
109
117
 
110
118
        """
111
 
        return self._handlers.get(name, None)
 
119
        rval = None
 
120
        for handler in self.handlers:
 
121
            if handler.name == name:
 
122
                rval = handler
 
123
                break
 
124
        return handler
112
125
 
113
126
    def GetHandlers(self):
114
127
        """Get the whole dictionary of handlers
115
128
        @return: dict(name=Handler)
116
129
 
117
130
        """
118
 
        return self._handlers
 
131
        return self.handlers
119
132
 
120
133
    def HasHandler(self, name):
121
134
        """Is there a handler for the given file type
122
135
        @return: bool
123
136
 
124
137
        """
125
 
        return name in self._handlers
126
 
 
127
 
#-----------------------------------------------------------------------------#
128
 
 
129
 
class Handler(syntax.EditraXml):
130
 
    """Handler object data"""
131
 
    def __init__(self, lang, id_):
132
 
        """Create a new handler
133
 
        @param lang: language name string
134
 
        @param id_: language id (int)
135
 
 
136
 
        """
137
 
        syntax.EditraXml.__init__(self)
138
 
 
139
 
        # Attributes
140
 
        self._lang = lang
141
 
        self._langid = id_
142
 
        self._commands = CommandList()
143
 
        self._errpat = None
144
 
        self._hotspot = None
145
 
 
146
 
        # Setup
147
 
        self.SetName(EXML_HANDLER)
148
 
        self.RegisterHandler(self._commands)
149
 
 
150
 
    def startElement(self, name, attrs):
151
 
        if name == EXML_ERROR:
152
 
            pattern = attrs.get(EXML_PATTERN, None)
153
 
            if pattern is not None:
154
 
                self._errpat = re.compile(pattern)
155
 
        elif name == EXML_HOTSPOT:
156
 
            pattern = attrs.get(EXML_PATTERN, None)
157
 
            if pattern is not None:
158
 
                self._hotspot = re.compile(pattern)
159
 
        else:
160
 
            syntax.EditraXml.startElement(self, name, attrs)
161
 
 
162
 
    #---- External Api ----#
163
 
 
164
 
    def GetCommands(self):
165
 
        """Get the dictionary of commands
166
 
        @return: dict(alias="command string")
167
 
 
168
 
        """
169
 
        cmdxml = self.GetCommandsXml()
170
 
        return cmdxml.GetCommands()
171
 
 
172
 
    def GetCommandsXml(self):
173
 
        """Get the CommandList Xml object
174
 
        @return: CommandList
175
 
 
176
 
        """
177
 
        return self._commands
178
 
 
179
 
    def GetDefaultCommand(self):
180
 
        """Get the default command
181
 
        @return: string
182
 
 
183
 
        """
184
 
        cmdxml = self.GetCommandsXml()
185
 
        return cmdxml.GetDefault()
186
 
 
187
 
    def GetErrorPattern(self):
188
 
        """Get the error pattern object
189
 
        @return: re object or None
190
 
 
191
 
        """
192
 
        return self._errpat
193
 
 
194
 
    def GetHotSpotPattern(self):
195
 
        """Get the hotspot pattern object
196
 
        @return: re object or None
197
 
 
198
 
        """
199
 
        return self._hotspot
200
 
 
201
 
    def GetLang(self):
202
 
        """Get the language identifier string
203
 
        @return: string
204
 
 
205
 
        """
206
 
        return self._lang
207
 
 
208
 
    def GetLangId(self):
209
 
        """Get the language identifer
210
 
        @return: int
211
 
 
212
 
        """
213
 
        return self._langid
214
 
 
215
 
#-----------------------------------------------------------------------------#
216
 
 
217
 
class CommandList(syntax.EditraXml):
218
 
    """Handler object data"""
219
 
    def __init__(self):
220
 
        syntax.EditraXml.__init__(self)
221
 
 
222
 
        # Attributes
223
 
        self._default = u''
224
 
        self._commands = dict()
225
 
 
226
 
        # Setup
227
 
        self.SetName(EXML_COMMANDLIST)
228
 
 
229
 
    def startElement(self, name, attrs):
230
 
        if name == EXML_COMMAND:
231
 
            alias = attrs.get(syntax.EXML_NAME, None)
232
 
            cmd = attrs.get(EXML_EXECUTE, None)
233
 
            if None not in (alias, cmd):
234
 
                self._commands[alias] = cmd
235
 
        elif name == EXML_COMMANDLIST:
236
 
            default = attrs.get(EXML_DEFAULT, None)
237
 
            assert default is not None, "Default attribute not specified!"
238
 
            self._default = default
239
 
 
240
 
    #---- External Api ----#
241
 
 
242
 
    def GetCommands(self):
243
 
        """Get the mapping of command aliases to commands
244
 
        @return: dict
245
 
 
246
 
        """
247
 
        return self._commands
248
 
 
249
 
    def GetDefault(self):
250
 
        """Get the default command
251
 
        @return: string
252
 
 
253
 
        """
254
 
        return self._default
255
 
 
256
 
#-----------------------------------------------------------------------------#
257
 
 
 
138
        for handler in self.handlers:
 
139
            if handler.name == name:
 
140
                return True
 
141
        return False
 
142
 
 
143
#-----------------------------------------------------------------------------#
258
144
# Test
259
 
if __name__ == '__main__':
260
 
    h = LaunchXml()
261
 
#    sax.parseString(xml_spec, h)
262
 
    f = open("launch.xml", 'rb')
263
 
    txt = f.read()
264
 
    f.close()
265
 
    sax.parseString(txt, h)
266
 
    hndlr = h.GetHandler('Python')
267
 
    print hndlr.GetCommands()
268
 
    print hndlr.GetErrorPattern()
269
 
    print hndlr.GetDefaultCommand()
270
 
    print hndlr.GetHotSpotPattern()
271
 
 
272
 
    print h.GetHandlers()
273
 
 
274
 
    hndlr = h.GetHandler('C')
275
 
    print hndlr.GetCommands()
 
145
#if __name__ == '__main__':
 
146
#    h = LaunchXml.Load("launch.xml")
 
147
#    print "CHECK Python Handler"
 
148
#    hndlr = h.GetHandler('Python')
 
149
#    print hndlr.GetCommands()
 
150
#    print hndlr.error.pattern
 
151
#    print hndlr.hotspot.pattern
 
152
#    print hndlr.commandlist.default
 
153
 
 
154
#    print h.GetHandlers()
 
155
 
 
156
#    print "Check C Handler"
 
157
#    hndlr = h.GetHandler('C')
 
158
#    print hndlr.GetCommands()
 
159
#    print hndlr.GetHotspotPattern()
 
160
#    print hndlr.GetErrorPattern()
 
161
#    print hndlr.GetDefaultCommand()
 
162