← Back to branch summary

~ubuntu-branches/ubuntu/trusty/boa-constructor/trusty

« back to all changes in this revision

Viewing changes to Explorers/EditorExplorer.py

  • Committer: Bazaar Package Importer
  • Author(s): Cédric Delfosse
  • Date: 2007-01-23 21:32:29 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20070123213229-1d9lxp9c4dutjwv5
http://bugs.debian.org/349081
Add a .desktop file (Closes: #349081)

Show diffs side-by-side

added added

removed removed

Lines of Context:
Explorers/EditorExplorer.py
1
 
#-----------------------------------------------------------------------------
2
 
# Name:        EditorExplorer.py
3
 
# Purpose:     
4
 
#
5
 
# Author:      Riaan Booysem
6
 
#
7
 
# Created:     2002
8
 
# RCS-ID:      $Id: EditorExplorer.py,v 1.8 2004/08/16 13:22:00 riaan Exp $
9
 
# Copyright:   (c) 2002 - 2004
10
 
# Licence:     GPL
11
 
#-----------------------------------------------------------------------------
12
 
import os
13
 
 
14
 
from wxPython import wx
15
 
 
16
 
import Preferences, Utils
17
 
 
18
 
import ExplorerNodes
19
 
from Models import EditorHelper
20
 
 
21
 
true=1;false=0
22
 
 
23
 
[wxID_EDTGOTO, wxID_EDTRELOAD, wxID_EDTCLOSE, wxID_EDTCLOSEALL, wxID_EDTMOVEUP, 
24
 
 wxID_EDTMOVEDOWN, wxID_EDTCOPYPATH] = Utils.wxNewIds(7)
25
 
 
26
 
class EditorController(ExplorerNodes.Controller):
27
 
    closeBmp = 'Images/Editor/Close.png'
28
 
    moveUpBmp = 'Images/Shared/up.png'
29
 
    moveDownBmp = 'Images/Shared/down.png'
30
 
 
31
 
    def __init__(self, editor, list, inspector, controllers):
32
 
        ExplorerNodes.Controller.__init__(self, editor)
33
 
        self.list = list
34
 
        self.menu = wx.wxMenu()
35
 
 
36
 
        self.editorMenuDef = [ 
37
 
           (wxID_EDTGOTO, 'Goto', self.OnGotoModel, '-'),
38
 
           (-1, '-', None, ''),
39
 
           (wxID_EDTRELOAD, 'Refresh', self.OnReloadItems, '-'),
40
 
           (-1, '-', None, '-'),
41
 
           (wxID_EDTCLOSE, 'Close', self.OnCloseModels, self.closeBmp),
42
 
           (wxID_EDTCLOSEALL, 'Close all', self.OnCloseAllModels, '-'),
43
 
           (-1, '-', None, ''),
44
 
           (wxID_EDTMOVEUP, 'Move up', self.OnMoveModelUp, self.moveUpBmp),
45
 
           (wxID_EDTMOVEDOWN, 'Move down', self.OnMoveModelDown, self.moveDownBmp),
46
 
           (-1, '-', None, '-'),
47
 
           (wxID_EDTCOPYPATH, 'Copy filepath(s) to clipboard', self.OnCopyPath, '-'),
48
 
        ]
49
 
 
50
 
        self.setupMenu(self.menu, self.list, self.editorMenuDef)
51
 
        self.toolbarMenus = [self.editorMenuDef]
52
 
 
53
 
    def destroy(self):
54
 
        self.editorMenuDef = ()
55
 
        self.toolbarMenus = ()
56
 
        self.menu.Destroy()
57
 
 
58
 
    def editorUpdateNotify(self, info=''):
59
 
        self.OnReloadItems()
60
 
 
61
 
    def OnReloadItems(self, event=None):
62
 
        if self.list.node:
63
 
            self.list.refreshCurrent()
64
 
 
65
 
    def OnCloseModels(self, event):
66
 
        if self.list.node:
67
 
            ms = self.list.getMultiSelection()
68
 
            nodes = self.getNodesForSelection(ms)
69
 
            for node in nodes:
70
 
                self.editor.closeModulePage(node.modulePage)
71
 
 
72
 
    def moveModel(self, node, idx, direc):
73
 
        page = self.editor.tabs.GetPage(idx)
74
 
        text = self.editor.tabs.GetPageText(idx)
75
 
        imgIdx = self.editor.tabs.GetPageImage(idx)
76
 
        self.editor.tabs.RemovePage(idx)
77
 
        self.editor.tabs.InsertPage(idx+direc, page, text, false, imgIdx)
78
 
 
79
 
        # swap the two tIdx's
80
 
        for modPage in self.editor.modules.values():
81
 
            if modPage.tIdx == idx:
82
 
                modPage.tIdx = idx + direc
83
 
            elif modPage.tIdx == idx + direc:
84
 
                modPage.tIdx = idx
85
 
 
86
 
        self.list.refreshCurrent()
87
 
        self.list.selectItemByIdx(idx+direc-1)
88
 
 
89
 
    def OnMoveModelUp(self, event):
90
 
        if self.list.node:
91
 
            ms = self.list.getMultiSelection()
92
 
            nodes = self.getNodesForSelection(ms)
93
 
            if len(nodes) != 1:
94
 
                wx.wxLogError('Can only move 1 at a time')
95
 
            else:
96
 
                node = nodes[0]
97
 
                idx = node.modulePage.tIdx
98
 
                if idx == 2:
99
 
                    wx.wxLogError('Already at the beginning')
100
 
                else:
101
 
                    self.moveModel(node, idx, -1)
102
 
 
103
 
    def OnMoveModelDown(self, event):
104
 
        if self.list.node:
105
 
            ms = self.list.getMultiSelection()
106
 
            nodes = self.getNodesForSelection(ms)
107
 
            if len(nodes) != 1:
108
 
                wx.wxLogError('Can only move 1 at a time')
109
 
            else:
110
 
                node = nodes[0]
111
 
                idx = node.modulePage.tIdx
112
 
                if idx == self.editor.tabs.GetPageCount() -1:
113
 
                    wx.wxLogError('Already at the end')
114
 
                else:
115
 
                    self.moveModel(node, idx, 1)
116
 
 
117
 
    def OnGotoModel(self, event):
118
 
        if self.list.node:
119
 
            ms = self.list.getMultiSelection()
120
 
            nodes = self.getNodesForSelection(ms)
121
 
            if len(nodes) != 1:
122
 
                wx.wxLogError('Can only goto 1 at a time')
123
 
            else:
124
 
                nodes[0].open(self.editor)
125
 
 
126
 
    def OnCopyPath(self, event):
127
 
        if self.list.node:
128
 
            ms = self.list.getMultiSelection()
129
 
            nodes = self.getNodesForSelection(ms)
130
 
            paths = []
131
 
            for node in nodes:
132
 
                paths.append(node.resourcepath)
133
 
            Utils.writeTextToClipboard(os.linesep.join(paths))
134
 
 
135
 
    def OnCloseAllModels(self, event):
136
 
        if self.list.node:
137
 
            for node in self.list.items:
138
 
                self.editor.closeModulePage(node.modulePage)
139
 
 
140
 
class OpenModelsNode(ExplorerNodes.ExplorerNode):
141
 
    protocol = 'boa.open-models'
142
 
    def __init__(self, editor, parent):
143
 
        ExplorerNodes.ExplorerNode.__init__(self, 'Editor', '', None,
144
 
              EditorHelper.imgOpenEditorModels, None, {})
145
 
        self.editor = editor
146
 
        self.bold = true
147
 
        self.vetoSort = true
148
 
 
149
 
    def notifyBeginLabelEdit(self, event):
150
 
        event.Veto()
151
 
 
152
 
    def isFolderish(self):
153
 
        return true
154
 
 
155
 
    def createChildNode(self, name, modulePage):
156
 
        return OpenModelItemNode(modulePage.updatePageName(), name, modulePage, self)
157
 
 
158
 
    def openList(self):
159
 
        res = []
160
 
        mods = []
161
 
        for name, modPage in self.editor.modules.items():
162
 
            mods.append( (modPage.tIdx, name, modPage) )
163
 
 
164
 
        mods.sort()
165
 
        for idx, name, modPage in mods:
166
 
            res.append(self.createChildNode(name, modPage))
167
 
        return res
168
 
 
169
 
 
170
 
class OpenModelItemNode(ExplorerNodes.ExplorerNode):
171
 
    protocol = 'boa.model'
172
 
    def __init__(self, name, resourcepath, modulePage, parent):
173
 
        ExplorerNodes.ExplorerNode.__init__(self, name, resourcepath, None,
174
 
              modulePage.model.imgIdx, parent, {})
175
 
        self.modulePage = modulePage
176
 
        self.model = modulePage.model
177
 
 
178
 
    def notifyBeginLabelEdit(self, event):
179
 
        event.Veto()
180
 
 
181
 
    def isFolderish(self):
182
 
        return false
183
 
 
184
 
    def open(self, editor):
185
 
        if not os.path.split(self.resourcepath)[0]:
186
 
            # unsaved, manually get info and switch to page
187
 
            modPage = editor.modules[self.resourcepath]
188
 
            modPage.focus()
189
 
            model = modPage.model
190
 
            ctrlr = editor.getControllerFromModel(model)
191
 
            return model, ctrlr
192
 
        else:
193
 
            return editor.openOrGotoModule(self.resourcepath)
194
 
 
195
 
 
196
 
class ModelViewItemNode(ExplorerNodes.ExplorerNode):
197
 
    protocol = 'boa.view'
198
 
    def __init__(self, name, model, parent):
199
 
        ExplorerNodes.ExplorerNode.__init__(self, name, '', None,
200
 
              EditorHelper.imgFolder, parent, {})
201
 
        self.model = model
202
 
 
203
 
    def notifyBeginLabelEdit(self, event):
204
 
        event.Veto()
205
 
 
206
 
    def isFolderish(self):
207
 
        return true
208
 
 
209
 
    def openList(self):
210
 
        res = []
211
 
        for item in self.model.views[self.name].explore():
212
 
            res.append(ViewItemNode(item, '', None, -1, self, {}))
213
 
        return res
214
 
 
215
 
class ViewItemNode(ExplorerNodes.ExplorerNode):
216
 
    def open(self, editor):
217
 
        pass
218
 
 
219
 
#-------------------------------------------------------------------------------
220
 
 
221
 
wxID_NEWCREATE = wx.wxNewId()
222
 
class EditorNewController(ExplorerNodes.Controller):
223
 
    createBmp = 'Images/Editor/Close.png'
224
 
 
225
 
    def __init__(self, editor, list):
226
 
        ExplorerNodes.Controller.__init__(self, editor)
227
 
        self.list = list
228
 
        self.menu = wx.wxMenu()
229
 
 
230
 
        self.editorMenuDef = ( (wxID_NEWCREATE, 'Create', self.OnCreate, '-'), )
231
 
 
232
 
        self.setupMenu(self.menu, self.list, self.editorMenuDef)
233
 
        self.toolbarMenus = [self.editorMenuDef]
234
 
 
235
 
    def destroy(self):
236
 
        self.editorMenuDef = ()
237
 
        self.toolbarMenus = ()
238
 
        self.menu.Destroy()
239
 
 
240
 
    def OnCreate(self, event):
241
 
        print 'Create'
242
 
 
243
 
class NewPaletteNode(ExplorerNodes.ExplorerNode):
244
 
    protocol = 'boa.new-palette'
245
 
    def __init__(self, editor, parent):
246
 
        ExplorerNodes.ExplorerNode.__init__(self, 'Editor', '', None,
247
 
              EditorHelper.imgOpenEditorModels, None, {})
248
 
        self.editor = editor
249
 
        self.bold = true
250
 
        self.vetoSort = true
251
 
 
252
 
    def isFolderish(self):
253
 
        return true
254
 
 
255
 
    def createChildNode(self, name, modulePage):
256
 
        return NewPaletteItemNode(modulePage.updatePageName(), name, modulePage, self)
257
 
 
258
 
    def openList(self):
259
 
        res = []
260
 
        mods = []
261
 
        for name, modPage in self.editor.modules.items():
262
 
            mods.append( (modPage.tIdx, name, modPage) )
263
 
 
264
 
        mods.sort()
265
 
        for idx, name, modPage in mods:
266
 
            res.append(self.createChildNode(name, modPage))
267
 
        return res
268
 
 
269
 
 
270
 
class NewPaletteItemNode(ExplorerNodes.ExplorerNode):
271
 
    protocol = 'boa.new-item'
272
 
    def __init__(self, name, resourcepath, palette, newitem):
273
 
        ExplorerNodes.ExplorerNode.__init__(self, name, resourcepath, None,
274
 
              modulePage.model.imgIdx, parent, {})
275
 
 
276
 
    def notifyBeginLabelEdit(self, event):
277
 
        event.Veto()
278
 
 
279
 
    def isFolderish(self):
280
 
        return false
281
 
 
282
 
#-------------------------------------------------------------------------------
283
 
ExplorerNodes.register(OpenModelsNode, controller=EditorController)
 
1
#-----------------------------------------------------------------------------
 
2
# Name:        EditorExplorer.py
 
3
# Purpose:
 
4
#
 
5
# Author:      Riaan Booysem
 
6
#
 
7
# Created:     2002
 
8
# RCS-ID:      $Id: EditorExplorer.py,v 1.10 2005/05/13 20:41:59 riaan Exp $
 
9
# Copyright:   (c) 2002 - 2005
 
10
# Licence:     GPL
 
11
#-----------------------------------------------------------------------------
 
12
import os
 
13
 
 
14
import wx
 
15
 
 
16
import Preferences, Utils
 
17
 
 
18
import ExplorerNodes
 
19
from Models import EditorHelper
 
20
 
 
21
[wxID_EDTGOTO, wxID_EDTRELOAD, wxID_EDTCLOSE, wxID_EDTCLOSEALL, wxID_EDTMOVEUP,
 
22
 wxID_EDTMOVEDOWN, wxID_EDTCOPYPATH] = Utils.wxNewIds(7)
 
23
 
 
24
class EditorController(ExplorerNodes.Controller):
 
25
    closeBmp = 'Images/Editor/Close.png'
 
26
    moveUpBmp = 'Images/Shared/up.png'
 
27
    moveDownBmp = 'Images/Shared/down.png'
 
28
 
 
29
    def __init__(self, editor, list, inspector, controllers):
 
30
        ExplorerNodes.Controller.__init__(self, editor)
 
31
        self.list = list
 
32
        self.menu = wx.Menu()
 
33
 
 
34
        self.editorMenuDef = [
 
35
           (wxID_EDTGOTO, 'Goto', self.OnGotoModel, '-'),
 
36
           (-1, '-', None, ''),
 
37
           (wxID_EDTRELOAD, 'Refresh', self.OnReloadItems, '-'),
 
38
           (-1, '-', None, '-'),
 
39
           (wxID_EDTCLOSE, 'Close', self.OnCloseModels, self.closeBmp),
 
40
           (wxID_EDTCLOSEALL, 'Close all', self.OnCloseAllModels, '-'),
 
41
           (-1, '-', None, ''),
 
42
           (wxID_EDTMOVEUP, 'Move up', self.OnMoveModelUp, self.moveUpBmp),
 
43
           (wxID_EDTMOVEDOWN, 'Move down', self.OnMoveModelDown, self.moveDownBmp),
 
44
           (-1, '-', None, '-'),
 
45
           (wxID_EDTCOPYPATH, 'Copy filepath(s) to clipboard', self.OnCopyPath, '-'),
 
46
        ]
 
47
 
 
48
        self.setupMenu(self.menu, self.list, self.editorMenuDef)
 
49
        self.toolbarMenus = [self.editorMenuDef]
 
50
 
 
51
    def destroy(self):
 
52
        self.editorMenuDef = ()
 
53
        self.toolbarMenus = ()
 
54
        self.menu.Destroy()
 
55
 
 
56
    def editorUpdateNotify(self, info=''):
 
57
        self.OnReloadItems()
 
58
 
 
59
    def OnReloadItems(self, event=None):
 
60
        if self.list.node:
 
61
            self.list.refreshCurrent()
 
62
 
 
63
    def OnCloseModels(self, event):
 
64
        if self.list.node:
 
65
            ms = self.list.getMultiSelection()
 
66
            nodes = self.getNodesForSelection(ms)
 
67
            for node in nodes:
 
68
                self.editor.closeModulePage(node.modulePage)
 
69
 
 
70
    def moveModel(self, node, idx, direc):
 
71
        page = self.editor.tabs.GetPage(idx)
 
72
        text = self.editor.tabs.GetPageText(idx)
 
73
        imgIdx = self.editor.tabs.GetPageImage(idx)
 
74
        self.editor.tabs.RemovePage(idx)
 
75
        self.editor.tabs.InsertPage(idx+direc, page, text, False, imgIdx)
 
76
 
 
77
        # swap the two tIdx's
 
78
        for modPage in self.editor.modules.values():
 
79
            if modPage.tIdx == idx:
 
80
                modPage.tIdx = idx + direc
 
81
            elif modPage.tIdx == idx + direc:
 
82
                modPage.tIdx = idx
 
83
 
 
84
        self.list.refreshCurrent()
 
85
        self.list.selectItemByIdx(idx+direc-1)
 
86
 
 
87
    def OnMoveModelUp(self, event):
 
88
        if self.list.node:
 
89
            ms = self.list.getMultiSelection()
 
90
            nodes = self.getNodesForSelection(ms)
 
91
            if len(nodes) != 1:
 
92
                wx.LogError('Can only move 1 at a time')
 
93
            else:
 
94
                node = nodes[0]
 
95
                idx = node.modulePage.tIdx
 
96
                if idx == 2:
 
97
                    wx.LogError('Already at the beginning')
 
98
                else:
 
99
                    self.moveModel(node, idx, -1)
 
100
 
 
101
    def OnMoveModelDown(self, event):
 
102
        if self.list.node:
 
103
            ms = self.list.getMultiSelection()
 
104
            nodes = self.getNodesForSelection(ms)
 
105
            if len(nodes) != 1:
 
106
                wx.LogError('Can only move 1 at a time')
 
107
            else:
 
108
                node = nodes[0]
 
109
                idx = node.modulePage.tIdx
 
110
                if idx == self.editor.tabs.GetPageCount() -1:
 
111
                    wx.LogError('Already at the end')
 
112
                else:
 
113
                    self.moveModel(node, idx, 1)
 
114
 
 
115
    def OnGotoModel(self, event):
 
116
        if self.list.node:
 
117
            ms = self.list.getMultiSelection()
 
118
            nodes = self.getNodesForSelection(ms)
 
119
            if len(nodes) != 1:
 
120
                wx.LogError('Can only goto 1 at a time')
 
121
            else:
 
122
                nodes[0].open(self.editor)
 
123
 
 
124
    def OnCopyPath(self, event):
 
125
        if self.list.node:
 
126
            ms = self.list.getMultiSelection()
 
127
            nodes = self.getNodesForSelection(ms)
 
128
            paths = []
 
129
            for node in nodes:
 
130
                paths.append(node.resourcepath)
 
131
            Utils.writeTextToClipboard(os.linesep.join(paths))
 
132
 
 
133
    def OnCloseAllModels(self, event):
 
134
        if self.list.node:
 
135
            for node in self.list.items:
 
136
                self.editor.closeModulePage(node.modulePage)
 
137
 
 
138
class OpenModelsNode(ExplorerNodes.ExplorerNode):
 
139
    protocol = 'boa.open-models'
 
140
    def __init__(self, editor, parent):
 
141
        ExplorerNodes.ExplorerNode.__init__(self, 'Editor', '', None,
 
142
              EditorHelper.imgOpenEditorModels, None, {})
 
143
        self.editor = editor
 
144
        self.bold = True
 
145
        self.vetoSort = True
 
146
 
 
147
    def notifyBeginLabelEdit(self, event):
 
148
        event.Veto()
 
149
 
 
150
    def isFolderish(self):
 
151
        return True
 
152
 
 
153
    def createChildNode(self, name, modulePage):
 
154
        return OpenModelItemNode(modulePage.updatePageName(), name, modulePage, self)
 
155
 
 
156
    def openList(self):
 
157
        res = []
 
158
        mods = []
 
159
        for name, modPage in self.editor.modules.items():
 
160
            mods.append( (modPage.tIdx, name, modPage) )
 
161
 
 
162
        mods.sort()
 
163
        for idx, name, modPage in mods:
 
164
            res.append(self.createChildNode(name, modPage))
 
165
        return res
 
166
 
 
167
 
 
168
class OpenModelItemNode(ExplorerNodes.ExplorerNode):
 
169
    protocol = 'boa.model'
 
170
    def __init__(self, name, resourcepath, modulePage, parent):
 
171
        ExplorerNodes.ExplorerNode.__init__(self, name, resourcepath, None,
 
172
              modulePage.model.imgIdx, parent, {})
 
173
        self.modulePage = modulePage
 
174
        self.model = modulePage.model
 
175
 
 
176
    def notifyBeginLabelEdit(self, event):
 
177
        event.Veto()
 
178
 
 
179
    def isFolderish(self):
 
180
        return False
 
181
 
 
182
    def open(self, editor):
 
183
        if not os.path.split(self.resourcepath)[0]:
 
184
            # unsaved, manually get info and switch to page
 
185
            modPage = editor.modules[self.resourcepath]
 
186
            modPage.focus()
 
187
            model = modPage.model
 
188
            ctrlr = editor.getControllerFromModel(model)
 
189
            return model, ctrlr
 
190
        else:
 
191
            return editor.openOrGotoModule(self.resourcepath)
 
192
 
 
193
 
 
194
class ModelViewItemNode(ExplorerNodes.ExplorerNode):
 
195
    protocol = 'boa.view'
 
196
    def __init__(self, name, model, parent):
 
197
        ExplorerNodes.ExplorerNode.__init__(self, name, '', None,
 
198
              EditorHelper.imgFolder, parent, {})
 
199
        self.model = model
 
200
 
 
201
    def notifyBeginLabelEdit(self, event):
 
202
        event.Veto()
 
203
 
 
204
    def isFolderish(self):
 
205
        return True
 
206
 
 
207
    def openList(self):
 
208
        res = []
 
209
        for item in self.model.views[self.name].explore():
 
210
            res.append(ViewItemNode(item, '', None, -1, self, {}))
 
211
        return res
 
212
 
 
213
class ViewItemNode(ExplorerNodes.ExplorerNode):
 
214
    def open(self, editor):
 
215
        pass
 
216
 
 
217
#-------------------------------------------------------------------------------
 
218
 
 
219
wxID_NEWCREATE = wx.NewId()
 
220
class EditorNewController(ExplorerNodes.Controller):
 
221
    createBmp = 'Images/Editor/Close.png'
 
222
 
 
223
    def __init__(self, editor, list):
 
224
        ExplorerNodes.Controller.__init__(self, editor)
 
225
        self.list = list
 
226
        self.menu = wx.Menu()
 
227
 
 
228
        self.editorMenuDef = ( (wxID_NEWCREATE, 'Create', self.OnCreate, '-'), )
 
229
 
 
230
        self.setupMenu(self.menu, self.list, self.editorMenuDef)
 
231
        self.toolbarMenus = [self.editorMenuDef]
 
232
 
 
233
    def destroy(self):
 
234
        self.editorMenuDef = ()
 
235
        self.toolbarMenus = ()
 
236
        self.menu.Destroy()
 
237
 
 
238
    def OnCreate(self, event):
 
239
        print 'Create'
 
240
 
 
241
class NewPaletteNode(ExplorerNodes.ExplorerNode):
 
242
    protocol = 'boa.new-palette'
 
243
    def __init__(self, editor, parent):
 
244
        ExplorerNodes.ExplorerNode.__init__(self, 'Editor', '', None,
 
245
              EditorHelper.imgOpenEditorModels, None, {})
 
246
        self.editor = editor
 
247
        self.bold = True
 
248
        self.vetoSort = True
 
249
 
 
250
    def isFolderish(self):
 
251
        return True
 
252
 
 
253
    def createChildNode(self, name, modulePage):
 
254
        return NewPaletteItemNode(modulePage.updatePageName(), name, modulePage, self)
 
255
 
 
256
    def openList(self):
 
257
        res = []
 
258
        mods = []
 
259
        for name, modPage in self.editor.modules.items():
 
260
            mods.append( (modPage.tIdx, name, modPage) )
 
261
 
 
262
        mods.sort()
 
263
        for idx, name, modPage in mods:
 
264
            res.append(self.createChildNode(name, modPage))
 
265
        return res
 
266
 
 
267
 
 
268
class NewPaletteItemNode(ExplorerNodes.ExplorerNode):
 
269
    protocol = 'boa.new-item'
 
270
    def __init__(self, name, resourcepath, palette, newitem):
 
271
        ExplorerNodes.ExplorerNode.__init__(self, name, resourcepath, None,
 
272
              modulePage.model.imgIdx, parent, {})
 
273
 
 
274
    def notifyBeginLabelEdit(self, event):
 
275
        event.Veto()
 
276
 
 
277
    def isFolderish(self):
 
278
        return False
 
279
 
 
280
#-------------------------------------------------------------------------------
 
281
ExplorerNodes.register(OpenModelsNode, controller=EditorController)