~iferca/yape/trunk

« back to all changes in this revision

Viewing changes to yape.py

  • Committer: Israel Fernández Cabrera
  • Date: 2008-10-03 21:12:17 UTC
  • Revision ID: iferca@gmail.com-20081003211217-uu1df2ucq3wd67nd
YaPe project moved to the new YaPe project structure. Old one will work fine but it was not suitable for the next development phases

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
3
 
 
4
 
__license__ = """YaPe, Yet Another Python Editor
5
 
Copyright 2007-2008 Israel Fernández Cabrera <iferca@gmail.com>
6
 
 
7
 
YaPe is free software; you can redistribute it and/or modify it
8
 
under the terms of the GNU General Public License as published by the Free
9
 
Software Foundation; either version 2 of the License, or (at your option)
10
 
any later version.
11
 
 
12
 
This program is distributed in the hope that it will be useful, but WITHOUT
13
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
 
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15
 
more details.
16
 
 
17
 
You should have received a copy of the GNU General Public License along with
18
 
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19
 
Place, Suite 330, Boston, MA  02111-1307  USA.
20
 
"""
21
 
__version__ = "0.8.5-10"
22
 
 
23
 
 
24
 
import sys
25
 
import os
26
 
import pygtk
27
 
pygtk.require('2.0')
28
 
import gtk
29
 
import terminal
30
 
import panelmanager
31
 
import localgtk
32
 
import errors
33
 
import utils
34
 
from editor.editormanager import EditorManager
35
 
from signalhandler import SignalConnector
36
 
from settings.config import Config
37
 
from settings.settingsdialog import SettingsDialog
38
 
from project.projectbrowser import ProjectBrowser
39
 
from classnavigator import ClassNavigatorBar, ClassNavigatorPanel
40
 
from configfactory import ConfigFactory
41
 
from statusbarmanager import StatusBarManager
42
 
from operations import Operations, showNoProjectOpenError
43
 
 
44
 
 
45
 
class ClipboardProxy(object):
46
 
    def __init__(self, mainWindow):
47
 
        self._window = mainWindow
48
 
        sc = SignalConnector.getInstance()
49
 
        sc.registerCallback("COPY", self._copyToClipboard)
50
 
        sc.registerCallback("TOOL_COPY", self._copyToClipboard)
51
 
        sc.registerCallback("CUT", self._cutToClipboard)
52
 
        sc.registerCallback("TOOL_CUT", self._cutToClipboard)
53
 
        sc.registerCallback("PASTE", self._pasteFromClipboard)
54
 
        sc.registerCallback("TOOL_PASTE", self._pasteFromClipboard)
55
 
        sc.registerCallback("DELETE", self._deleteSelection)
56
 
 
57
 
    def _deleteSelection(self, widget):
58
 
        activeWidget = self._window.get_focus()
59
 
        if (hasattr(activeWidget, "delete_selection")):
60
 
            activeWidget.delete_selection()
61
 
 
62
 
    def _cutToClipboard(self, widget):
63
 
        activeWidget = self._window.get_focus()
64
 
        if (hasattr(activeWidget, "cut_clipboard")):
65
 
            activeWidget.cut_clipboard()
66
 
 
67
 
    def _copyToClipboard(self, widget):
68
 
        activeWidget = self._window.get_focus()
69
 
        if (type(activeWidget) is terminal.Terminal):
70
 
            return False
71
 
        if (hasattr(activeWidget, "copy_clipboard")):
72
 
            activeWidget.copy_clipboard()
73
 
 
74
 
    def _pasteFromClipboard(self, widget):
75
 
        activeWidget = self._window.get_focus()
76
 
        if (hasattr(activeWidget, "paste_clipboard")):
77
 
            activeWidget.paste_clipboard()
78
 
 
79
 
 
80
 
"""
81
 
Yape's Main Window
82
 
"""
83
 
class Yape(localgtk.GladeInterface):
84
 
    def __init__(self, argv):
85
 
        self._config = Config()
86
 
        self._config.validateDefaultConfig(os.path.dirname(os.path.abspath(__file__)))
87
 
        super(Yape, self).__init__("yape.glade")
88
 
        #this line should be close to the first lines because of the initialization.
89
 
        self.signalConnector = SignalConnector.getInstance()
90
 
        self.signalConnector.setWidgetTree(self.getWidgetTree())
91
 
        self.signalConnector.registerSignalObserver("UpdateCursorPosition", self)
92
 
        #Operations actually uses SignalConnector but don't initialize it, so must always be after SignalConnector first instantiation
93
 
        self._operations = Operations()
94
 
        self._window.maximize()
95
 
        self._initialSettings()
96
 
        self._initializeGUI()
97
 
        self._window.connect("delete-event", self.quitApplication)
98
 
        self._registerSignals()
99
 
        self.cbProxy = ClipboardProxy(self._window)
100
 
        self._createClassNavigator()
101
 
        self._createProjectBrowser()
102
 
        self._createEditorManager()
103
 
        self._createPanelManagers()
104
 
        self._statusManager = StatusBarManager(self._statusBar, self._progressStatus)
105
 
        localgtk.setWindowIcon(self._window, "yape.svg")
106
 
        self._window.show()
107
 
        self._handleApplicationArguments(argv)
108
 
 
109
 
    def _handleApplicationArguments(self, argv):
110
 
        if len(argv) > 1:
111
 
            path = os.path.abspath(argv[1])
112
 
            if path.endswith(".yape"):
113
 
                self._operations.openProject(projectName=path)
114
 
            elif path.endswith(".py"):
115
 
                self._operations.openFile(path)
116
 
 
117
 
    def notifyUpdateCursorPosition(self, x, y):
118
 
        self._lineLabel.set_text(str(y))
119
 
        self._colLabel.set_text(str(x))
120
 
 
121
 
    def showAbout(self, widget):
122
 
        """
123
 
        Call back method to show the About dialog
124
 
        """
125
 
        about = gtk.AboutDialog()
126
 
        localgtk.setWindowIcon(about, "yape.svg")
127
 
        about.set_version(__version__)
128
 
        about.set_name("YaPe")
129
 
        about.set_license(__license__)
130
 
        about.set_copyright("Copyright 2007-2008, Israel Fernández Cabrera & Pável Varela Rodríguez")
131
 
        import webbrowser
132
 
        gtk.about_dialog_set_url_hook(lambda dialog, link: webbrowser.open(link))
133
 
        about.set_website("http://launchpad.net/yape")
134
 
        about.set_title("About YaPe")
135
 
        credits = ["Israel Fernández Cabrera <iferca@gmail.com>", 
136
 
                   "Pável Varela Rodríguez <neonskull@gmail.com>"]
137
 
        about.set_authors(credits)
138
 
        artwork = ["Israel Fernández Cabrera <iferca@gmail.com>"]
139
 
        about.set_artists(artwork)
140
 
        about.set_comments("Yet another Python editor\nYaPe is a text editor for Python.")
141
 
        response = about.run()
142
 
        about.destroy()
143
 
 
144
 
    def quitApplication(self, widget, event=None):
145
 
        try:
146
 
            SignalConnector.getInstance().notifyObservers("ApplicationExit")
147
 
            gtk.main_quit()
148
 
            return False
149
 
        except errors.AbortException, e:
150
 
            return True
151
 
 
152
 
    def _initialSettings(self):
153
 
        """
154
 
        Read some parameter from the configuration to starts YaPe with the same
155
 
        visible elements (panels, toolbars, etc) that it has when closed.
156
 
        """
157
 
        try:
158
 
            visible = self._config.getConfig("projecttoolbar_visible")
159
 
            self.getWidget("ProjectToolbarMenuitem").set_active(visible)
160
 
            self.getWidget("ProjectToolbarHandlebox").set_property("visible", visible)
161
 
        except(ValueError):
162
 
            pass
163
 
        try:
164
 
            visible = self._config.getConfig("viewtoolbar_visible")
165
 
            self.getWidget("ViewToolbarMenuitem").set_active(visible)
166
 
            self.getWidget("ViewToolbarHandlebox").set_property("visible", visible)
167
 
        except(ValueError):
168
 
            pass
169
 
        try:
170
 
            visible = self._config.getConfig("maintoolbar_visible")
171
 
            self.getWidget("MainToolbarMenuitem").set_active(visible)
172
 
            self.getWidget("MainToolbarHandlebox").set_property("visible", visible)
173
 
        except(ValueError):
174
 
            pass
175
 
        try:
176
 
            visible = self._config.getConfig("djangotoolbar_visible")
177
 
            self.getWidget("DjangoMenuitem").set_active(visible)
178
 
            self.getWidget("DjangoHandlebox").set_property("visible", visible)
179
 
        except(ValueError):
180
 
            pass
181
 
 
182
 
    def _initializeGUI(self):
183
 
        """
184
 
        Configure son GUI elements: set images, stocks, etc
185
 
        """
186
 
        #New Project Menu option
187
 
        self.__setMenuitemImage("NewProjectMenuitem", "new-project")
188
 
        self.__setMenuitemImage("NewProjectMenuitem2", "new-project")
189
 
        #New Project Tool button
190
 
        newProjectButton = self.getWidget("NewProjectToolbutton")
191
 
        newProjectButton.set_stock_id("new-project")
192
 
        self.__setMenuitemImage("OpenProjectMenuitem", "open-project")
193
 
        #Open Project  Tool button
194
 
        openProjectButton = self.getWidget("OpenProjectToolbutton")
195
 
        openProjectButton.set_stock_id("open-project")
196
 
        #Run Current Script Menu option
197
 
        self.__setMenuitemImage("RunCurrentScriptMenuitem", "run-current-script")
198
 
        runCurrentScriptButton = self.getWidget("RunCurrentScriptToolbutton")
199
 
        runCurrentScriptButton.set_stock_id("run-current-script")
200
 
        #New Class Menu option
201
 
        self.__setMenuitemImage("NewClassMenuitem", "class")
202
 
        #New Django Application Menu option
203
 
        self.__setMenuitemImage("StartAppMenuitem", "new-django-app")
204
 
        newdjangoAppButton = self.getWidget("NewApplicationToolbutton")
205
 
        newdjangoAppButton.set_stock_id("new-django-app")
206
 
        #Run Django Web Server
207
 
        self.__setMenuitemImage("RunServerMenuitem", "django-web-server")
208
 
        runDevServerButton = self.getWidget("RunDevServerToolbutton")
209
 
        runDevServerButton.set_stock_id("django-web-server")
210
 
        #Django Shell Menu option
211
 
        self.__setMenuitemImage("DjangoShellMenuitem", "django-shell")
212
 
        djangoShellButton = self.getWidget("DjangoShellToolbutton")
213
 
        djangoShellButton.set_stock_id("django-shell")
214
 
        #Django Sync DB Menu option
215
 
        self.__setMenuitemImage("DjangoSyncDBMenuitem", "django-sync-db")
216
 
        syncDBButton = self.getWidget("SyncDBToolbutton")
217
 
        syncDBButton.set_stock_id("django-sync-db")
218
 
        #Django Validate Model Menu option
219
 
        self.__setMenuitemImage("ValidateMenuitem", "django-validate-model")
220
 
        validateModelButton = self.getWidget("ValidateModelToolbutton")
221
 
        validateModelButton.set_stock_id("django-validate-model")
222
 
        #Django DB Shell Model Menu option
223
 
        self.__setMenuitemImage("DjangoDBShellMenuitem", "django-db-shell")
224
 
        dbShellButton = self.getWidget("DBShellToolbutton")
225
 
        dbShellButton.set_stock_id("django-db-shell")
226
 
 
227
 
    def __setMenuitemImage(self, widgetName, stockName):
228
 
        self.getWidget(widgetName).set_image(gtk.image_new_from_stock(stockName, gtk.ICON_SIZE_MENU))
229
 
 
230
 
    def _createProjectBrowser(self):
231
 
        ProjectBrowser.registerAsAddin()
232
 
 
233
 
    def _createClassNavigator(self):
234
 
        if (not self._config.getConfig("show_class_browser")):
235
 
            self._config.validateDefaultConfig(os.path.dirname(os.path.abspath(__file__)))
236
 
        editorArea = self.getWidget("EditorContainer")
237
 
        if self._config.getConfig("show_class_browser_as") == "bar":
238
 
            classNavigator = ClassNavigatorBar()
239
 
            editorArea.pack_start(classNavigator, False, True)
240
 
        elif self._config.getConfig("show_class_browser_as") == "panel":
241
 
            ClassNavigatorPanel.registerAsAddin()
242
 
        elif self._config.getConfig("show_class_browser_as") == "both":
243
 
            classNavigator = ClassNavigatorBar()
244
 
            editorArea.pack_start(classNavigator, False, True)
245
 
            ClassNavigatorPanel.registerAsAddin()
246
 
 
247
 
    def _createEditorManager(self):
248
 
        self.signalConnector.registerSignalObserver("EditorStatus", self)
249
 
        editorArea = self.getWidget("EditorContainer")
250
 
        self._editorManager = EditorManager()
251
 
        editorArea.pack_start(self._editorManager)
252
 
        if self._config.getConfig("create_new_file_on_startup"):
253
 
            self._editorManager.createNewEditor()
254
 
 
255
 
    def notifyEditorStatus(self, canUndo, canRedo, canSave, isNew=False):
256
 
        self._setUndoSensitive(canUndo)
257
 
        self._setRedoSensitive(canRedo)
258
 
        self._setSaveSensitive(canSave)
259
 
        self._setReverseSensitive(not isNew)
260
 
 
261
 
    def _setReverseSensitive(self, sensitive):
262
 
        menuitem = self.getWidget("ReverMenuitem")
263
 
        menuitem.set_sensitive(sensitive)
264
 
 
265
 
    def _setSaveSensitive(self, sensitive):
266
 
        menuItem = self.getWidget("saveFileMenuItem")
267
 
        toolbarItem = self.getWidget("saveToolbutton")
268
 
        menuItem.set_sensitive(sensitive)
269
 
        toolbarItem.set_sensitive(sensitive)
270
 
 
271
 
    def _setUndoSensitive(self, sensitive):
272
 
        menuItem = self.getWidget("undoMenuitem")
273
 
        toolbarItem = self.getWidget("undoToolbutton")
274
 
        menuItem.set_sensitive(sensitive)
275
 
        toolbarItem.set_sensitive(sensitive)
276
 
 
277
 
    def _setRedoSensitive(self, sensitive):
278
 
        menuItem = self.getWidget("redoMenuitem")
279
 
        toolbarItem = self.getWidget("redoToolbutton")
280
 
        menuItem.set_sensitive(sensitive)
281
 
        toolbarItem.set_sensitive(sensitive)
282
 
 
283
 
    def closeBottomPanel(self, widget=None):
284
 
        self._toggleBottomMenuOption.set_active(False)
285
 
 
286
 
    def showBottomPanel(self, widget=None):
287
 
        self._toggleBottomMenuOption.set_active(True)
288
 
 
289
 
    def toogleBottomPanel(self, widget=None):
290
 
        self._toggleBottomMenuOption.set_active(not self._toggleBottomMenuOption.get_active())
291
 
 
292
 
    def closeLeftPanel(self, widget=None):
293
 
        self._toggleLeftMenuOption.set_active(False)
294
 
 
295
 
    def showLeftPanel(self, widget=None):
296
 
        self._toggleLeftMenuOption.set_active(True)
297
 
 
298
 
    def toogleLeftPanel(self, widget=None):
299
 
        self._toggleLeftMenuOption.set_active(not self._toggleLeftMenuOption.get_active())
300
 
 
301
 
    def notifyTooglePanel(self, panelName, show):
302
 
        if panelName == "Bottom":
303
 
            if show:
304
 
                self.showBottomPanel()
305
 
            else:
306
 
                self.closeBottomPanel()
307
 
        elif panelName == "Left":
308
 
            if show:
309
 
                self.showLeftPanel()
310
 
            else:
311
 
                self.closeLeftPanel() 
312
 
 
313
 
    def _createPanelManagers(self):
314
 
        def initBottomPanel(config):
315
 
            self.bottomContainer = self.getWidget("BottomContainer")
316
 
            self._toggleBottomMenuOption = self.getWidget("ToggleBottomPanelMenuitem")
317
 
            factory = ConfigFactory.getInstance()
318
 
            self.bottomPanelManager = factory.getPanelManager(name="Bottom",
319
 
                                                              container=self.bottomContainer)
320
 
            signalMap = {"on_ToggleBottomPanelMenuitem_toggled": self._toggleBottomPanel,
321
 
            "on_CloseBottomPanelToolbutton_clicked": self.closeBottomPanel,
322
 
            "on_ToggleBottomPanelToolbutton_clicked": self.toogleBottomPanel,
323
 
            "on_AddBottomPanel_clicked": self.bottomPanelManager.manageAddins,
324
 
            "on_newAddinInstanceAtBottom_clicked": self.bottomPanelManager.duplicateCurrentPanel,
325
 
            "on_zoomCurrentPanelButtom_clicked": self.bottomPanelManager.zoomCurrentPanel}
326
 
            self.signalAutoConnect(signalMap)
327
 
            self.bottomContainer.pack_start(self.bottomPanelManager)
328
 
            try:
329
 
                if (config.getConfig("panels/Bottom/visible")):
330
 
                    self._toggleBottomMenuOption.set_active(True)
331
 
            except(ValueError):
332
 
                pass
333
 
 
334
 
        def initLeftPanel(config):
335
 
            self.leftContainer = self.getWidget("LeftContainer")
336
 
            self._toggleLeftMenuOption = self.getWidget("ToggleLeftPanelMenuitem")
337
 
            factory = ConfigFactory.getInstance()
338
 
            self.leftPanelManager = factory.getPanelManager(name = "Left",
339
 
                                                            container = self.leftContainer)
340
 
            signalMap = {"on_ToggleLeftPanelMenuitem_toggled": self._toggleLeftPanel,
341
 
            "on_CloseLeftPanelToolbutton_clicked": self.closeLeftPanel,
342
 
            "on_ToggleLeftPanelToolbutton_clicked": self.toogleLeftPanel,
343
 
            "on_AddLeftPanel_clicked": self.leftPanelManager.manageAddins,
344
 
            "on_newAddinInstanceAtLeft_clicked": self.leftPanelManager.duplicateCurrentPanel,
345
 
            "on_zoomCurrentPanelLeft_clicked": self.leftPanelManager.zoomCurrentPanel}
346
 
            self.signalAutoConnect(signalMap)
347
 
            self.leftContainer.pack_start(self.leftPanelManager)
348
 
            try:
349
 
                if (config.getConfig("panels/Left/visible")):
350
 
                    self._toggleLeftMenuOption.set_active(True)
351
 
            except(ValueError):
352
 
                pass
353
 
 
354
 
        def initRightPanel(config):
355
 
            self.rightContainer = self.getWidget("RightContainer")
356
 
            toggleMenuOption = self.getWidget("ToggleRightPanelMenuitem")
357
 
            factory = ConfigFactory.getInstance()
358
 
            self.rightPanelManager = factory.getPanelManager(name = "Right",
359
 
                                                             container = self.rightContainer)
360
 
            signalMap = {"on_ToggleRightPanelMenuitem_toggled": self._toggleRightPanel,
361
 
            "on_CloseRightPanelToolbutton_clicked": lambda widget: toggleMenuOption.set_active(False),
362
 
            "on_ToggleRightPanelToolbutton_clicked": 
363
 
                lambda widget: toggleMenuOption.set_active(not toggleMenuOption.get_active()),
364
 
            "on_AddRightPanel_clicked": self.rightPanelManager.manageAddins,
365
 
            "on_newAddinInstanceAtRight_clicked": self.rightPanelManager.duplicateCurrentPanel,
366
 
            "on_zoomCurrentPanelRight_clicked": self.rightPanelManager.zoomCurrentPanel}
367
 
            self.signalAutoConnect(signalMap)
368
 
            self.rightContainer.pack_start(self.rightPanelManager, True, True)
369
 
            try:
370
 
                if (config.getConfig("panels/Right/visible")):
371
 
                    toggleMenuOption.set_active(True)
372
 
            except(ValueError):
373
 
                pass
374
 
 
375
 
        sc = SignalConnector.getInstance()
376
 
        sc.registerSignalObserver("TooglePanel", self)
377
 
        initLeftPanel(self._config)
378
 
        initRightPanel(self._config)
379
 
        initBottomPanel(self._config)
380
 
 
381
 
    def _toggleRightPanel(self, widget = None):
382
 
        if (self.rightContainer.get_property("visible") == True):
383
 
            self.rightContainer.hide()
384
 
            self._config.setConfig("panels/Right/visible", False)
385
 
        else:
386
 
            self._config.setConfig("panels/Right/visible", True)
387
 
            self.rightContainer.show_all()
388
 
 
389
 
    def _toggleLeftPanel(self, widget = None):
390
 
        if (self.leftContainer.get_property("visible") == True):
391
 
            self.leftContainer.hide()
392
 
            self._config.setConfig("panels/Left/visible", False)
393
 
        else:
394
 
            self._config.setConfig("panels/Left/visible", True)
395
 
            self.leftContainer.show_all()
396
 
 
397
 
    def _toggleBottomPanel(self, widget = None):
398
 
        if (self.bottomContainer.get_property("visible") == True):
399
 
            self.bottomContainer.hide()
400
 
            self._config.setConfig("panels/Bottom/visible", False)
401
 
        else:
402
 
            self._config.setConfig("panels/Bottom/visible", True)
403
 
            self.bottomContainer.show_all()
404
 
 
405
 
    def _toggleMainToolbar(self, widget=None):
406
 
        toolbarHandler = self.getWidget("MainToolbarHandlebox")
407
 
        visible = toolbarHandler.get_property("visible")
408
 
        toolbarHandler.set_property("visible", not visible) 
409
 
        self._config.setConfig("maintoolbar_visible", not visible)
410
 
 
411
 
    def _toggleViewToolbar(self, widget=None):
412
 
        toolbarHandler = self.getWidget("ViewToolbarHandlebox")
413
 
        visible = toolbarHandler.get_property("visible")
414
 
        toolbarHandler.set_property("visible", not visible)
415
 
        self._config.setConfig("viewtoolbar_visible", not visible)
416
 
 
417
 
    def _toggleProjectToolbar(self, widget=None):
418
 
        toolbarHandler = self.getWidget("ProjectToolbarHandlebox")
419
 
        visible = toolbarHandler.get_property("visible")
420
 
        toolbarHandler.set_property("visible", not visible)
421
 
        self._config.setConfig("projecttoolbar_visible", not visible)
422
 
 
423
 
    def _toggleDjangoToolbar(self, widget=None):
424
 
        toolbarHandler = self.getWidget("DjangoHandlebox")
425
 
        visible = toolbarHandler.get_property("visible")
426
 
        toolbarHandler.set_property("visible", not visible)
427
 
        self._config.setConfig("djangotoolbar_visible", not visible)
428
 
 
429
 
    def _toggleStatusbar(self, widget):
430
 
        statusbarArea = self.getWidget("StatusAreaContainer")
431
 
        statusbarArea.set_property("visible", not statusbarArea.get_property("visible"))
432
 
 
433
 
    def _managePreferences(self, widget = None):
434
 
        settingsManager = SettingsDialog()
435
 
 
436
 
    def _toggleFullScreen(self, widget):
437
 
        button = self.getWidget("FullScreenToolButton")
438
 
        if (not hasattr(self, "_fullscreen")):
439
 
            self._fullscreen = False
440
 
        if (self._fullscreen):
441
 
            self._window.unfullscreen()
442
 
            self._fullscreen = False
443
 
            button.set_stock_id("gtk-fullscreen")
444
 
        else:
445
 
            self._window.fullscreen()
446
 
            self._fullscreen = True
447
 
            button.set_stock_id("gtk-leave-fullscreen")
448
 
 
449
 
    def _disableDjangoFeaturesFromUI(self):
450
 
        widgets = {"DjangoMenuitem": "djangoViewToolbarMenuItem",
451
 
                   "DjangoHandlebox": "djangoToolBarHandleBox",
452
 
                   "djangoMenuitem": "djangoToolMenuItem"}
453
 
        self.realizeWidgets(widgets)
454
 
        for widgetName in widgets.itervalues():
455
 
            widget = getattr(self, widgetName)
456
 
            widget.hide()
457
 
 
458
 
    def _disbleRefactorFeaturesFromUI(self):
459
 
        widgets = {"RefactorMenuitem": "menuItem",
460
 
        "separatormenuitem10": "separator"}
461
 
        self.realizeWidgets(widgets)
462
 
        for widgetName in widgets.itervalues():
463
 
            widget = getattr(self, widgetName)
464
 
            widget.hide()
465
 
 
466
 
    def _registerSignals(self):
467
 
        """
468
 
        Connects the main window signals and translate glade file's cryptic signal
469
 
        names into human redable (is up to the programer to select a new, redlable name), operation
470
 
        based names. This mechanism allows that any part of the code (addins?) can
471
 
        redefine what should be done with a given user action over the GUI.
472
 
        """
473
 
        #Main Window/Menu/Toolbar related signals
474
 
        signals = (("NEW_FILE", "on_NewPythonFileMenuitem_activate"), ("NEW_CLASS", "on_NewClassMenuitem_activate"),
475
 
        ("NEW_TEXT_FILE", "on_NewPlainTextFileMenuitem_activate"), ("OPEN_FILE", "on_openMenuItem_activate"),
476
 
        ("TOOL_OPEN_FILE", "on_fileOpenToolbutton_clicked"), ("SAVE_FILE", "on_saveFileMenuItem_activate"),
477
 
        ("TOOL_SAVE_FILE", "on_saveToolbutton_clicked"), ("SAVE_FILE_AS", "on_saveAsMenuItem_activate"),
478
 
        ("REVERT_FILE", "on_ReverMenuitem_activate"), ("UNDO", "on_undoMenuitem_activate"), ("TOOL_UNDO", "on_undoToolbutton_clicked"),
479
 
        ("REDO", "on_redoMenuitem_activate"), ("TOOL_REDO", "on_redoToolbutton_clicked"), ("TOOL_NEW_FILE", "on_newFileToolbutton_clicked"),
480
 
        ("COPY", "on_copyMenuItem_activate"), ("TOOL_COPY", "on_copyToolbutton_clicked"), ("CUT", "on_cutToolbutton_clicked"),
481
 
        ("TOOL_CUT", "on_cutMenuItem_activate"), ("PASTE", "on_pasteToolbutton_clicked"),
482
 
        ("TOOL_PASTE", "on_pasteMenuItem_activate"), ("DELETE", "on_deleteMenuItem_activate"), ("QUIT_APP", "on_QuitMenuItem_activate"),
483
 
        ("QUIT_APP", self.quitApplication), ("TOOL_QUIT_APP", "on_QuitToolbutton_clicked"), ("TOOL_QUIT_APP", self.quitApplication),
484
 
        ("SHOW_ABOUT", "on_AboutMenuItem_activate"), ("SHOW_ABOUT", self.showAbout), ("SEARCH", "on_FindMenuItem_activate"),
485
 
        ("TOOL_SEARCH", "on_findToolButton_clicked"), ("REPLACE", "on_ReplaceMenuItem_activate"), ("TOOL_REPLACE", "on_replaceToolButton_clicked"),
486
 
        ("CLEAR_SEARCH", "on_clearHighLightMenuItem_activate"), ("GOTO_LINE", "on_GotoLine_activate"), 
487
 
        ("TOOL_GOTO_LINE", "on_gotoToolbutton_clicked"), ("SELECT_ALL", "on_selectAllMenuItem_activate"), ("COMMENT_LINE", "on_commentMenuitem_activate"),
488
 
        ("SHOW_SUGGESTION", "on_ShowSuggestionMenuitem_activate"), ("INCREASE_INDENT", "on_IndentMenuitem_activate"),
489
 
        ("DECREASE_INDENT", "on_UnindentMenuitem_activate"), ("CLOSE_CURRENT", "on_CloseMenuitem_activate"),
490
 
        #View menu entries
491
 
        ("TOOGLE_MAIN_TOOLBAR", "on_MainToolbarMenuitem_toggled"), ("TOOGLE_MAIN_TOOLBAR", self._toggleMainToolbar),
492
 
        ("TOOGLE_PROJECT_TOOLBAR", "on_ProjectToolbarMenuitem_toggled"), ("TOOGLE_PROJECT_TOOLBAR", self._toggleProjectToolbar),
493
 
        ("TOOGLE_VIEW_TOOLBAR", "on_ViewToolbarMenuitem_toggled"), ("TOOGLE_VIEW_TOOLBAR", self._toggleViewToolbar),
494
 
        ("TOOGLE_DJANGO_TOOLBAR", "on_DjangoMenuitem_toggled"), ("TOOGLE_DJANGO_TOOLBAR", self._toggleDjangoToolbar),
495
 
        ("TOOGLE_FULLSCREEN_TOOL", "on_FullScreenToolButton_clicked"), ("TOOGLE_FULLSCREEN_TOOL", lambda sender: sender.set_active(not sender.get_active())),
496
 
        ("TOOGLE_STATUSBAR", "on_ToggleStatusBarMenuitem_toggled"), ("TOOGLE_STATUSBAR", self._toggleStatusbar),
497
 
        ("TOOGLE_FULLSCREEN", "on_FullScreenMenuitem_toggled"), ("TOOGLE_FULLSCREEN", self._toggleFullScreen),
498
 
        ("MOVE_NEXT_TAB", "on_NextTabMenuitem_activate"), ("MOVE_PREV_TAB", "on_PreviousTabMenuitem_activate"),
499
 
        #Preferences Dialog related signals
500
 
        ("SHOW_PREFERENCES", "on_preferencesMenuItem_activate"), ("SHOW_PREFERENCES", self._managePreferences),
501
 
        #Project related signals
502
 
        ("NEW_PROJECT", "on_NewProjectMenuitem_activate"), ("NEW_PROJECT", self._operations.createNewProject),
503
 
        ("NEW_PROJECT_TOOL", "on_NewProjectToolbutton_clicked"), ("NEW_PROJECT_TOOL", self._operations.createNewProject),
504
 
        ("PROJECT_OPTIONS", "on_ProjectOptionsMenuItem_activate"), ("PROJECT_OPTIONS", self._operations.projectOptions),
505
 
        ("OPEN_PROJECT", "on_OpenProjectMenuitem_activate"), ("OPEN_PROJECT", self._operations.openProject),
506
 
        ("OPEN_PROJECT_TOOL", "on_OpenProjectToolbutton_clicked"), ("OPEN_PROJECT_TOOL", self._operations.openProject),
507
 
        ("RUN_MAINSCRIPT", "on_RunMainScriptMenuitem_activate"), ("RUN_MAINSCRIPT", self._operations.runMainScript),
508
 
        ("RUN_MAINSCRIPT_TOOL", "on_RunMainScriptToolbutton_clicked"), ("RUN_MAINSCRIPT_TOOL", self._operations.runMainScript),
509
 
        ("RUN_CURRSCRIPT", "on_RunCurrentScriptMenuitem_activate"), ("RUN_CURRSCRIPT", self._operations.runCurrentScript),
510
 
        ("RUN_CURRSCRIPT_TOOL", "on_RunCurrentScriptToolbutton_clicked"), ("RUN_CURRSCRIPT_TOOL", self._operations.runCurrentScript),
511
 
        ("CLEAN_PROJECT", "on_ClearProjectMenuitem_activate"), ("CLEAN_PROJECT", self._operations.cleanProject),
512
 
        #Color picker
513
 
        ("TOOL_COLOR_PICKER", "on_ColorPickerMenuitem_activate"), ("TOOL_RE_EVAL", "on_REMenuitem_activate"),
514
 
        ("TOOL_RE_EVAL", self._operations.showReEvaluator))
515
 
        #Refactoring related signals
516
 
        if self._config.getConfig("refactor_enabled"):
517
 
            refactoringSignals = (("EXTRACT_VARIABLE_REFACTORING", "on_ExtractLocalVariableMenuitem_activat"),
518
 
            ("INLINE_VARIABLE_REFACTORING", "on_InlineLocalVariableMenuitem_activate"),
519
 
            ("RENAME_REFACTORING", "on_RenameMenuitem_activate"),
520
 
            ("EXTRACT_METHOD_REFACTORING", "on_ExtractMethodMenuitem_activate"),
521
 
            ("FIND_DEFINITION_REFACTORING", "on_FindDefinitionMenuitem_activate"),
522
 
            ("FIND_REFERENCES_REFACTORING", "on_FindReferencesMenuitem_activate"))
523
 
            signals = signals + refactoringSignals
524
 
        else:
525
 
            self._disbleRefactorFeaturesFromUI()
526
 
        if self._config.getConfig("django_enabled"):
527
 
            #Django
528
 
            djangoSignals = (("NEW_DJANGO_APP", "on_StartAppMenuitem_activate"), ("NEW_DJANGO_APP", self._operations.newDjangoApp),
529
 
            ("NEW_DJANGO_APP_TOOL", "on_NewApplicationToolbutton_clicked"), ("NEW_DJANGO_APP_TOOL", self._operations.newDjangoApp),
530
 
            #Run Server Menu option
531
 
            ("RUN_DJANGO_WS", "on_RunServerMenuitem_activate"), ("RUN_DJANGO_WS", self._operations.runDjangoWS),
532
 
            ("RUN_DJANGO_WS_TOOL", "on_RunDevServerToolbutton_clicked"), ("RUN_DJANGO_WS_TOOL", self._operations.runDjangoWS),
533
 
            #Django Shell Menu option
534
 
            ("RUN_DJANGO_SHELL", "on_DjangoShellMenuitem_activate"), ("RUN_DJANGO_SHELL", self._operations.runDjangoShell),
535
 
            ("RUN_DJANGO_SHELL_TOOL", "on_DjangoShellToolbutton_clicked"), ("RUN_DJANGO_SHELL_TOOL", self._operations.runDjangoShell),
536
 
            #Django SyncDB Menu option
537
 
            ("DJANGO_SYNCDB", "on_DjangoSyncDBMenuitem_activate"), ("DJANGO_SYNCDB", self._operations.djangoSyncDB),
538
 
            ("DJANGO_SYNCDB_TOOL", "on_SyncDBToolbutton_clicked"), ("DJANGO_SYNCDB_TOOL", self._operations.djangoSyncDB),
539
 
            #Django Validate Menu option
540
 
            ("DJANGO_VALIDATE", "on_ValidateMenuitem_activate"), ("DJANGO_VALIDATE", self._operations.djangoValidate),
541
 
            ("DJANGO_VALIDATE_TOOL", "on_ValidateModelToolbutton_clicked"), ("DJANGO_VALIDATE_TOOL", self._operations.djangoValidate),
542
 
            #Django DB Shell Menu option
543
 
            ("DJANGO_DB_SHELL", "on_DjangoDBShellMenuitem_activate"), ("DJANGO_DB_SHELL", self._operations.djangoDBShell),
544
 
            ("DJANGO_DB_SHELL_TOOL", "on_DBShellToolbutton_clicked"), ("DJANGO_DB_SHELL_TOOL", self._operations.djangoDBShell))
545
 
            signals = signals + djangoSignals
546
 
        else:
547
 
            self._disableDjangoFeaturesFromUI()
548
 
        for first, second in signals:
549
 
            if type(second) is str:
550
 
                self.signalConnector.mapCallback(first, second)
551
 
            else:
552
 
                self.signalConnector.registerCallback(first, second)
553
 
 
554
 
 
555
 
def main():
556
 
    try:
557
 
        gtk.gdk.threads_init()
558
 
        localgtk.registerCustomIcons()
559
 
        yape = Yape(sys.argv)
560
 
        gtk.main()
561
 
        gtk.gdk.threads_leave()
562
 
    except ImportError, e:
563
 
        utils.showErrorMessageEx("Dependency error...", 
564
 
                "YaPe've found that your system is missing some dependencies.",
565
 
                "%s. Please install the missing packages and try again." % str(e), e)
566
 
    except Exception, e:
567
 
        utils.showErrorMessageEx("Unknown error...", "Unknown exception raised.",
568
 
                    "%s. This is probably a YaPe's bug, please report." % str(e), e)
569
 
 
570
 
 
571
 
if (__name__ == "__main__"):
572
 
    main()